@useinsider/guido 1.0.3-beta.dfb1fcf → 1.0.3-beta.e1adf59

package/dist/services/slackNotificationService.js

@@ -0,0 +1,167 @@
+var d = Object.defineProperty;
+var h = (t, e, r) => e in t ? d(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var i = (t, e, r) => h(t, typeof e != "symbol" ? e + "" : e, r);
+class u {
+  constructor(e, r) {
+    i(this, "webhookUrl");
+    i(this, "channel");
+    i(this, "defaultUsername");
+    i(this, "enabled");
+    this.webhookUrl = e || void 0 || "", this.channel = (r == null ? void 0 : r.channel) || "#errors", this.defaultUsername = (r == null ? void 0 : r.username) || "Guido Error Bot", this.enabled = (r == null ? void 0 : r.enabled) !== !1, this.webhookUrl || (console.warn("[SlackNotificationService] Webhook URL not configured, Slack notifications disabled"), this.enabled = !1);
+  }
+  /**
+   * Send an error notification to Slack
+   */
+  async sendErrorNotification(e) {
+    if (!this.enabled || !this.webhookUrl)
+      return !1;
+    try {
+      const r = this.buildErrorPayload(e), a = await fetch(this.webhookUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(r)
+      });
+      return a.ok ? !0 : (console.error("[SlackNotificationService] Failed to send Slack notification:", a.statusText), !1);
+    } catch (r) {
+      return console.error("[SlackNotificationService] Error sending Slack notification:", r), !1;
+    }
+  }
+  /**
+   * Send a critical error that requires immediate attention
+   */
+  async sendCriticalError(e, r, a) {
+    return this.sendErrorNotification({
+      title: e,
+      message: r,
+      errorType: "critical",
+      severity: "critical",
+      context: a,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Send a CORS error notification
+   */
+  async sendCorsErrorNotification(e, r) {
+    return this.sendCriticalError(
+      "CORS Error in Stripo Email Editor",
+      "Failed to load Stripo resources due to CORS restrictions",
+      {
+        resourceUrl: e,
+        ...r,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    );
+  }
+  /**
+   * Send a plugin load error notification
+   */
+  async sendPluginLoadErrorNotification(e, r) {
+    return this.sendCriticalError(
+      "Stripo Plugin Failed to Load",
+      `Email editor initialization failed: ${e}`,
+      {
+        ...r,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    );
+  }
+  /**
+   * Build Slack message payload from error notification
+   */
+  buildErrorPayload(e) {
+    const a = {
+      critical: "#E74C3C",
+      // Red
+      high: "#E67E22",
+      // Orange
+      medium: "#F39C12",
+      // Yellow
+      low: "#3498DB"
+      // Blue
+    }[e.severity] || "#95A5A6", l = [
+      {
+        title: "Error Type",
+        value: e.errorType,
+        short: !0
+      },
+      {
+        title: "Severity",
+        value: e.severity.toUpperCase(),
+        short: !0
+      },
+      {
+        title: "Timestamp",
+        value: e.timestamp ? new Date(e.timestamp).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+        short: !0
+      }
+    ];
+    e.context && Object.entries(e.context).forEach(([n, c]) => {
+      l.length < 20 && l.push({
+        title: this.formatFieldTitle(n),
+        value: this.formatFieldValue(c),
+        short: !0
+      });
+    });
+    const s = {
+      color: a,
+      title: e.title,
+      text: e.message,
+      fields: l,
+      footer: "Guido Error Tracking",
+      ts: Math.floor((e.timestamp || Date.now()) / 1e3)
+    };
+    return e.stackTrace && (s.text = `${e.message}
+\`\`\`${e.stackTrace}\`\`\``), {
+      channel: this.channel,
+      username: this.defaultUsername,
+      // eslint-disable-next-line camelcase
+      icon_emoji: ":warning:",
+      attachments: [s]
+    };
+  }
+  /**
+   * Format field title for Slack (e.g., emailId -> Email ID)
+   */
+  formatFieldTitle(e) {
+    return e.replace(/([A-Z])/g, " $1").replace(/^./, (r) => r.toUpperCase()).trim();
+  }
+  /**
+   * Format field value for Slack display
+   */
+  formatFieldValue(e) {
+    return e == null ? "(empty)" : typeof e == "object" ? JSON.stringify(e).slice(0, 500) : String(e).slice(0, 500);
+  }
+  /**
+   * Check if notifications are enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Update webhook URL
+   */
+  setWebhookUrl(e) {
+    this.webhookUrl = e, this.enabled = !!e;
+  }
+  /**
+   * Update channel
+   */
+  setChannel(e) {
+    this.channel = e;
+  }
+  /**
+   * Enable/disable notifications
+   */
+  setEnabled(e) {
+    this.enabled = e && !!this.webhookUrl;
+  }
+}
+let o = null;
+const S = () => (o || (o = new u()), o);
+export {
+  u as SlackNotificationService,
+  S as getSlackNotificationService
+};

package/dist/services/stripoApi.js

@@ -1,25 +1,45 @@
-import { useHttp as a } from "../composables/useHttp.js";
-import { useToaster as s } from "../composables/useToaster.js";
-const m = () => {
-  const { get: r } = a(), { handleError: o } = s();
+import { useApiErrorTracking as i } from "../composables/useApiErrorTracking.js";
+import { useHttp as c } from "../composables/useHttp.js";
+import { useToaster as p } from "../composables/useToaster.js";
+const h = () => {
+  const { get: s } = c(), { handleError: n } = p(), { withParsingErrorTracking: a } = i();
   return {
     getToken: async () => {
       try {
-        const t = Number(localStorage.getItem("ins-guido-test-instance")), { data: e } = await r(`/stripo/get-user-token?test=${t}`);
-        return e.body.token;
+        const t = Number(localStorage.getItem("ins-guido-test-instance")), { data: e } = await s(`/stripo/get-user-token?test=${t}`);
+        return a(
+          () => {
+            var o;
+            if (!((o = e == null ? void 0 : e.body) != null && o.token))
+              throw new Error("Invalid token response: missing token in response body");
+            return e.body.token;
+          },
+          "/stripo/get-user-token",
+          e,
+          { endpoint: "/stripo/get-user-token", operation: "getToken" }
+        );
       } catch (t) {
-        return o(t, "Failed to fetch token"), "";
+        return n(t, "Failed to fetch token"), "";
       }
     },
     getCustomFonts: async () => {
       try {
-        const { data: t = [] } = await r("/stripo/get-partner-custom-fonts");
-        return t.map((e) => ({
-          ...e,
-          active: !0
-        }));
+        const { data: t = [] } = await s("/stripo/get-partner-custom-fonts");
+        return a(
+          () => {
+            if (!Array.isArray(t))
+              throw new Error("Invalid fonts response: expected array");
+            return t.map((r) => ({
+              ...r,
+              active: !0
+            }));
+          },
+          "/stripo/get-partner-custom-fonts",
+          t,
+          { endpoint: "/stripo/get-partner-custom-fonts", operation: "getCustomFonts" }
+        );
       } catch (t) {
-        return o(t, "Failed to fetch custom fonts"), [];
+        return n(t, "Failed to fetch custom fonts"), [];
       }
     },
     getDefaultTemplate: async () => {
@@ -29,21 +49,31 @@ const m = () => {
         forceRecreate: !0
       };
       try {
-        const { data: e } = await r("/stripo/default-template/0");
+        const { data: e } = await s("/stripo/default-template");
         try {
           return {
-            ...JSON.parse(e),
+            ...a(
+              () => {
+                const o = JSON.parse(e);
+                if (!o.html)
+                  throw new Error("Invalid template response: missing html field");
+                return o;
+              },
+              "/stripo/default-template",
+              e,
+              { endpoint: "/stripo/default-template", operation: "getDefaultTemplate" }
+            ),
             forceRecreate: !0
           };
-        } catch {
-          return t;
+        } catch (r) {
+          return r instanceof Error && !r.message.includes("Invalid template") && n(r, "Failed to parse template as JSON"), t;
         }
       } catch (e) {
-        return o(e, "Failed to fetch default template"), t;
+        return n(e, "Failed to fetch default template"), t;
       }
     }
   };
 };
 export {
-  m as useStripoApi
+  h as useStripoApi
 };

package/dist/services/stripoErrorDeduplicationService.js

@@ -0,0 +1,91 @@
+var c = Object.defineProperty;
+var a = (e, r, t) => r in e ? c(e, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[r] = t;
+var n = (e, r, t) => a(e, typeof r != "symbol" ? r + "" : r, t);
+class s {
+  constructor() {
+    n(this, "reportedErrors", /* @__PURE__ */ new Set());
+  }
+  /**
+   * Track an error locally to prevent duplicate Slack alerts
+   * Only sends Slack alert once per unique error within the same session
+   */
+  trackError(r) {
+    const t = this.getDeduplicationKey(r);
+    return this.reportedErrors.has(t) ? !1 : (this.reportedErrors.add(t), !0);
+  }
+  /**
+   * Track plugin load error locally (CORS, script failure, timeout)
+   */
+  trackPluginLoadError(r, t) {
+    return this.trackError({
+      errorType: "plugin_load_error",
+      errorMessage: r,
+      errorCategory: "critical",
+      context: {
+        ...t,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        environment: "production"
+      },
+      reportedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Track CORS error locally
+   */
+  trackCorsError(r, t) {
+    return this.trackError({
+      errorType: "cors_error",
+      errorMessage: r,
+      errorCategory: "handled",
+      context: {
+        ...t,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        environment: "production"
+      },
+      reportedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Track authentication error locally (token refresh failure)
+   * Tracks it, but Slack notifier decides whether to alert based on token expiration
+   */
+  trackAuthenticationError(r, t) {
+    return this.trackError({
+      errorType: "authentication_error",
+      errorMessage: r,
+      errorCategory: "critical",
+      context: {
+        ...t,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        environment: "production"
+      },
+      reportedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Generate unique deduplication key for error
+   * Format: "errorType:emailId:userId" to allow same error on different emails
+   */
+  getDeduplicationKey(r) {
+    const t = r.context.emailId || "unknown", i = r.context.userId || "unknown";
+    return `${r.errorType}:${t}:${i}`;
+  }
+  /**
+   * Clear tracked errors (for testing or session reset)
+   */
+  clearTrackedErrors() {
+    this.reportedErrors.clear();
+  }
+  /**
+   * Get count of errors tracked in this session
+   */
+  getTrackedErrorCount() {
+    return this.reportedErrors.size;
+  }
+}
+let o = null;
+const u = () => (o || (o = new s()), o);
+export {
+  s as StripoErrorDeduplicationService,
+  u as getStripoErrorDeduplicationService
+};

package/dist/src/@types/generic.d.ts

@@ -6,71 +6,36 @@ type Features = {
     dynamicContent?: boolean;
     saveAsTemplate?: boolean;
     versionHistory?: boolean;
-    testMessage?: boolean;
-    displayConditions?: boolean;
 };
 type Partner = {
     partnerName: string;
     productType: number;
     messageType: number;
 };
-export type GuidoBlockType = 'amp-accordion' | 'amp-carousel' | 'amp-form-controls' | 'banner-block' | 'button-block' | 'html-block' | 'image-block' | 'menu-block' | 'social-block' | 'spacer-block' | 'text-block' | 'timer-block' | 'video-block';
-export type GuidoCustomBlockType = 'dynamic-content' | 'checkbox-block' | 'radio-button-block' | 'recommendation-block' | 'unsubscribe-block' | 'coupon-block' | 'items-block';
-type BlocksConfig = {
-    excludeDefaults?: GuidoBlockType[];
-    includeCustoms?: GuidoCustomBlockType[];
-};
 export type GuidoConfig = {
     translationsPath: string;
     htmlCompilerRules?: CompilerRule[];
     ignoreDefaultHtmlCompilerRules?: boolean;
     useHeader?: boolean;
     emailHeader: EmailHeader;
-    migrationDate: number;
     partner?: Partner;
     extensions?: Extensions;
     features?: Features;
-    blocks?: BlocksConfig;
-    backButtonLabel?: string;
 };
 export type TemplateConfig = {
     preselectedDynamicContentList?: DynamicContent[];
     selectedUnsubscribePages?: number[];
     variationId?: string;
 };
-export type BaseDynamicContent = {
+export type DynamicContent = {
     value: string;
+    text: string;
     fallback?: string;
     format?: {
         key: string;
         value: string;
     };
 };
-export type DynamicContent = BaseDynamicContent & {
-    text: string;
-};
-export type MergeTag = BaseDynamicContent & {
-    label: string;
-    selStart?: number;
-    selEnd?: number;
-    hidden?: boolean;
-};
-export type PositionData = {
-    x: number;
-    y: number;
-    width?: number;
-    height?: number;
-};
-export type DynamicContentEvent = {
-    attribute: DynamicContent;
-    position?: PositionData;
-};
-export type MergeTagClickEvent = {
-    position: PositionData;
-    element: HTMLElement;
-    tagValue: string | null;
-    tagLabel: string | null;
-};
 export interface EmailHeader {
     senderName: string;
     subject: string;
@@ -86,13 +51,12 @@ export interface TooltipOptions {
     };
     preventXss?: boolean;
 }
+export type MergeTag = {
+    label: string;
+    value: string;
+};
 export type TextValueObject = {
     text: string;
     value: string;
 };
-export interface L10n {
-    locale?: string;
-    timezone?: string;
-    time?: number;
-}
 export {};

package/dist/src/components/Guido.vue.d.ts

@@ -1,4 +1,4 @@
-import type { DynamicContent, GuidoConfig, PositionData, TemplateConfig } from '@@/Types/generic';
+import type { DynamicContent, GuidoConfig, TemplateConfig } from '@@/Types/generic';
 import type { SavedTemplateDetails } from '@@/Types/stripo';
 type __VLS_Props = {
     templateId: string;
@@ -11,6 +11,7 @@ type __VLS_Props = {
     css?: string;
     guidoConfig: GuidoConfig;
     templateConfig?: TemplateConfig;
+    traceId?: string;
 };
 declare const _default: import("vue").DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {
     dynamicContent: {
@@ -20,14 +21,12 @@ declare const _default: import("vue").DefineComponent<__VLS_TypePropsToOption<__
     hasChanges: import("vue").ComputedRef<boolean>;
     saveSilent: () => Promise<SavedTemplateDetails | undefined> | undefined;
 }, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, {
-    "dynamic-content:open": (detail: DynamicContent | null, position?: PositionData | undefined) => void;
+    "dynamic-content:open": (detail: DynamicContent | null) => void;
     back: () => void;
     "save:start": () => void;
     "save:complete": (data: Omit<SavedTemplateDetails, "forceRecreate">) => void;
     "on-change": (hasChanges: boolean) => void;
     ready: () => void;
-    "onboarding:finished": () => void;
-    "test-email:click": () => void;
 }, string, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

package/dist/src/components/organisms/onboarding/NewVersionPopup.vue.d.ts

@@ -1,4 +1,2 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, {
-    "onboarding-finished": () => void;
-}, string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
 export default _default;

package/dist/src/components/organisms/onboarding/OnboardingWrapper.vue.d.ts

@@ -1,4 +1,2 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, {
-    "onboarding-finished": () => void;
-}, string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
 export default _default;

package/dist/src/components/wrappers/WpModal.vue.d.ts

@@ -32,8 +32,8 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_WithDefaults<
     closeOnOutsideClick: boolean;
     footerStatus: boolean;
 }>>>, {
-    size: "small" | "medium" | "large";
     description: string;
+    size: "small" | "medium" | "large";
     closeOnOutsideClick: boolean;
     footerButtonOptions: FooterButtonGroup;
     closeButtonStatus: boolean;

package/dist/src/composables/useApiErrorTracking.d.ts

@@ -0,0 +1,26 @@
+import type { HttpError, HttpResponse } from '@@/Composables/useHttp';
+/**
+ * API error context with request/response details
+ */
+export interface ApiErrorContext {
+    endpoint: string;
+    method?: string;
+    statusCode?: number;
+    statusText?: string;
+    errorType?: 'http_error' | 'network_error' | 'parsing_error' | 'timeout';
+    attemptNumber?: number;
+    retryable?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Tracks API failures including HTTP errors, network issues, and data parsing failures
+ * Integrates with the main error tracking system (Sentry + FullStory)
+ */
+export declare const useApiErrorTracking: () => {
+    captureHttpError: (error: HttpError, endpoint: string, options?: Omit<ApiErrorContext, "endpoint">) => ApiErrorContext;
+    captureNetworkError: (error: Error, endpoint: string, options?: Omit<ApiErrorContext, "endpoint">) => ApiErrorContext;
+    captureParsingError: (error: unknown, endpoint: string, responseData?: unknown, options?: Omit<ApiErrorContext, "endpoint">) => ApiErrorContext;
+    captureTimeoutError: (endpoint: string, timeoutMs: number, options?: Omit<ApiErrorContext, "endpoint">) => ApiErrorContext;
+    withApiErrorTracking: <T>(apiCall: () => Promise<HttpResponse<T>>, endpoint: string, method?: string, options?: Omit<ApiErrorContext, "endpoint">) => Promise<HttpResponse<T>>;
+    withParsingErrorTracking: <T>(parser: () => T, endpoint: string, rawResponse?: unknown, options?: Omit<ApiErrorContext, "endpoint">) => T;
+};

package/dist/src/composables/useErrorTracking.d.ts

@@ -0,0 +1,30 @@
+import type { Ref } from 'vue';
+/**
+ * Error context for error tracking and correlation
+ */
+export interface ErrorContext {
+    component?: string;
+    operation?: string;
+    templateId?: string;
+    userId?: string;
+    [key: string]: unknown;
+}
+/**
+ * Error tracking service for capturing and reporting errors
+ * Integrates with Sentry and FullStory for comprehensive error tracking
+ */
+export declare const useErrorTracking: () => {
+    traceId: string;
+    errorCount: Readonly<Ref<number>>;
+    lastError: Readonly<Ref<Error | null>>;
+    captureError: (error: Error, context?: ErrorContext) => ErrorContext;
+    captureStripoError: (error: unknown, operation: string, additionalContext?: Record<string, unknown>, shouldLogToSentry?: boolean) => ErrorContext;
+    captureTimeoutError: (operation: string, timeoutMs: number, additionalContext?: Record<string, unknown>) => ErrorContext;
+    createTimeoutPromise: <T>(ms: number, operation: string, additionalContext?: Record<string, unknown>) => Promise<T>;
+    withTimeout: <T>(promise: Promise<T>, ms: number, operation: string, additionalContext?: Record<string, unknown>) => Promise<T>;
+    getErrorSummary: () => {
+        errorCount: number;
+        lastError: Error | null;
+    };
+    resetErrorTracking: () => void;
+};

package/dist/src/composables/useGuidoActions.d.ts

@@ -3,11 +3,9 @@ import type { InjectionKey } from 'vue';
 export type BackHandler = () => void;
 export type SaveStartHandler = () => void;
 export type SaveCompleteHandler = (template: Omit<SavedTemplateDetails, 'forceRecreate'>) => void;
-export type TestEmailClickHandler = () => void;
 export declare const BACK_KEY: InjectionKey<BackHandler>;
 export declare const SAVE_START_KEY: InjectionKey<SaveStartHandler>;
 export declare const SAVE_COMPLETE_KEY: InjectionKey<SaveCompleteHandler>;
-export declare const TEST_EMAIL_CLICK_KEY: InjectionKey<TestEmailClickHandler>;
 /**
  * Provides Guido action handlers to child components
  */
@@ -15,7 +13,6 @@ export declare const provideGuidoActions: (actions: {
     onBack: BackHandler;
     onSaveStart: SaveStartHandler;
     onSaveComplete: SaveCompleteHandler;
-    onTestEmailClick: TestEmailClickHandler;
 }) => void;
 /**
  * Provides individual Guido action handlers
@@ -38,11 +35,6 @@ export declare const useSaveStart: () => SaveStartHandler;
  * @returns Save complete function
  */
 export declare const useSaveComplete: () => SaveCompleteHandler;
-/**
- * Hook to use the test email click handler
- * @returns Test email click function
- */
-export declare const useTestEmailClick: () => TestEmailClickHandler;
 /**
  * Convenience hook to get all Guido actions
  * @returns Object containing all action handlers
@@ -51,5 +43,4 @@ export declare const useGuidoActions: () => {
     back: BackHandler;
     saveStart: SaveStartHandler;
     saveComplete: SaveCompleteHandler;
-    testEmailClick: TestEmailClickHandler;
 };

package/dist/src/composables/useStripoErrorCategory.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Error categorization system for Stripo integration
+ * Determines whether errors should be logged to Sentry/FullStory, Slack, or both
+ *
+ * Note: Error type names use snake_case (e.g., plugin_load_error) to match
+ * error type strings used throughout the codebase. This is intentional and
+ * required for the categorization system to work correctly.
+ */
+export type ErrorSeverity = 'critical' | 'warning' | 'info';
+export type ErrorCaptureLevel = 'sentry_and_slack' | 'slack_only' | 'sentry_only';
+export interface ErrorCategory {
+    type: string;
+    severity: ErrorSeverity;
+    captureLevel: ErrorCaptureLevel;
+    description: string;
+}
+/**
+ * Categorize an error based on its type
+ * Returns the error category with capture level and severity
+ */
+export declare const useStripoErrorCategory: () => {
+    getErrorCategory: (errorType: string) => ErrorCategory;
+    shouldCaptureSentry: (errorType: string) => boolean;
+    shouldNotifySlack: (errorType: string) => boolean;
+    addErrorCategory: (category: ErrorCategory) => void;
+};

package/dist/src/composables/useStripoSlackNotifier.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Slack notifications for Stripo errors
+ * Uses error categorization to determine which errors should trigger Slack alerts
+ * Prevents duplicate alerts within the same session
+ */
+export declare const useStripoSlackNotifier: () => {
+    notifySlack: (errorMessage: string, errorType: string, additionalContext?: Record<string, unknown>) => Promise<boolean>;
+};

package/dist/src/enums/onboarding.d.ts

@@ -1,2 +1 @@
 export declare const SERVICE_HOVER_SELECTORS: string[];
-export declare const ACADEMY_LINK = "https://academy.useinsider.com/docs/email-drag-drop-editor";

package/dist/src/extensions/Blocks/Recommendation/block.d.ts

@@ -1,7 +1,6 @@
 import { Block, BlockCompositionType } from '@stripoinc/ui-editor-extensions';
 export declare const BLOCK_ID = "recommendation-block";
 export declare class RecommendationBlock extends Block {
-    constructor();
     getId(): string;
     getIcon(): string;
     getBlockCompositionType(): BlockCompositionType;

package/dist/src/extensions/Blocks/Recommendation/control.d.ts

@@ -17,19 +17,10 @@ export declare class RecommendationBlockControl extends CommonControl {
     _getProductLayout(): string;
     _getFilterStatus(): string;
     _getShuffleProducts(): string;
+    _getResponsive(): string;
+    _onFilterChange(value: boolean): void;
     _onFilterSelectClick(): void;
     _onDataChange(item: string, value: string | number | string[]): void;
-    /**
-     * Get the current card composition from block data attribute or use default
-     */
-    _getCardComposition(): string[];
-    _regenerateProductRows(): void;
-    /**
-     * Reapply spacing values after product regeneration
-     * This ensures spacing persists when products are regenerated
-     */
-    _reapplySpacing(): void;
-    _debouncedRegenerateProductRows: import("@vueuse/shared").PromisifyFn<() => void>;
     _onCurrencyConfigChange(item: string, value: string | number): void;
     _onCurrencyChange(value: string): void;
     _setProductIdsVisibility(): void;