@djangocfg/ext-newsletter 1.0.2 → 1.0.3

package/dist/hooks.cjs

@@ -0,0 +1,2652 @@
+'use strict';
+
+var consola = require('consola');
+var pRetry = require('p-retry');
+var zod = require('zod');
+var api = require('@djangocfg/ext-base/api');
+var extBase = require('@djangocfg/ext-base');
+var useSWR = require('swr');
+var react = require('react');
+var hooks = require('@djangocfg/ext-base/hooks');
+var jsxRuntime = require('react/jsx-runtime');
+var uiNextjs = require('@djangocfg/ui-nextjs');
+var lucideReact = require('lucide-react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pRetry__default = /*#__PURE__*/_interopDefault(pRetry);
+var useSWR__default = /*#__PURE__*/_interopDefault(useSWR);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter__bulk_email/client.ts
+var ExtNewsletterBulkEmail = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Send Bulk Email
+   * 
+   * Send bulk emails to multiple recipients using base email template.
+   */
+  async newsletterBulkCreate(data) {
+    const response = await this.client.request("POST", "/cfg/newsletter/bulk/", { body: data });
+    return response;
+  }
+};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter__bulk_email/models.ts
+var models_exports = {};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter__campaigns/client.ts
+var ExtNewsletterCampaigns = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List Newsletter Campaigns
+   * 
+   * Get a list of all newsletter campaigns.
+   */
+  async newsletterCampaignsList(...args) {
+    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { page: args[0], page_size: args[1] };
+    }
+    const response = await this.client.request("GET", "/cfg/newsletter/campaigns/", { params });
+    return response;
+  }
+  /**
+   * Create Newsletter Campaign
+   * 
+   * Create a new newsletter campaign.
+   */
+  async newsletterCampaignsCreate(data) {
+    const response = await this.client.request("POST", "/cfg/newsletter/campaigns/", { body: data });
+    return response;
+  }
+  /**
+   * Get Campaign Details
+   * 
+   * Retrieve details of a specific newsletter campaign.
+   */
+  async newsletterCampaignsRetrieve(id) {
+    const response = await this.client.request("GET", `/cfg/newsletter/campaigns/${id}/`);
+    return response;
+  }
+  /**
+   * Update Campaign
+   * 
+   * Update a newsletter campaign.
+   */
+  async newsletterCampaignsUpdate(id, data) {
+    const response = await this.client.request("PUT", `/cfg/newsletter/campaigns/${id}/`, { body: data });
+    return response;
+  }
+  /**
+   * Delete Campaign
+   * 
+   * Delete a newsletter campaign.
+   */
+  async newsletterCampaignsDestroy(id) {
+    await this.client.request("DELETE", `/cfg/newsletter/campaigns/${id}/`);
+    return;
+  }
+  /**
+   * Send Newsletter Campaign
+   * 
+   * Send a newsletter campaign to all subscribers.
+   */
+  async newsletterCampaignsSendCreate(data) {
+    const response = await this.client.request("POST", "/cfg/newsletter/campaigns/send/", { body: data });
+    return response;
+  }
+};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter__campaigns/models.ts
+var models_exports2 = {};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter__logs/client.ts
+var ExtNewsletterLogs = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List Email Logs
+   * 
+   * Get a list of email sending logs.
+   */
+  async newsletterLogsList(...args) {
+    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { page: args[0], page_size: args[1] };
+    }
+    const response = await this.client.request("GET", "/cfg/newsletter/logs/", { params });
+    return response;
+  }
+};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter__logs/models.ts
+var models_exports3 = {};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter__newsletters/client.ts
+var ExtNewsletterNewsletters = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List Active Newsletters
+   * 
+   * Get a list of all active newsletters available for subscription.
+   */
+  async newsletterNewslettersList(...args) {
+    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { page: args[0], page_size: args[1] };
+    }
+    const response = await this.client.request("GET", "/cfg/newsletter/newsletters/", { params });
+    return response;
+  }
+  /**
+   * Get Newsletter Details
+   * 
+   * Retrieve details of a specific newsletter.
+   */
+  async newsletterNewslettersRetrieve(id) {
+    const response = await this.client.request("GET", `/cfg/newsletter/newsletters/${id}/`);
+    return response;
+  }
+};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter__newsletters/models.ts
+var models_exports4 = {};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter__subscriptions/client.ts
+var ExtNewsletterSubscriptions = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Subscribe to Newsletter
+   * 
+   * Subscribe an email address to a newsletter.
+   */
+  async newsletterSubscribeCreate(data) {
+    const response = await this.client.request("POST", "/cfg/newsletter/subscribe/", { body: data });
+    return response;
+  }
+  /**
+   * List User Subscriptions
+   * 
+   * Get a list of current user's active newsletter subscriptions.
+   */
+  async newsletterSubscriptionsList(...args) {
+    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { page: args[0], page_size: args[1] };
+    }
+    const response = await this.client.request("GET", "/cfg/newsletter/subscriptions/", { params });
+    return response;
+  }
+  /**
+   * Unsubscribe from Newsletter
+   * 
+   * Unsubscribe from a newsletter using subscription ID.
+   */
+  async newsletterUnsubscribeCreate(data) {
+    const response = await this.client.request("POST", "/cfg/newsletter/unsubscribe/", { body: data });
+    return response;
+  }
+};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter__subscriptions/models.ts
+var models_exports5 = {};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter__testing/client.ts
+var ExtNewsletterTesting = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Test Email Sending
+   * 
+   * Send a test email to verify mailer configuration.
+   */
+  async newsletterTestCreate(data) {
+    const response = await this.client.request("POST", "/cfg/newsletter/test/", { body: data });
+    return response;
+  }
+};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter__testing/models.ts
+var models_exports6 = {};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter/client.ts
+var ExtNewsletterNewsletter = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Retrieve, update, or delete a newsletter campaign.
+   */
+  async campaignsPartialUpdate(id, data) {
+    const response = await this.client.request("PATCH", `/cfg/newsletter/campaigns/${id}/`, { body: data });
+    return response;
+  }
+  /**
+   * Handle newsletter unsubscriptions.
+   */
+  async unsubscribeUpdate(data) {
+    const response = await this.client.request("PUT", "/cfg/newsletter/unsubscribe/", { body: data });
+    return response;
+  }
+  /**
+   * Handle newsletter unsubscriptions.
+   */
+  async unsubscribePartialUpdate(data) {
+    const response = await this.client.request("PATCH", "/cfg/newsletter/unsubscribe/", { body: data });
+    return response;
+  }
+};
+
+// src/api/generated/ext_newsletter/ext_newsletter__newsletter/models.ts
+var models_exports7 = {};
+
+// src/api/generated/ext_newsletter/http.ts
+var FetchAdapter = class {
+  async request(request) {
+    const { method, url, headers, body, params, formData } = request;
+    let finalUrl = url;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== null && value !== void 0) {
+          searchParams.append(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        finalUrl = url.includes("?") ? `${url}&${queryString}` : `${url}?${queryString}`;
+      }
+    }
+    const finalHeaders = { ...headers };
+    let requestBody;
+    if (formData) {
+      requestBody = formData;
+    } else if (body) {
+      finalHeaders["Content-Type"] = "application/json";
+      requestBody = JSON.stringify(body);
+    }
+    const response = await fetch(finalUrl, {
+      method,
+      headers: finalHeaders,
+      body: requestBody,
+      credentials: "include"
+      // Include Django session cookies
+    });
+    let data = null;
+    const contentType = response.headers.get("content-type");
+    if (response.status !== 204 && contentType?.includes("application/json")) {
+      data = await response.json();
+    } else if (response.status !== 204) {
+      data = await response.text();
+    }
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    return {
+      data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders
+    };
+  }
+};
+
+// src/api/generated/ext_newsletter/errors.ts
+var APIError = class extends Error {
+  constructor(statusCode, statusText, response, url, message) {
+    super(message || `HTTP ${statusCode}: ${statusText}`);
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+    this.response = response;
+    this.url = url;
+    this.name = "APIError";
+  }
+  /**
+   * Get error details from response.
+   * DRF typically returns: { "detail": "Error message" } or { "field": ["error1", "error2"] }
+   */
+  get details() {
+    if (typeof this.response === "object" && this.response !== null) {
+      return this.response;
+    }
+    return null;
+  }
+  /**
+   * Get field-specific validation errors from DRF.
+   * Returns: { "field_name": ["error1", "error2"], ... }
+   */
+  get fieldErrors() {
+    const details = this.details;
+    if (!details) return null;
+    const fieldErrors = {};
+    for (const [key, value] of Object.entries(details)) {
+      if (Array.isArray(value)) {
+        fieldErrors[key] = value;
+      }
+    }
+    return Object.keys(fieldErrors).length > 0 ? fieldErrors : null;
+  }
+  /**
+   * Get single error message from DRF.
+   * Checks for "detail", "message", or first field error.
+   */
+  get errorMessage() {
+    const details = this.details;
+    if (!details) return this.message;
+    if (details.detail) {
+      return Array.isArray(details.detail) ? details.detail.join(", ") : String(details.detail);
+    }
+    if (details.message) {
+      return String(details.message);
+    }
+    const fieldErrors = this.fieldErrors;
+    if (fieldErrors) {
+      const firstField = Object.keys(fieldErrors)[0];
+      if (firstField) {
+        return `${firstField}: ${fieldErrors[firstField]?.join(", ")}`;
+      }
+    }
+    return this.message;
+  }
+  // Helper methods for common HTTP status codes
+  get isValidationError() {
+    return this.statusCode === 400;
+  }
+  get isAuthError() {
+    return this.statusCode === 401;
+  }
+  get isPermissionError() {
+    return this.statusCode === 403;
+  }
+  get isNotFoundError() {
+    return this.statusCode === 404;
+  }
+  get isServerError() {
+    return this.statusCode >= 500 && this.statusCode < 600;
+  }
+};
+var NetworkError = class extends Error {
+  constructor(message, url, originalError) {
+    super(message);
+    this.url = url;
+    this.originalError = originalError;
+    this.name = "NetworkError";
+  }
+};
+var DEFAULT_CONFIG = {
+  enabled: process.env.NODE_ENV !== "production",
+  logRequests: true,
+  logResponses: true,
+  logErrors: true,
+  logBodies: true,
+  logHeaders: false
+};
+var SENSITIVE_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-csrf-token"
+];
+var APILogger = class {
+  config;
+  consola;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.consola = config.consola || consola.createConsola({
+      level: this.config.enabled ? 4 : 0
+    });
+  }
+  /**
+   * Enable logging
+   */
+  enable() {
+    this.config.enabled = true;
+  }
+  /**
+   * Disable logging
+   */
+  disable() {
+    this.config.enabled = false;
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Filter sensitive headers
+   */
+  filterHeaders(headers) {
+    if (!headers) return {};
+    const filtered = {};
+    Object.keys(headers).forEach((key) => {
+      const lowerKey = key.toLowerCase();
+      if (SENSITIVE_HEADERS.includes(lowerKey)) {
+        filtered[key] = "***";
+      } else {
+        filtered[key] = headers[key] || "";
+      }
+    });
+    return filtered;
+  }
+  /**
+   * Log request
+   */
+  logRequest(request) {
+    if (!this.config.enabled || !this.config.logRequests) return;
+    const { method, url, headers, body } = request;
+    this.consola.start(`${method} ${url}`);
+    if (this.config.logHeaders && headers) {
+      this.consola.debug("Headers:", this.filterHeaders(headers));
+    }
+    if (this.config.logBodies && body) {
+      this.consola.debug("Body:", body);
+    }
+  }
+  /**
+   * Log response
+   */
+  logResponse(request, response) {
+    if (!this.config.enabled || !this.config.logResponses) return;
+    const { method, url } = request;
+    const { status, statusText, data, duration } = response;
+    this.consola.success(
+      `${method} ${url} ${status} ${statusText} (${duration}ms)`
+    );
+    if (this.config.logBodies && data) {
+      this.consola.debug("Response:", data);
+    }
+  }
+  /**
+   * Log error
+   */
+  logError(request, error) {
+    if (!this.config.enabled || !this.config.logErrors) return;
+    const { method, url } = request;
+    const { message, statusCode, fieldErrors, duration } = error;
+    this.consola.error(
+      `${method} ${url} ${statusCode || "Network"} Error (${duration}ms)`
+    );
+    this.consola.error("Message:", message);
+    if (fieldErrors && Object.keys(fieldErrors).length > 0) {
+      this.consola.error("Field Errors:");
+      Object.entries(fieldErrors).forEach(([field, errors]) => {
+        errors.forEach((err) => {
+          this.consola.error(`  \u2022 ${field}: ${err}`);
+        });
+      });
+    }
+  }
+  /**
+   * Log general info
+   */
+  info(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.info(message, ...args);
+  }
+  /**
+   * Log warning
+   */
+  warn(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.warn(message, ...args);
+  }
+  /**
+   * Log error
+   */
+  error(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.error(message, ...args);
+  }
+  /**
+   * Log debug
+   */
+  debug(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.debug(message, ...args);
+  }
+  /**
+   * Log success
+   */
+  success(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.success(message, ...args);
+  }
+  /**
+   * Create a sub-logger with prefix
+   */
+  withTag(tag) {
+    return this.consola.withTag(tag);
+  }
+};
+new APILogger();
+var DEFAULT_RETRY_CONFIG = {
+  retries: 3,
+  factor: 2,
+  minTimeout: 1e3,
+  maxTimeout: 6e4,
+  randomize: true,
+  onFailedAttempt: () => {
+  }
+};
+function shouldRetry(error) {
+  if (error instanceof NetworkError) {
+    return true;
+  }
+  if (error instanceof APIError) {
+    const status = error.statusCode;
+    if (status >= 500 && status < 600) {
+      return true;
+    }
+    if (status === 429) {
+      return true;
+    }
+    return false;
+  }
+  return true;
+}
+async function withRetry(fn, config) {
+  const finalConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+  return pRetry__default.default(
+    async () => {
+      try {
+        return await fn();
+      } catch (error) {
+        if (!shouldRetry(error)) {
+          throw new pRetry.AbortError(error);
+        }
+        throw error;
+      }
+    },
+    {
+      retries: finalConfig.retries,
+      factor: finalConfig.factor,
+      minTimeout: finalConfig.minTimeout,
+      maxTimeout: finalConfig.maxTimeout,
+      randomize: finalConfig.randomize,
+      onFailedAttempt: finalConfig.onFailedAttempt ? (error) => {
+        const pRetryError = error;
+        finalConfig.onFailedAttempt({
+          error: pRetryError,
+          attemptNumber: pRetryError.attemptNumber,
+          retriesLeft: pRetryError.retriesLeft
+        });
+      } : void 0
+    }
+  );
+}
+
+// src/api/generated/ext_newsletter/client.ts
+var APIClient = class {
+  baseUrl;
+  httpClient;
+  logger = null;
+  retryConfig = null;
+  // Sub-clients
+  ext_newsletter_bulk_email;
+  ext_newsletter_campaigns;
+  ext_newsletter_logs;
+  ext_newsletter_newsletters;
+  ext_newsletter_subscriptions;
+  ext_newsletter_testing;
+  ext_newsletter_newsletter;
+  constructor(baseUrl, options) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.httpClient = options?.httpClient || new FetchAdapter();
+    if (options?.loggerConfig !== void 0) {
+      this.logger = new APILogger(options.loggerConfig);
+    }
+    if (options?.retryConfig !== void 0) {
+      this.retryConfig = options.retryConfig;
+    }
+    this.ext_newsletter_bulk_email = new ExtNewsletterBulkEmail(this);
+    this.ext_newsletter_campaigns = new ExtNewsletterCampaigns(this);
+    this.ext_newsletter_logs = new ExtNewsletterLogs(this);
+    this.ext_newsletter_newsletters = new ExtNewsletterNewsletters(this);
+    this.ext_newsletter_subscriptions = new ExtNewsletterSubscriptions(this);
+    this.ext_newsletter_testing = new ExtNewsletterTesting(this);
+    this.ext_newsletter_newsletter = new ExtNewsletterNewsletter(this);
+  }
+  /**
+   * Get CSRF token from cookies (for SessionAuthentication).
+   *
+   * Returns null if cookie doesn't exist (JWT-only auth).
+   */
+  getCsrfToken() {
+    const name = "csrftoken";
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) {
+      return parts.pop()?.split(";").shift() || null;
+    }
+    return null;
+  }
+  /**
+   * Make HTTP request with Django CSRF and session handling.
+   * Automatically retries on network errors and 5xx server errors.
+   */
+  async request(method, path, options) {
+    if (this.retryConfig) {
+      return withRetry(() => this._makeRequest(method, path, options), {
+        ...this.retryConfig,
+        onFailedAttempt: (info) => {
+          if (this.logger) {
+            this.logger.warn(
+              `Retry attempt ${info.attemptNumber}/${info.retriesLeft + info.attemptNumber} for ${method} ${path}: ${info.error.message}`
+            );
+          }
+          this.retryConfig?.onFailedAttempt?.(info);
+        }
+      });
+    }
+    return this._makeRequest(method, path, options);
+  }
+  /**
+   * Internal request method (without retry wrapper).
+   * Used by request() method with optional retry logic.
+   */
+  async _makeRequest(method, path, options) {
+    const url = this.baseUrl ? `${this.baseUrl}${path}` : path;
+    const startTime = Date.now();
+    const headers = {
+      ...options?.headers || {}
+    };
+    if (!options?.formData && !headers["Content-Type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (this.logger) {
+      this.logger.logRequest({
+        method,
+        url,
+        headers,
+        body: options?.formData || options?.body,
+        timestamp: startTime
+      });
+    }
+    try {
+      const response = await this.httpClient.request({
+        method,
+        url,
+        headers,
+        params: options?.params,
+        body: options?.body,
+        formData: options?.formData
+      });
+      const duration = Date.now() - startTime;
+      if (response.status >= 400) {
+        const error = new APIError(
+          response.status,
+          response.statusText,
+          response.data,
+          url
+        );
+        if (this.logger) {
+          this.logger.logError(
+            {
+              method,
+              url,
+              headers,
+              body: options?.formData || options?.body,
+              timestamp: startTime
+            },
+            {
+              message: error.message,
+              statusCode: response.status,
+              duration,
+              timestamp: Date.now()
+            }
+          );
+        }
+        throw error;
+      }
+      if (this.logger) {
+        this.logger.logResponse(
+          {
+            method,
+            url,
+            headers,
+            body: options?.formData || options?.body,
+            timestamp: startTime
+          },
+          {
+            status: response.status,
+            statusText: response.statusText,
+            data: response.data,
+            duration,
+            timestamp: Date.now()
+          }
+        );
+      }
+      return response.data;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      if (error instanceof APIError) {
+        throw error;
+      }
+      const isCORSError = error instanceof TypeError && (error.message.toLowerCase().includes("cors") || error.message.toLowerCase().includes("failed to fetch") || error.message.toLowerCase().includes("network request failed"));
+      if (this.logger) {
+        if (isCORSError) {
+          this.logger.error(`\u{1F6AB} CORS Error: ${method} ${url}`);
+          this.logger.error(`  \u2192 ${error instanceof Error ? error.message : String(error)}`);
+          this.logger.error(`  \u2192 Configure security_domains parameter on the server`);
+        } else {
+          this.logger.error(`\u26A0\uFE0F  Network Error: ${method} ${url}`);
+          this.logger.error(`  \u2192 ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      if (typeof window !== "undefined") {
+        try {
+          if (isCORSError) {
+            window.dispatchEvent(new CustomEvent("cors-error", {
+              detail: {
+                url,
+                method,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: /* @__PURE__ */ new Date()
+              },
+              bubbles: true,
+              cancelable: false
+            }));
+          } else {
+            window.dispatchEvent(new CustomEvent("network-error", {
+              detail: {
+                url,
+                method,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: /* @__PURE__ */ new Date()
+              },
+              bubbles: true,
+              cancelable: false
+            }));
+          }
+        } catch (eventError) {
+        }
+      }
+      const networkError = error instanceof Error ? new NetworkError(error.message, url, error) : new NetworkError("Unknown error", url);
+      if (this.logger) {
+        this.logger.logError(
+          {
+            method,
+            url,
+            headers,
+            body: options?.formData || options?.body,
+            timestamp: startTime
+          },
+          {
+            message: networkError.message,
+            duration,
+            timestamp: Date.now()
+          }
+        );
+      }
+      throw networkError;
+    }
+  }
+};
+
+// src/api/generated/ext_newsletter/storage.ts
+var LocalStorageAdapter = class {
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  getItem(key) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        const value = localStorage.getItem(key);
+        this.logger?.debug(`LocalStorage.getItem("${key}"): ${value ? "found" : "not found"}`);
+        return value;
+      }
+      this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
+    } catch (error) {
+      this.logger?.error("LocalStorage.getItem failed:", error);
+    }
+    return null;
+  }
+  setItem(key, value) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        localStorage.setItem(key, value);
+        this.logger?.debug(`LocalStorage.setItem("${key}"): success`);
+      } else {
+        this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
+      }
+    } catch (error) {
+      this.logger?.error("LocalStorage.setItem failed:", error);
+    }
+  }
+  removeItem(key) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        localStorage.removeItem(key);
+        this.logger?.debug(`LocalStorage.removeItem("${key}"): success`);
+      } else {
+        this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
+      }
+    } catch (error) {
+      this.logger?.error("LocalStorage.removeItem failed:", error);
+    }
+  }
+};
+var CookieStorageAdapter = class {
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  getItem(key) {
+    try {
+      if (typeof document === "undefined") {
+        this.logger?.warn("Cookies not available: document is undefined (SSR context?)");
+        return null;
+      }
+      const value = `; ${document.cookie}`;
+      const parts = value.split(`; ${key}=`);
+      if (parts.length === 2) {
+        const result = parts.pop()?.split(";").shift() || null;
+        this.logger?.debug(`CookieStorage.getItem("${key}"): ${result ? "found" : "not found"}`);
+        return result;
+      }
+      this.logger?.debug(`CookieStorage.getItem("${key}"): not found`);
+    } catch (error) {
+      this.logger?.error("CookieStorage.getItem failed:", error);
+    }
+    return null;
+  }
+  setItem(key, value) {
+    try {
+      if (typeof document !== "undefined") {
+        document.cookie = `${key}=${value}; path=/; max-age=31536000`;
+        this.logger?.debug(`CookieStorage.setItem("${key}"): success`);
+      } else {
+        this.logger?.warn("Cookies not available: document is undefined (SSR context?)");
+      }
+    } catch (error) {
+      this.logger?.error("CookieStorage.setItem failed:", error);
+    }
+  }
+  removeItem(key) {
+    try {
+      if (typeof document !== "undefined") {
+        document.cookie = `${key}=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+        this.logger?.debug(`CookieStorage.removeItem("${key}"): success`);
+      } else {
+        this.logger?.warn("Cookies not available: document is undefined (SSR context?)");
+      }
+    } catch (error) {
+      this.logger?.error("CookieStorage.removeItem failed:", error);
+    }
+  }
+};
+var MemoryStorageAdapter = class {
+  storage = /* @__PURE__ */ new Map();
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  getItem(key) {
+    const value = this.storage.get(key) || null;
+    this.logger?.debug(`MemoryStorage.getItem("${key}"): ${value ? "found" : "not found"}`);
+    return value;
+  }
+  setItem(key, value) {
+    this.storage.set(key, value);
+    this.logger?.debug(`MemoryStorage.setItem("${key}"): success`);
+  }
+  removeItem(key) {
+    this.storage.delete(key);
+    this.logger?.debug(`MemoryStorage.removeItem("${key}"): success`);
+  }
+};
+
+// src/api/generated/ext_newsletter/enums.ts
+var enums_exports = {};
+__export(enums_exports, {
+  EmailLogStatus: () => EmailLogStatus,
+  NewsletterCampaignStatus: () => NewsletterCampaignStatus
+});
+var EmailLogStatus = /* @__PURE__ */ ((EmailLogStatus2) => {
+  EmailLogStatus2["PENDING"] = "pending";
+  EmailLogStatus2["SENT"] = "sent";
+  EmailLogStatus2["FAILED"] = "failed";
+  return EmailLogStatus2;
+})(EmailLogStatus || {});
+var NewsletterCampaignStatus = /* @__PURE__ */ ((NewsletterCampaignStatus2) => {
+  NewsletterCampaignStatus2["DRAFT"] = "draft";
+  NewsletterCampaignStatus2["SENDING"] = "sending";
+  NewsletterCampaignStatus2["SENT"] = "sent";
+  NewsletterCampaignStatus2["FAILED"] = "failed";
+  return NewsletterCampaignStatus2;
+})(NewsletterCampaignStatus || {});
+
+// src/api/generated/ext_newsletter/_utils/schemas/index.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  BulkEmailRequestSchema: () => BulkEmailRequestSchema,
+  BulkEmailResponseSchema: () => BulkEmailResponseSchema,
+  EmailLogSchema: () => EmailLogSchema,
+  ErrorResponseSchema: () => ErrorResponseSchema,
+  NewsletterCampaignRequestSchema: () => NewsletterCampaignRequestSchema,
+  NewsletterCampaignSchema: () => NewsletterCampaignSchema,
+  NewsletterSchema: () => NewsletterSchema,
+  NewsletterSubscriptionSchema: () => NewsletterSubscriptionSchema,
+  PaginatedEmailLogListSchema: () => PaginatedEmailLogListSchema,
+  PaginatedNewsletterCampaignListSchema: () => PaginatedNewsletterCampaignListSchema,
+  PaginatedNewsletterListSchema: () => PaginatedNewsletterListSchema,
+  PaginatedNewsletterSubscriptionListSchema: () => PaginatedNewsletterSubscriptionListSchema,
+  PatchedNewsletterCampaignRequestSchema: () => PatchedNewsletterCampaignRequestSchema,
+  PatchedUnsubscribeRequestSchema: () => PatchedUnsubscribeRequestSchema,
+  SendCampaignRequestSchema: () => SendCampaignRequestSchema,
+  SendCampaignResponseSchema: () => SendCampaignResponseSchema,
+  SubscribeRequestSchema: () => SubscribeRequestSchema,
+  SubscribeResponseSchema: () => SubscribeResponseSchema,
+  SuccessResponseSchema: () => SuccessResponseSchema,
+  TestEmailRequestSchema: () => TestEmailRequestSchema,
+  UnsubscribeRequestSchema: () => UnsubscribeRequestSchema,
+  UnsubscribeSchema: () => UnsubscribeSchema
+});
+var BulkEmailRequestSchema = zod.z.object({
+  recipients: zod.z.array(zod.z.email()),
+  subject: zod.z.string().min(1).max(255),
+  email_title: zod.z.string().min(1).max(255),
+  main_text: zod.z.string().min(1),
+  main_html_content: zod.z.string().optional(),
+  button_text: zod.z.string().max(100).optional(),
+  button_url: zod.z.url().optional(),
+  secondary_text: zod.z.string().optional()
+});
+var BulkEmailResponseSchema = zod.z.object({
+  success: zod.z.boolean(),
+  sent_count: zod.z.int(),
+  failed_count: zod.z.int(),
+  total_recipients: zod.z.int(),
+  error: zod.z.string().optional()
+});
+var EmailLogSchema = zod.z.object({
+  id: zod.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  user: zod.z.int().nullable(),
+  user_email: zod.z.string(),
+  newsletter: zod.z.int().nullable(),
+  newsletter_title: zod.z.string(),
+  recipient: zod.z.string(),
+  subject: zod.z.string(),
+  body: zod.z.string(),
+  status: zod.z.nativeEnum(EmailLogStatus),
+  created_at: zod.z.iso.datetime(),
+  sent_at: zod.z.iso.datetime().nullable(),
+  error_message: zod.z.string().nullable()
+});
+var ErrorResponseSchema = zod.z.object({
+  success: zod.z.boolean().optional(),
+  message: zod.z.string()
+});
+var NewsletterSchema = zod.z.object({
+  id: zod.z.int(),
+  title: zod.z.string().max(255),
+  description: zod.z.string().optional(),
+  is_active: zod.z.boolean().optional(),
+  auto_subscribe: zod.z.boolean().optional(),
+  created_at: zod.z.iso.datetime(),
+  updated_at: zod.z.iso.datetime(),
+  subscribers_count: zod.z.int()
+});
+var NewsletterCampaignSchema = zod.z.object({
+  id: zod.z.int(),
+  newsletter: zod.z.int(),
+  newsletter_title: zod.z.string(),
+  subject: zod.z.string().max(255),
+  email_title: zod.z.string().max(255),
+  main_text: zod.z.string(),
+  main_html_content: zod.z.string().optional(),
+  button_text: zod.z.string().max(100).optional(),
+  button_url: zod.z.url().optional(),
+  secondary_text: zod.z.string().optional(),
+  status: zod.z.nativeEnum(NewsletterCampaignStatus),
+  created_at: zod.z.iso.datetime(),
+  sent_at: zod.z.iso.datetime().nullable(),
+  recipient_count: zod.z.int()
+});
+var NewsletterCampaignRequestSchema = zod.z.object({
+  newsletter: zod.z.int(),
+  subject: zod.z.string().min(1).max(255),
+  email_title: zod.z.string().min(1).max(255),
+  main_text: zod.z.string().min(1),
+  main_html_content: zod.z.string().optional(),
+  button_text: zod.z.string().max(100).optional(),
+  button_url: zod.z.url().optional(),
+  secondary_text: zod.z.string().optional()
+});
+var NewsletterSubscriptionSchema = zod.z.object({
+  id: zod.z.int(),
+  newsletter: zod.z.int(),
+  newsletter_title: zod.z.string(),
+  user: zod.z.int().nullable().optional(),
+  user_email: zod.z.string(),
+  email: zod.z.email(),
+  is_active: zod.z.boolean().optional(),
+  subscribed_at: zod.z.iso.datetime(),
+  unsubscribed_at: zod.z.iso.datetime().nullable()
+});
+var PaginatedEmailLogListSchema = zod.z.object({
+  count: zod.z.int(),
+  page: zod.z.int(),
+  pages: zod.z.int(),
+  page_size: zod.z.int(),
+  has_next: zod.z.boolean(),
+  has_previous: zod.z.boolean(),
+  next_page: zod.z.int().nullable().optional(),
+  previous_page: zod.z.int().nullable().optional(),
+  results: zod.z.array(EmailLogSchema)
+});
+var PaginatedNewsletterCampaignListSchema = zod.z.object({
+  count: zod.z.int(),
+  page: zod.z.int(),
+  pages: zod.z.int(),
+  page_size: zod.z.int(),
+  has_next: zod.z.boolean(),
+  has_previous: zod.z.boolean(),
+  next_page: zod.z.int().nullable().optional(),
+  previous_page: zod.z.int().nullable().optional(),
+  results: zod.z.array(NewsletterCampaignSchema)
+});
+var PaginatedNewsletterListSchema = zod.z.object({
+  count: zod.z.int(),
+  page: zod.z.int(),
+  pages: zod.z.int(),
+  page_size: zod.z.int(),
+  has_next: zod.z.boolean(),
+  has_previous: zod.z.boolean(),
+  next_page: zod.z.int().nullable().optional(),
+  previous_page: zod.z.int().nullable().optional(),
+  results: zod.z.array(NewsletterSchema)
+});
+var PaginatedNewsletterSubscriptionListSchema = zod.z.object({
+  count: zod.z.int(),
+  page: zod.z.int(),
+  pages: zod.z.int(),
+  page_size: zod.z.int(),
+  has_next: zod.z.boolean(),
+  has_previous: zod.z.boolean(),
+  next_page: zod.z.int().nullable().optional(),
+  previous_page: zod.z.int().nullable().optional(),
+  results: zod.z.array(NewsletterSubscriptionSchema)
+});
+var PatchedNewsletterCampaignRequestSchema = zod.z.object({
+  newsletter: zod.z.int().optional(),
+  subject: zod.z.string().min(1).max(255).optional(),
+  email_title: zod.z.string().min(1).max(255).optional(),
+  main_text: zod.z.string().min(1).optional(),
+  main_html_content: zod.z.string().optional(),
+  button_text: zod.z.string().max(100).optional(),
+  button_url: zod.z.url().optional(),
+  secondary_text: zod.z.string().optional()
+});
+var PatchedUnsubscribeRequestSchema = zod.z.object({
+  subscription_id: zod.z.int().optional()
+});
+var SendCampaignRequestSchema = zod.z.object({
+  campaign_id: zod.z.int()
+});
+var SendCampaignResponseSchema = zod.z.object({
+  success: zod.z.boolean(),
+  message: zod.z.string().optional(),
+  sent_count: zod.z.int().optional(),
+  error: zod.z.string().optional()
+});
+var SubscribeRequestSchema = zod.z.object({
+  newsletter_id: zod.z.int(),
+  email: zod.z.email()
+});
+var SubscribeResponseSchema = zod.z.object({
+  success: zod.z.boolean(),
+  message: zod.z.string(),
+  subscription_id: zod.z.int().optional()
+});
+var SuccessResponseSchema = zod.z.object({
+  success: zod.z.boolean(),
+  message: zod.z.string()
+});
+var TestEmailRequestSchema = zod.z.object({
+  email: zod.z.email(),
+  subject: zod.z.string().min(1).max(255).optional(),
+  message: zod.z.string().min(1).optional()
+});
+var UnsubscribeSchema = zod.z.object({
+  subscription_id: zod.z.int()
+});
+var UnsubscribeRequestSchema = zod.z.object({
+  subscription_id: zod.z.int()
+});
+
+// src/api/generated/ext_newsletter/validation-events.ts
+function dispatchValidationError(detail) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  try {
+    const event = new CustomEvent("zod-validation-error", {
+      detail,
+      bubbles: true,
+      cancelable: false
+    });
+    window.dispatchEvent(event);
+  } catch (error) {
+    console.warn("Failed to dispatch validation error event:", error);
+  }
+}
+function onValidationError(callback) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const handler = (event) => {
+    if (event instanceof CustomEvent) {
+      callback(event.detail);
+    }
+  };
+  window.addEventListener("zod-validation-error", handler);
+  return () => {
+    window.removeEventListener("zod-validation-error", handler);
+  };
+}
+function formatZodError(error) {
+  const issues = error.issues.map((issue, index) => {
+    const path = issue.path.join(".") || "root";
+    const parts = [`${index + 1}. ${path}: ${issue.message}`];
+    if ("expected" in issue && issue.expected) {
+      parts.push(`   Expected: ${issue.expected}`);
+    }
+    if ("received" in issue && issue.received) {
+      parts.push(`   Received: ${issue.received}`);
+    }
+    return parts.join("\n");
+  });
+  return issues.join("\n");
+}
+
+// src/api/generated/ext_newsletter/_utils/fetchers/index.ts
+var fetchers_exports = {};
+__export(fetchers_exports, {
+  createNewsletterBulkCreate: () => createNewsletterBulkCreate,
+  createNewsletterCampaignsCreate: () => createNewsletterCampaignsCreate,
+  createNewsletterCampaignsSendCreate: () => createNewsletterCampaignsSendCreate,
+  createNewsletterSubscribeCreate: () => createNewsletterSubscribeCreate,
+  createNewsletterTestCreate: () => createNewsletterTestCreate,
+  createNewsletterUnsubscribeCreate: () => createNewsletterUnsubscribeCreate,
+  deleteNewsletterCampaignsDestroy: () => deleteNewsletterCampaignsDestroy,
+  getNewsletterCampaignsList: () => getNewsletterCampaignsList,
+  getNewsletterCampaignsRetrieve: () => getNewsletterCampaignsRetrieve,
+  getNewsletterLogsList: () => getNewsletterLogsList,
+  getNewsletterNewslettersList: () => getNewsletterNewslettersList,
+  getNewsletterNewslettersRetrieve: () => getNewsletterNewslettersRetrieve,
+  getNewsletterSubscriptionsList: () => getNewsletterSubscriptionsList,
+  partialUpdateNewsletterCampaignsPartialUpdate: () => partialUpdateNewsletterCampaignsPartialUpdate,
+  partialUpdateNewsletterUnsubscribePartialUpdate: () => partialUpdateNewsletterUnsubscribePartialUpdate,
+  updateNewsletterCampaignsUpdate: () => updateNewsletterCampaignsUpdate,
+  updateNewsletterUnsubscribeUpdate: () => updateNewsletterUnsubscribeUpdate
+});
+
+// src/api/generated/ext_newsletter/api-instance.ts
+var globalAPI = null;
+function getAPIInstance() {
+  if (!globalAPI) {
+    throw new Error(
+      'API not configured. Call configureAPI() with your base URL before using fetchers or hooks.\n\nExample:\n  import { configureAPI } from "./api-instance"\n  configureAPI({ baseUrl: "https://api.example.com" })'
+    );
+  }
+  return globalAPI;
+}
+function isAPIConfigured() {
+  return globalAPI !== null;
+}
+function configureAPI(config) {
+  globalAPI = new API(config.baseUrl, config.options);
+  if (config.token) {
+    globalAPI.setToken(config.token, config.refreshToken);
+  }
+  return globalAPI;
+}
+function reconfigureAPI(updates) {
+  const instance = getAPIInstance();
+  if (updates.baseUrl) {
+    instance.setBaseUrl(updates.baseUrl);
+  }
+  if (updates.token) {
+    instance.setToken(updates.token, updates.refreshToken);
+  }
+  return instance;
+}
+function clearAPITokens() {
+  const instance = getAPIInstance();
+  instance.clearTokens();
+}
+function resetAPI() {
+  if (globalAPI) {
+    globalAPI.clearTokens();
+  }
+  globalAPI = null;
+}
+
+// src/api/generated/ext_newsletter/_utils/fetchers/ext_newsletter__newsletter.ts
+async function partialUpdateNewsletterCampaignsPartialUpdate(id, data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_newsletter.campaignsPartialUpdate(id, data);
+  try {
+    return NewsletterCampaignSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`partialUpdateNewsletterCampaignsPartialUpdate
+Path: /cfg/newsletter/campaigns/{id}/
+Method: PATCH`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "partialUpdateNewsletterCampaignsPartialUpdate",
+            path: "/cfg/newsletter/campaigns/{id}/",
+            method: "PATCH",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function updateNewsletterUnsubscribeUpdate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_newsletter.unsubscribeUpdate(data);
+  try {
+    return UnsubscribeSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`updateNewsletterUnsubscribeUpdate
+Path: /cfg/newsletter/unsubscribe/
+Method: PUT`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "updateNewsletterUnsubscribeUpdate",
+            path: "/cfg/newsletter/unsubscribe/",
+            method: "PUT",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function partialUpdateNewsletterUnsubscribePartialUpdate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_newsletter.unsubscribePartialUpdate(data);
+  try {
+    return UnsubscribeSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`partialUpdateNewsletterUnsubscribePartialUpdate
+Path: /cfg/newsletter/unsubscribe/
+Method: PATCH`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "partialUpdateNewsletterUnsubscribePartialUpdate",
+            path: "/cfg/newsletter/unsubscribe/",
+            method: "PATCH",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function createNewsletterBulkCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_bulk_email.newsletterBulkCreate(data);
+  try {
+    return BulkEmailResponseSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`createNewsletterBulkCreate
+Path: /cfg/newsletter/bulk/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createNewsletterBulkCreate",
+            path: "/cfg/newsletter/bulk/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function getNewsletterCampaignsList(params, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_campaigns.newsletterCampaignsList(params?.page, params?.page_size);
+  try {
+    return PaginatedNewsletterCampaignListSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getNewsletterCampaignsList
+Path: /cfg/newsletter/campaigns/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getNewsletterCampaignsList",
+            path: "/cfg/newsletter/campaigns/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function createNewsletterCampaignsCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_campaigns.newsletterCampaignsCreate(data);
+  try {
+    return NewsletterCampaignSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`createNewsletterCampaignsCreate
+Path: /cfg/newsletter/campaigns/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createNewsletterCampaignsCreate",
+            path: "/cfg/newsletter/campaigns/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function getNewsletterCampaignsRetrieve(id, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_campaigns.newsletterCampaignsRetrieve(id);
+  try {
+    return NewsletterCampaignSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getNewsletterCampaignsRetrieve
+Path: /cfg/newsletter/campaigns/{id}/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getNewsletterCampaignsRetrieve",
+            path: "/cfg/newsletter/campaigns/{id}/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function updateNewsletterCampaignsUpdate(id, data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_campaigns.newsletterCampaignsUpdate(id, data);
+  try {
+    return NewsletterCampaignSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`updateNewsletterCampaignsUpdate
+Path: /cfg/newsletter/campaigns/{id}/
+Method: PUT`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "updateNewsletterCampaignsUpdate",
+            path: "/cfg/newsletter/campaigns/{id}/",
+            method: "PUT",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function deleteNewsletterCampaignsDestroy(id, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_campaigns.newsletterCampaignsDestroy(id);
+  return response;
+}
+async function createNewsletterCampaignsSendCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_campaigns.newsletterCampaignsSendCreate(data);
+  try {
+    return SendCampaignResponseSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`createNewsletterCampaignsSendCreate
+Path: /cfg/newsletter/campaigns/send/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createNewsletterCampaignsSendCreate",
+            path: "/cfg/newsletter/campaigns/send/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function getNewsletterLogsList(params, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_logs.newsletterLogsList(params?.page, params?.page_size);
+  try {
+    return PaginatedEmailLogListSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getNewsletterLogsList
+Path: /cfg/newsletter/logs/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getNewsletterLogsList",
+            path: "/cfg/newsletter/logs/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function getNewsletterNewslettersList(params, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_newsletters.newsletterNewslettersList(params?.page, params?.page_size);
+  try {
+    return PaginatedNewsletterListSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getNewsletterNewslettersList
+Path: /cfg/newsletter/newsletters/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getNewsletterNewslettersList",
+            path: "/cfg/newsletter/newsletters/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function getNewsletterNewslettersRetrieve(id, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_newsletters.newsletterNewslettersRetrieve(id);
+  try {
+    return NewsletterSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getNewsletterNewslettersRetrieve
+Path: /cfg/newsletter/newsletters/{id}/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getNewsletterNewslettersRetrieve",
+            path: "/cfg/newsletter/newsletters/{id}/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function createNewsletterSubscribeCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_subscriptions.newsletterSubscribeCreate(data);
+  try {
+    return SubscribeResponseSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`createNewsletterSubscribeCreate
+Path: /cfg/newsletter/subscribe/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createNewsletterSubscribeCreate",
+            path: "/cfg/newsletter/subscribe/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function getNewsletterSubscriptionsList(params, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_subscriptions.newsletterSubscriptionsList(params?.page, params?.page_size);
+  try {
+    return PaginatedNewsletterSubscriptionListSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getNewsletterSubscriptionsList
+Path: /cfg/newsletter/subscriptions/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getNewsletterSubscriptionsList",
+            path: "/cfg/newsletter/subscriptions/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function createNewsletterUnsubscribeCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_subscriptions.newsletterUnsubscribeCreate(data);
+  try {
+    return SuccessResponseSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`createNewsletterUnsubscribeCreate
+Path: /cfg/newsletter/unsubscribe/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createNewsletterUnsubscribeCreate",
+            path: "/cfg/newsletter/unsubscribe/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function createNewsletterTestCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_newsletter_testing.newsletterTestCreate(data);
+  try {
+    return BulkEmailResponseSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`createNewsletterTestCreate
+Path: /cfg/newsletter/test/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createNewsletterTestCreate",
+            path: "/cfg/newsletter/test/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+
+// src/api/generated/ext_newsletter/index.ts
+var TOKEN_KEY = "auth_token";
+var REFRESH_TOKEN_KEY = "refresh_token";
+var API = class {
+  baseUrl;
+  _client;
+  _token = null;
+  _refreshToken = null;
+  storage;
+  options;
+  // Sub-clients
+  ext_newsletter_bulk_email;
+  ext_newsletter_campaigns;
+  ext_newsletter_logs;
+  ext_newsletter_newsletters;
+  ext_newsletter_subscriptions;
+  ext_newsletter_testing;
+  ext_newsletter_newsletter;
+  constructor(baseUrl, options) {
+    this.baseUrl = baseUrl;
+    this.options = options;
+    const logger2 = options?.loggerConfig ? new APILogger(options.loggerConfig) : void 0;
+    this.storage = options?.storage || new LocalStorageAdapter(logger2);
+    this._loadTokensFromStorage();
+    this._client = new APIClient(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig
+    });
+    this._injectAuthHeader();
+    this.ext_newsletter_bulk_email = this._client.ext_newsletter_bulk_email;
+    this.ext_newsletter_campaigns = this._client.ext_newsletter_campaigns;
+    this.ext_newsletter_logs = this._client.ext_newsletter_logs;
+    this.ext_newsletter_newsletters = this._client.ext_newsletter_newsletters;
+    this.ext_newsletter_subscriptions = this._client.ext_newsletter_subscriptions;
+    this.ext_newsletter_testing = this._client.ext_newsletter_testing;
+    this.ext_newsletter_newsletter = this._client.ext_newsletter_newsletter;
+  }
+  _loadTokensFromStorage() {
+    this._token = this.storage.getItem(TOKEN_KEY);
+    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+  _reinitClients() {
+    this._client = new APIClient(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig
+    });
+    this._injectAuthHeader();
+    this.ext_newsletter_bulk_email = this._client.ext_newsletter_bulk_email;
+    this.ext_newsletter_campaigns = this._client.ext_newsletter_campaigns;
+    this.ext_newsletter_logs = this._client.ext_newsletter_logs;
+    this.ext_newsletter_newsletters = this._client.ext_newsletter_newsletters;
+    this.ext_newsletter_subscriptions = this._client.ext_newsletter_subscriptions;
+    this.ext_newsletter_testing = this._client.ext_newsletter_testing;
+    this.ext_newsletter_newsletter = this._client.ext_newsletter_newsletter;
+  }
+  _injectAuthHeader() {
+    const originalRequest = this._client.request.bind(this._client);
+    this._client.request = async (method, path, options) => {
+      const token = this.getToken();
+      const mergedOptions = {
+        ...options,
+        headers: {
+          ...options?.headers || {},
+          ...token ? { "Authorization": `Bearer ${token}` } : {}
+        }
+      };
+      return originalRequest(method, path, mergedOptions);
+    };
+  }
+  /**
+   * Get current JWT token
+   */
+  getToken() {
+    return this.storage.getItem(TOKEN_KEY);
+  }
+  /**
+   * Get current refresh token
+   */
+  getRefreshToken() {
+    return this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+  /**
+   * Set JWT token and refresh token
+   * @param token - JWT access token
+   * @param refreshToken - JWT refresh token (optional)
+   */
+  setToken(token, refreshToken) {
+    this._token = token;
+    this.storage.setItem(TOKEN_KEY, token);
+    if (refreshToken) {
+      this._refreshToken = refreshToken;
+      this.storage.setItem(REFRESH_TOKEN_KEY, refreshToken);
+    }
+    this._reinitClients();
+  }
+  /**
+   * Clear all tokens
+   */
+  clearTokens() {
+    this._token = null;
+    this._refreshToken = null;
+    this.storage.removeItem(TOKEN_KEY);
+    this.storage.removeItem(REFRESH_TOKEN_KEY);
+    this._reinitClients();
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return !!this.getToken();
+  }
+  /**
+   * Update base URL and reinitialize clients
+   * @param url - New base URL
+   */
+  setBaseUrl(url) {
+    this.baseUrl = url;
+    this._reinitClients();
+  }
+  /**
+   * Get current base URL
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Get OpenAPI schema path
+   * @returns Path to the OpenAPI schema JSON file
+   *
+   * Note: The OpenAPI schema is available in the schema.json file.
+   * You can load it dynamically using:
+   * ```typescript
+   * const schema = await fetch('./schema.json').then(r => r.json());
+   * // or using fs in Node.js:
+   * // const schema = JSON.parse(fs.readFileSync('./schema.json', 'utf-8'));
+   * ```
+   */
+  getSchemaPath() {
+    return "./schema.json";
+  }
+};
+var apiNewsletter = api.createExtensionAPI(API);
+
+// package.json
+var package_default = {
+  name: "@djangocfg/ext-newsletter",
+  version: "1.0.3",
+  description: "Newsletter and subscription management extension for DjangoCFG",
+  keywords: [
+    "django",
+    "djangocfg",
+    "extension",
+    "newsletter",
+    "subscription",
+    "email",
+    "marketing",
+    "typescript",
+    "react"
+  ],
+  author: {
+    name: "DjangoCFG",
+    url: "https://djangocfg.com"
+  },
+  homepage: "https://hub.djangocfg.com/extensions/djangocfg-ext-newsletter",
+  repository: {
+    type: "git",
+    url: "https://github.com/markolofsen/django-cfg.git",
+    directory: "extensions/newsletter"
+  },
+  bugs: {
+    url: "https://github.com/markolofsen/django-cfg/issues"
+  },
+  license: "MIT",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    },
+    "./hooks": {
+      types: "./dist/hooks.d.ts",
+      import: "./dist/hooks.js",
+      require: "./dist/hooks.cjs"
+    },
+    "./config": {
+      types: "./dist/config.d.ts",
+      import: "./dist/config.js",
+      require: "./dist/config.cjs"
+    }
+  },
+  files: [
+    "dist",
+    "src",
+    "preview.png"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    check: "tsc --noEmit"
+  },
+  peerDependencies: {
+    "@djangocfg/api": "workspace:*",
+    "@djangocfg/ext-base": "workspace:*",
+    "@djangocfg/ui-nextjs": "workspace:*",
+    consola: "^3.4.2",
+    "lucide-react": "^0.545.0",
+    next: "^15.5.7",
+    "p-retry": "^7.0.0",
+    react: "^18 || ^19",
+    "react-dom": "^18 || ^19",
+    swr: "^2.3.7",
+    zod: "^4.1.13"
+  },
+  devDependencies: {
+    "@djangocfg/api": "workspace:*",
+    "@djangocfg/ext-base": "workspace:*",
+    "@djangocfg/typescript-config": "workspace:*",
+    "@types/node": "^24.7.2",
+    "@types/react": "^19.0.0",
+    consola: "^3.4.2",
+    "p-retry": "^7.0.0",
+    swr: "^2.3.7",
+    tsup: "^8.5.0",
+    typescript: "^5.9.3"
+  }
+};
+
+// src/config.ts
+var extensionConfig = extBase.createExtensionConfig(package_default, {
+  name: "newsletter",
+  displayName: "Newsletter & Campaigns",
+  category: "content",
+  features: [
+    "Subscription management",
+    "Email template system",
+    "Campaign tracking",
+    "Subscriber segmentation",
+    "Analytics dashboard",
+    "Automated campaigns"
+  ],
+  minVersion: "2.0.0",
+  examples: [
+    {
+      title: "Newsletter Subscription Form",
+      description: "Add a newsletter signup form",
+      code: `import { NewsletterForm } from '@djangocfg/ext-newsletter';
+
+export default function Footer() {
+  return (
+    <NewsletterForm
+      onSubscribe={(email) => {
+        console.log('New subscriber:', email);
+      }}
+      texts={{
+        placeholder: 'Enter your email',
+        button: 'Subscribe',
+        success: 'Thanks for subscribing!',
+      }}
+    />
+  );
+}`,
+      language: "tsx"
+    }
+  ]
+});
+function useCreateNewsletterBulkCreate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (data, client) => {
+    const result = await createNewsletterBulkCreate(data, client);
+    mutate("cfg-newsletter-bulk");
+    return result;
+  };
+}
+function useNewsletterCampaignsList(params, client) {
+  return useSWR__default.default(
+    params ? ["cfg-newsletter-campaigns", params] : "cfg-newsletter-campaigns",
+    () => getNewsletterCampaignsList(params, client)
+  );
+}
+function useCreateNewsletterCampaignsCreate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (data, client) => {
+    const result = await createNewsletterCampaignsCreate(data, client);
+    mutate("cfg-newsletter-campaigns");
+    return result;
+  };
+}
+function useNewsletterCampaignsRetrieve(id, client) {
+  return useSWR__default.default(
+    ["cfg-newsletter-campaign", id],
+    () => getNewsletterCampaignsRetrieve(id, client)
+  );
+}
+function useUpdateNewsletterCampaignsUpdate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (id, data, client) => {
+    const result = await updateNewsletterCampaignsUpdate(id, data, client);
+    mutate("cfg-newsletter-campaigns");
+    mutate("cfg-newsletter-campaign");
+    return result;
+  };
+}
+function useDeleteNewsletterCampaignsDestroy() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (id, client) => {
+    const result = await deleteNewsletterCampaignsDestroy(id, client);
+    mutate("cfg-newsletter-campaigns");
+    mutate("cfg-newsletter-campaign");
+    return result;
+  };
+}
+function useCreateNewsletterCampaignsSendCreate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (data, client) => {
+    const result = await createNewsletterCampaignsSendCreate(data, client);
+    mutate("cfg-newsletter-campaigns-send");
+    return result;
+  };
+}
+function useNewsletterLogsList(params, client) {
+  return useSWR__default.default(
+    params ? ["cfg-newsletter-logs", params] : "cfg-newsletter-logs",
+    () => getNewsletterLogsList(params, client)
+  );
+}
+function useNewsletterNewslettersList(params, client) {
+  return useSWR__default.default(
+    params ? ["cfg-newsletter-newsletters", params] : "cfg-newsletter-newsletters",
+    () => getNewsletterNewslettersList(params, client)
+  );
+}
+function useNewsletterNewslettersRetrieve(id, client) {
+  return useSWR__default.default(
+    ["cfg-newsletter-newsletter", id],
+    () => getNewsletterNewslettersRetrieve(id, client)
+  );
+}
+function useCreateNewsletterSubscribeCreate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (data, client) => {
+    const result = await createNewsletterSubscribeCreate(data, client);
+    mutate("cfg-newsletter-subscribe");
+    return result;
+  };
+}
+function useNewsletterSubscriptionsList(params, client) {
+  return useSWR__default.default(
+    params ? ["cfg-newsletter-subscriptions", params] : "cfg-newsletter-subscriptions",
+    () => getNewsletterSubscriptionsList(params, client)
+  );
+}
+function useCreateNewsletterUnsubscribeCreate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (data, client) => {
+    const result = await createNewsletterUnsubscribeCreate(data, client);
+    mutate("cfg-newsletter-unsubscribe");
+    return result;
+  };
+}
+function useCreateNewsletterTestCreate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (data, client) => {
+    const result = await createNewsletterTestCreate(data, client);
+    mutate("cfg-newsletter-test");
+    return result;
+  };
+}
+function usePartialUpdateNewsletterCampaignsPartialUpdate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (id, data, client) => {
+    const result = await partialUpdateNewsletterCampaignsPartialUpdate(id, data, client);
+    mutate("cfg-newsletter-campaigns-partial");
+    return result;
+  };
+}
+function useUpdateNewsletterUnsubscribeUpdate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (data, client) => {
+    const result = await updateNewsletterUnsubscribeUpdate(data, client);
+    mutate("cfg-newsletter-unsubscribe");
+    return result;
+  };
+}
+function usePartialUpdateNewsletterUnsubscribePartialUpdate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (data, client) => {
+    const result = await partialUpdateNewsletterUnsubscribePartialUpdate(data, client);
+    mutate("cfg-newsletter-unsubscribe-partial");
+    return result;
+  };
+}
+var NewsletterContext = react.createContext(void 0);
+function NewsletterProvider({
+  children,
+  page = 1,
+  pageSize = 100
+}) {
+  const { mutate } = useSWR.useSWRConfig();
+  const swrConfig = {
+    revalidateOnFocus: false,
+    revalidateOnReconnect: false,
+    revalidateIfStale: false
+  };
+  const listParams = { page, page_size: pageSize };
+  const {
+    data: campaignsData,
+    error: campaignsError,
+    isLoading: isLoadingCampaigns
+  } = useNewsletterCampaignsList(listParams, apiNewsletter);
+  const {
+    data: subscriptionsData,
+    error: subscriptionsError,
+    isLoading: isLoadingSubscriptions
+  } = useNewsletterSubscriptionsList(listParams, apiNewsletter);
+  const createCampaignMutation = useCreateNewsletterCampaignsCreate();
+  const updateCampaignMutation = useUpdateNewsletterCampaignsUpdate();
+  usePartialUpdateNewsletterCampaignsPartialUpdate();
+  const deleteCampaignMutation = useDeleteNewsletterCampaignsDestroy();
+  const sendCampaignMutation = useCreateNewsletterCampaignsSendCreate();
+  const subscribeMutation = useCreateNewsletterSubscribeCreate();
+  const unsubscribeMutation = useCreateNewsletterUnsubscribeCreate();
+  const campaigns = campaignsData?.results || [];
+  const subscriptions = subscriptionsData?.results || [];
+  const getCampaign = (id) => {
+    const { data, error, isLoading } = useNewsletterCampaignsRetrieve(id, apiNewsletter);
+    return { data, error, isLoading };
+  };
+  const createCampaign = async (data) => {
+    const result = await createCampaignMutation(data, apiNewsletter);
+    await mutate(["cfg-newsletter-campaigns-list", listParams]);
+    return result;
+  };
+  const updateCampaign = async (id, data) => {
+    const result = await updateCampaignMutation(id, data, apiNewsletter);
+    await mutate(["cfg-newsletter-campaigns-list", listParams]);
+    await mutate(["cfg-newsletter-campaigns-retrieve", id]);
+    return result;
+  };
+  const partialUpdateCampaign = async (id, data) => {
+    const result = await updateCampaignMutation(id, data);
+    await mutate(["cfg-newsletter-campaigns-list", listParams]);
+    await mutate(["cfg-newsletter-campaigns-retrieve", id]);
+    return result;
+  };
+  const deleteCampaign = async (id) => {
+    await deleteCampaignMutation(id, apiNewsletter);
+    await mutate(["cfg-newsletter-campaigns-list", listParams]);
+  };
+  const sendCampaign = async (campaignId) => {
+    const result = await sendCampaignMutation({ campaign_id: campaignId }, apiNewsletter);
+    await mutate(["cfg-newsletter-campaigns-list", listParams]);
+    await mutate(["cfg-newsletter-campaigns-retrieve", campaignId]);
+    return result;
+  };
+  const subscribe = async (data) => {
+    const result = await subscribeMutation(data, apiNewsletter);
+    await mutate(["cfg-newsletter-subscriptions-list", listParams]);
+    return result;
+  };
+  const unsubscribe = async (data) => {
+    const result = await unsubscribeMutation(data, apiNewsletter);
+    await mutate(["cfg-newsletter-subscriptions-list", listParams]);
+    return result;
+  };
+  const value = {
+    campaigns,
+    isLoadingCampaigns,
+    campaignsError,
+    pagination: campaignsData ? {
+      count: campaignsData.count,
+      next: campaignsData.next_page ?? null,
+      previous: campaignsData.previous_page ?? null
+    } : void 0,
+    getCampaign,
+    createCampaign,
+    updateCampaign,
+    partialUpdateCampaign,
+    deleteCampaign,
+    sendCampaign,
+    subscriptions,
+    isLoadingSubscriptions,
+    subscriptionsError,
+    subscribe,
+    unsubscribe
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(hooks.ExtensionProvider, { metadata: extensionConfig, options: swrConfig, children: /* @__PURE__ */ jsxRuntime.jsx(NewsletterContext.Provider, { value, children }) });
+}
+function useNewsletterContext() {
+  const context = react.useContext(NewsletterContext);
+  if (!context) {
+    throw new Error("useNewsletterContext must be used within NewsletterProvider");
+  }
+  return context;
+}
+var isDevelopment = process.env.NODE_ENV === "development";
+var logger = consola.createConsola({
+  level: isDevelopment ? 4 : 1
+}).withTag("ext-newsletter");
+var newsletterLogger = logger;
+function Hero({
+  title,
+  description,
+  primaryAction,
+  secondaryAction,
+  showNewsletter = true,
+  newsletterPlaceholder = "Enter your email",
+  newsletterButtonText = "Subscribe",
+  onNewsletterSubmit,
+  className = ""
+}) {
+  const [email, setEmail] = react.useState("");
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [status, setStatus] = react.useState("idle");
+  const [message, setMessage] = react.useState("");
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    if (!email || !onNewsletterSubmit) return;
+    setIsLoading(true);
+    setStatus("idle");
+    setMessage("");
+    try {
+      const result = await onNewsletterSubmit(email);
+      setStatus("success");
+      setMessage((result && "message" in result ? result.message : void 0) || "Successfully subscribed!");
+      setEmail("");
+      newsletterLogger.success("Newsletter subscription successful:", email);
+    } catch (error) {
+      setStatus("error");
+      setMessage(error instanceof Error ? error.message : "Subscription failed. Please try again.");
+      newsletterLogger.error("Newsletter subscription failed:", error);
+    } finally {
+      setIsLoading(false);
+      setTimeout(() => {
+        setStatus("idle");
+        setMessage("");
+      }, 5e3);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx("section", { className: `relative py-16 sm:py-20 md:py-24 lg:py-32 ${className}`, children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "container max-w-7xl mx-auto px-4 sm:px-6 lg:px-8", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "max-w-3xl mx-auto text-center", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("h1", { className: "text-4xl sm:text-5xl md:text-6xl font-bold tracking-tight text-foreground mb-6", children: title }),
+    description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-lg sm:text-xl text-muted-foreground mb-8 max-w-2xl mx-auto", children: description }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col sm:flex-row gap-4 justify-center items-center mb-12", children: [
+      primaryAction && /* @__PURE__ */ jsxRuntime.jsx(
+        uiNextjs.Button,
+        {
+          size: "lg",
+          onClick: primaryAction.onClick,
+          className: "w-full sm:w-auto",
+          children: primaryAction.label
+        }
+      ),
+      secondaryAction && /* @__PURE__ */ jsxRuntime.jsx(
+        uiNextjs.Button,
+        {
+          size: "lg",
+          variant: "outline",
+          onClick: secondaryAction.onClick,
+          className: "w-full sm:w-auto",
+          children: secondaryAction.label
+        }
+      )
+    ] }),
+    showNewsletter && onNewsletterSubmit && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "max-w-md mx-auto", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("form", { onSubmit: handleSubmit, className: "space-y-3", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col sm:flex-row gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative flex-1", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Mail, { className: "absolute left-3 top-1/2 -translate-y-1/2 h-5 w-5 text-muted-foreground" }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              uiNextjs.Input,
+              {
+                type: "email",
+                placeholder: newsletterPlaceholder,
+                value: email,
+                onChange: (e) => setEmail(e.target.value),
+                disabled: isLoading,
+                required: true,
+                className: "pl-10"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            uiNextjs.Button,
+            {
+              type: "submit",
+              disabled: isLoading || !email,
+              className: "w-full sm:w-auto",
+              children: isLoading ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "mr-2 h-4 w-4 animate-spin" }),
+                "Subscribing..."
+              ] }) : newsletterButtonText
+            }
+          )
+        ] }),
+        status === "success" && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 text-sm text-green-600 dark:text-green-400", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CheckCircle2, { className: "h-4 w-4" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: message })
+        ] }),
+        status === "error" && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 text-sm text-red-600 dark:text-red-400", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.AlertCircle, { className: "h-4 w-4" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: message })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-xs text-muted-foreground mt-3", children: "By subscribing, you agree to our Privacy Policy and consent to receive updates." })
+    ] })
+  ] }) }) });
+}
+var Hero_default = Hero;
+
+exports.API = API;
+exports.APIClient = APIClient;
+exports.APIError = APIError;
+exports.APILogger = APILogger;
+exports.BulkEmailRequestSchema = BulkEmailRequestSchema;
+exports.BulkEmailResponseSchema = BulkEmailResponseSchema;
+exports.CookieStorageAdapter = CookieStorageAdapter;
+exports.DEFAULT_RETRY_CONFIG = DEFAULT_RETRY_CONFIG;
+exports.EmailLogSchema = EmailLogSchema;
+exports.Enums = enums_exports;
+exports.ErrorResponseSchema = ErrorResponseSchema;
+exports.ExtNewsletterBulkEmailTypes = models_exports;
+exports.ExtNewsletterCampaignsTypes = models_exports2;
+exports.ExtNewsletterLogsTypes = models_exports3;
+exports.ExtNewsletterNewsletterTypes = models_exports7;
+exports.ExtNewsletterNewslettersTypes = models_exports4;
+exports.ExtNewsletterSubscriptionsTypes = models_exports5;
+exports.ExtNewsletterTestingTypes = models_exports6;
+exports.FetchAdapter = FetchAdapter;
+exports.Fetchers = fetchers_exports;
+exports.Hero = Hero;
+exports.LocalStorageAdapter = LocalStorageAdapter;
+exports.MemoryStorageAdapter = MemoryStorageAdapter;
+exports.NetworkError = NetworkError;
+exports.NewsletterCampaignRequestSchema = NewsletterCampaignRequestSchema;
+exports.NewsletterCampaignSchema = NewsletterCampaignSchema;
+exports.NewsletterHero = Hero_default;
+exports.NewsletterProvider = NewsletterProvider;
+exports.NewsletterSchema = NewsletterSchema;
+exports.NewsletterSubscriptionSchema = NewsletterSubscriptionSchema;
+exports.PaginatedEmailLogListSchema = PaginatedEmailLogListSchema;
+exports.PaginatedNewsletterCampaignListSchema = PaginatedNewsletterCampaignListSchema;
+exports.PaginatedNewsletterListSchema = PaginatedNewsletterListSchema;
+exports.PaginatedNewsletterSubscriptionListSchema = PaginatedNewsletterSubscriptionListSchema;
+exports.PatchedNewsletterCampaignRequestSchema = PatchedNewsletterCampaignRequestSchema;
+exports.PatchedUnsubscribeRequestSchema = PatchedUnsubscribeRequestSchema;
+exports.REFRESH_TOKEN_KEY = REFRESH_TOKEN_KEY;
+exports.Schemas = schemas_exports;
+exports.SendCampaignRequestSchema = SendCampaignRequestSchema;
+exports.SendCampaignResponseSchema = SendCampaignResponseSchema;
+exports.SubscribeRequestSchema = SubscribeRequestSchema;
+exports.SubscribeResponseSchema = SubscribeResponseSchema;
+exports.SuccessResponseSchema = SuccessResponseSchema;
+exports.TOKEN_KEY = TOKEN_KEY;
+exports.TestEmailRequestSchema = TestEmailRequestSchema;
+exports.UnsubscribeRequestSchema = UnsubscribeRequestSchema;
+exports.UnsubscribeSchema = UnsubscribeSchema;
+exports.apiNewsletter = apiNewsletter;
+exports.clearAPITokens = clearAPITokens;
+exports.configureAPI = configureAPI;
+exports.createNewsletterBulkCreate = createNewsletterBulkCreate;
+exports.createNewsletterCampaignsCreate = createNewsletterCampaignsCreate;
+exports.createNewsletterCampaignsSendCreate = createNewsletterCampaignsSendCreate;
+exports.createNewsletterSubscribeCreate = createNewsletterSubscribeCreate;
+exports.createNewsletterTestCreate = createNewsletterTestCreate;
+exports.createNewsletterUnsubscribeCreate = createNewsletterUnsubscribeCreate;
+exports.deleteNewsletterCampaignsDestroy = deleteNewsletterCampaignsDestroy;
+exports.dispatchValidationError = dispatchValidationError;
+exports.extensionConfig = extensionConfig;
+exports.formatZodError = formatZodError;
+exports.getAPIInstance = getAPIInstance;
+exports.getNewsletterCampaignsList = getNewsletterCampaignsList;
+exports.getNewsletterCampaignsRetrieve = getNewsletterCampaignsRetrieve;
+exports.getNewsletterLogsList = getNewsletterLogsList;
+exports.getNewsletterNewslettersList = getNewsletterNewslettersList;
+exports.getNewsletterNewslettersRetrieve = getNewsletterNewslettersRetrieve;
+exports.getNewsletterSubscriptionsList = getNewsletterSubscriptionsList;
+exports.isAPIConfigured = isAPIConfigured;
+exports.onValidationError = onValidationError;
+exports.partialUpdateNewsletterCampaignsPartialUpdate = partialUpdateNewsletterCampaignsPartialUpdate;
+exports.partialUpdateNewsletterUnsubscribePartialUpdate = partialUpdateNewsletterUnsubscribePartialUpdate;
+exports.reconfigureAPI = reconfigureAPI;
+exports.resetAPI = resetAPI;
+exports.shouldRetry = shouldRetry;
+exports.updateNewsletterCampaignsUpdate = updateNewsletterCampaignsUpdate;
+exports.updateNewsletterUnsubscribeUpdate = updateNewsletterUnsubscribeUpdate;
+exports.useCreateNewsletterBulkCreate = useCreateNewsletterBulkCreate;
+exports.useCreateNewsletterCampaignsCreate = useCreateNewsletterCampaignsCreate;
+exports.useCreateNewsletterCampaignsSendCreate = useCreateNewsletterCampaignsSendCreate;
+exports.useCreateNewsletterSubscribeCreate = useCreateNewsletterSubscribeCreate;
+exports.useCreateNewsletterTestCreate = useCreateNewsletterTestCreate;
+exports.useCreateNewsletterUnsubscribeCreate = useCreateNewsletterUnsubscribeCreate;
+exports.useDeleteNewsletterCampaignsDestroy = useDeleteNewsletterCampaignsDestroy;
+exports.useNewsletterCampaignsList = useNewsletterCampaignsList;
+exports.useNewsletterCampaignsRetrieve = useNewsletterCampaignsRetrieve;
+exports.useNewsletterContext = useNewsletterContext;
+exports.useNewsletterLogsList = useNewsletterLogsList;
+exports.useNewsletterNewslettersList = useNewsletterNewslettersList;
+exports.useNewsletterNewslettersRetrieve = useNewsletterNewslettersRetrieve;
+exports.useNewsletterSubscriptionsList = useNewsletterSubscriptionsList;
+exports.usePartialUpdateNewsletterCampaignsPartialUpdate = usePartialUpdateNewsletterCampaignsPartialUpdate;
+exports.usePartialUpdateNewsletterUnsubscribePartialUpdate = usePartialUpdateNewsletterUnsubscribePartialUpdate;
+exports.useUpdateNewsletterCampaignsUpdate = useUpdateNewsletterCampaignsUpdate;
+exports.useUpdateNewsletterUnsubscribeUpdate = useUpdateNewsletterUnsubscribeUpdate;
+exports.withRetry = withRetry;