@useinsider/guido 1.0.0-beta.02a8faf

package/dist/components/organisms/header/version-history/ViewOptions.vue.js

@@ -0,0 +1,18 @@
+import s from "./ViewOptions.vue2.js";
+/* empty css                 */
+import i from "../../../../_virtual/_plugin-vue2_normalizer.js";
+var r = function() {
+  var t = this, o = t._self._c, e = t._self._setupProxy;
+  return o(e.InSegments, { attrs: { id: "guido__verion-history-view-option-selection", "with-icon": "", "segment-list": e.segmentList, selected: e.versionHistoryStore.editorVisualMode }, on: { click: e.changeVisualMode } });
+}, n = [], _ = /* @__PURE__ */ i(
+  s,
+  r,
+  n,
+  !1,
+  null,
+  "6a2bde67"
+);
+const d = _.exports;
+export {
+  d as default
+};

package/dist/components/organisms/header/version-history/ViewOptions.vue2.js

@@ -0,0 +1,23 @@
+import { defineComponent as s } from "vue";
+import { useVersionHistoryApi as n } from "../../../../composables/useVersionHistoryApi.js";
+import { useVersionHistoryStore as r } from "../../../../stores/version-history.js";
+import { InSegments as m } from "@useinsider/design-system-vue";
+const d = /* @__PURE__ */ s({
+  __name: "ViewOptions",
+  setup(p) {
+    const e = r(), { switchToDesktopPreview: o, switchToMobilePreview: t } = n();
+    return { __sfc: !0, versionHistoryStore: e, switchToDesktopPreview: o, switchToMobilePreview: t, segmentList: [
+      { text: "", icon: "line-desktop", value: "desktop" },
+      { text: "", icon: "line-menu-mobileapp", value: "mobile" }
+    ], changeVisualMode: (i) => {
+      if (e.editorVisualMode = i, i === "mobile") {
+        t();
+        return;
+      }
+      o();
+    }, InSegments: m };
+  }
+});
+export {
+  d as default
+};

package/dist/composables/useActionsApi.d.ts

@@ -0,0 +1,4 @@
+import { GetCompiledEmailOptions, CompiledEmailResult } from '@@/Types/actions-api';
+export declare const useActionsApi: () => {
+    getCompiledEmail: (options?: GetCompiledEmailOptions) => Promise<CompiledEmailResult>;
+};

package/dist/composables/useActionsApi.js

@@ -0,0 +1,36 @@
+const d = () => ({ getCompiledEmail: (t = {}) => new Promise((a, i) => {
+  const m = { ...{
+    minimize: !0,
+    utmEntity: {
+      utmSource: "",
+      utmMedium: "",
+      utmCampaign: "",
+      utmContent: "",
+      utmTerm: "",
+      customUtms: [
+        {
+          name1: "val1",
+          name2: "val2"
+        }
+      ]
+    },
+    mergeTags: ["Tag1", "Tag2"],
+    forseAmp: !1,
+    resetDataSavedFlag: !1,
+    disableLineHeightsReplace: !0
+  }, ...t }, s = {
+    callback: (e, l, n, o, c) => {
+      e ? i(e) : a({
+        html: l,
+        ampHtml: n,
+        ampErrors: o,
+        displayConditions: c
+      });
+    },
+    ...m
+  };
+  window.StripoEditorApi.actionsApi.compileEmail(s);
+}) });
+export {
+  d as useActionsApi
+};

package/dist/composables/useApiExample.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @deprecated - It's added for example purposes.
+ */
+import type { User } from '../@types/generic';
+export declare const useApiExample: () => {
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<{
+        message: string;
+        status?: number | undefined;
+        statusText?: string | undefined;
+        response?: {
+            readonly headers: {
+                append: (name: string, value: string) => void;
+                delete: (name: string) => void;
+                get: (name: string) => string | null;
+                getSetCookie: () => string[];
+                has: (name: string) => boolean;
+                set: (name: string, value: string) => void;
+                forEach: (callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any) => void;
+                entries: () => IterableIterator<[string, string]>;
+                keys: () => IterableIterator<string>;
+                values: () => IterableIterator<string>;
+                [Symbol.iterator]: () => IterableIterator<[string, string]>;
+            };
+            readonly ok: boolean;
+            readonly redirected: boolean;
+            readonly status: number;
+            readonly statusText: string;
+            readonly type: ResponseType;
+            readonly url: string;
+            clone: () => Response;
+            readonly body: {
+                readonly locked: boolean;
+                cancel: (reason?: any) => Promise<void>;
+                getReader: {
+                    (options: {
+                        mode: "byob";
+                    }): ReadableStreamBYOBReader;
+                    (): ReadableStreamDefaultReader<Uint8Array>;
+                    (options?: ReadableStreamGetReaderOptions): ReadableStreamReader<Uint8Array>;
+                };
+                pipeThrough: <T>(transform: ReadableWritablePair<T, Uint8Array>, options?: StreamPipeOptions) => ReadableStream<T>;
+                pipeTo: (destination: WritableStream<Uint8Array>, options?: StreamPipeOptions) => Promise<void>;
+                tee: () => [ReadableStream<Uint8Array>, ReadableStream<Uint8Array>];
+            } | null;
+            readonly bodyUsed: boolean;
+            arrayBuffer: () => Promise<ArrayBuffer>;
+            blob: () => Promise<Blob>;
+            formData: () => Promise<FormData>;
+            json: () => Promise<any>;
+            text: () => Promise<string>;
+        } | undefined;
+    } | null>;
+    hasError: import("vue").ComputedRef<boolean>;
+    fetchUsers: () => Promise<User[]>;
+    createUser: (userData: Omit<User, "id">) => Promise<User>;
+    updateUser: (id: number, userData: Partial<User>) => Promise<User>;
+    deleteUser: (id: number) => Promise<void>;
+    uploadFile: (file: File) => Promise<string>;
+    clearError: () => void;
+};

package/dist/composables/useCustomInterfaceAppearance.d.ts

@@ -0,0 +1,3 @@
+export declare const useCustomInterfaceAppearance: () => {
+    importCss: () => void;
+};

package/dist/composables/useCustomInterfaceAppearance.js

@@ -0,0 +1,13 @@
+import r from "../static/editor.css.js";
+const c = () => ({ importCss: () => {
+  const e = new CSSStyleSheet();
+  e.replaceSync(r);
+  const t = document.querySelector("ui-editor");
+  if (!t)
+    return;
+  const o = t.shadowRoot;
+  o && (o.adoptedStyleSheets = [e]);
+} });
+export {
+  c as useCustomInterfaceAppearance
+};

package/dist/composables/useExport.d.ts

@@ -0,0 +1,3 @@
+export declare const useExport: () => {
+    exportHtml: () => Promise<void>;
+};

package/dist/composables/useExport.js

@@ -0,0 +1,30 @@
+import { useActionsApi as l } from "./useActionsApi.js";
+import { useToaster as m } from "./useToaster.js";
+const u = () => {
+  const a = (r, t, e) => {
+    const n = new Blob([r], { type: e }), s = URL.createObjectURL(n), o = document.createElement("a");
+    o.href = s, o.download = t, document.body.appendChild(o), o.click(), document.body.removeChild(o), URL.revokeObjectURL(s);
+  }, c = (r) => {
+    const t = /* @__PURE__ */ new Date(), e = String(t.getDate()).padStart(2, "0"), n = String(t.getMonth() + 1).padStart(2, "0"), s = t.getFullYear(), o = String(t.getHours()).padStart(2, "0"), i = String(t.getMinutes()).padStart(2, "0");
+    return `${r}_${e}-${n}-${s}_${o}-${i}.html`;
+  };
+  return { exportHtml: async () => {
+    const { getCompiledEmail: r } = l(), { showToaster: t } = m();
+    try {
+      const { html: e } = await r();
+      e ? a(e, c("HTML"), "text/html") : t({
+        type: "error",
+        message: "No HTML content to download"
+      });
+    } catch (e) {
+      const n = e instanceof Error ? e.message : String(e);
+      t({
+        type: "error",
+        message: `Error compiling email: ${n}`
+      });
+    }
+  } };
+};
+export {
+  u as useExport
+};

package/dist/composables/useHttp.d.ts

@@ -0,0 +1,78 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export interface HttpOptions extends Omit<RequestInit, 'method' | 'body'> {
+    baseURL?: string;
+    timeout?: number;
+    retry?: number;
+    retryDelay?: number;
+}
+export interface HttpResponse<T = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Headers;
+}
+export interface HttpError {
+    message: string;
+    status?: number;
+    statusText?: string;
+    response?: Response;
+}
+export declare const useHttp: (defaultOptions?: HttpOptions) => {
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<{
+        message: string;
+        status?: number | undefined;
+        statusText?: string | undefined;
+        response?: {
+            readonly headers: {
+                append: (name: string, value: string) => void;
+                delete: (name: string) => void;
+                get: (name: string) => string | null;
+                getSetCookie: () => string[];
+                has: (name: string) => boolean;
+                set: (name: string, value: string) => void;
+                forEach: (callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any) => void;
+                entries: () => IterableIterator<[string, string]>;
+                keys: () => IterableIterator<string>;
+                values: () => IterableIterator<string>;
+                [Symbol.iterator]: () => IterableIterator<[string, string]>;
+            };
+            readonly ok: boolean;
+            readonly redirected: boolean;
+            readonly status: number;
+            readonly statusText: string;
+            readonly type: ResponseType;
+            readonly url: string;
+            clone: () => Response;
+            readonly body: {
+                readonly locked: boolean;
+                cancel: (reason?: any) => Promise<void>;
+                getReader: {
+                    (options: {
+                        mode: "byob";
+                    }): ReadableStreamBYOBReader;
+                    (): ReadableStreamDefaultReader<Uint8Array>;
+                    (options?: ReadableStreamGetReaderOptions): ReadableStreamReader<Uint8Array>;
+                };
+                pipeThrough: <T>(transform: ReadableWritablePair<T, Uint8Array>, options?: StreamPipeOptions) => ReadableStream<T>;
+                pipeTo: (destination: WritableStream<Uint8Array>, options?: StreamPipeOptions) => Promise<void>;
+                tee: () => [ReadableStream<Uint8Array>, ReadableStream<Uint8Array>];
+            } | null;
+            readonly bodyUsed: boolean;
+            arrayBuffer: () => Promise<ArrayBuffer>;
+            blob: () => Promise<Blob>;
+            formData: () => Promise<FormData>;
+            json: () => Promise<any>;
+            text: () => Promise<string>;
+        } | undefined;
+    } | null>;
+    hasError: import("vue").ComputedRef<boolean>;
+    request: <T = unknown>(method: HttpMethod, url: string, data?: unknown, options?: HttpOptions) => Promise<HttpResponse<T>>;
+    get: <T = unknown>(url: string, options?: HttpOptions) => Promise<HttpResponse<T>>;
+    post: <T = unknown>(url: string, data?: unknown, options?: HttpOptions) => Promise<HttpResponse<T>>;
+    put: <T = unknown>(url: string, data?: unknown, options?: HttpOptions) => Promise<HttpResponse<T>>;
+    patch: <T = unknown>(url: string, data?: unknown, options?: HttpOptions) => Promise<HttpResponse<T>>;
+    delete: <T = unknown>(url: string, options?: HttpOptions) => Promise<HttpResponse<T>>;
+    cancel: (reason?: string) => void;
+    clearError: () => void;
+};

package/dist/composables/useHttp.js

@@ -0,0 +1,84 @@
+import { ref as p, computed as v } from "vue";
+const j = (y = {}) => {
+  const h = p(!1), a = p(null), u = p(null), E = v(() => h.value), g = v(() => a.value !== null), T = {
+    baseURL: "",
+    timeout: 1e4,
+    retry: 0,
+    retryDelay: 1e3,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    ...y
+  }, w = (e, s) => {
+    if (e.startsWith("http://") || e.startsWith("https://"))
+      return e;
+    const t = s || T.baseURL || "";
+    return t.endsWith("/") && e.startsWith("/") ? `${t}${e.slice(1)}` : t.endsWith("/") || e.startsWith("/") ? `${t}${e}` : `${t}/${e}`;
+  }, P = (e) => new Promise((s, t) => {
+    setTimeout(() => {
+      t(new Error("Request timeout"));
+    }, e);
+  }), x = (e) => new Promise((s) => {
+    setTimeout(s, e);
+  }), i = async (e, s, t, D = {}) => {
+    a.value = null, h.value = !0, u.value = new AbortController();
+    const n = { ...T, ...D }, L = w(s, n.baseURL), c = {
+      method: e,
+      headers: { ...n.headers },
+      signal: u.value.signal,
+      ...n
+    };
+    t && ["POST", "PUT", "PATCH"].includes(e) && (t instanceof FormData ? (delete c.headers["Content-Type"], c.body = t) : c.body = JSON.stringify(t));
+    const b = async (m = 0) => {
+      try {
+        const o = [fetch(L, c)];
+        n.timeout && o.push(P(n.timeout));
+        const r = await Promise.race(o);
+        if (!r.ok) {
+          const H = `HTTP Error: ${r.status} ${r.statusText}`, d = new Error(H);
+          throw d.status = r.status, d.statusText = r.statusText, d.response = r, d;
+        }
+        let f;
+        const l = r.headers.get("content-type");
+        return l != null && l.includes("application/json") ? f = await r.json() : l != null && l.includes("text/") ? f = await r.text() : f = await r.blob(), {
+          data: f,
+          status: r.status,
+          statusText: r.statusText,
+          headers: r.headers
+        };
+      } catch (o) {
+        const r = o instanceof Error && o.name === "AbortError";
+        if (m < (n.retry || 0) && !r)
+          return await x(n.retryDelay || 1e3), b(m + 1);
+        throw o instanceof Error ? o.name === "AbortError" ? a.value = { message: "Request was cancelled" } : a.value = { message: o.message } : a.value = o, o;
+      }
+    };
+    try {
+      return await b();
+    } finally {
+      h.value = !1, u.value = null;
+    }
+  }, $ = (e, s) => i("GET", e, void 0, s), C = (e, s, t) => i("POST", e, s, t), U = (e, s, t) => i("PUT", e, s, t), A = (e, s, t) => i("PATCH", e, s, t), R = (e, s) => i("DELETE", e, void 0, s), W = (e) => {
+    u.value && u.value.abort(e);
+  }, q = () => {
+    a.value = null;
+  };
+  return {
+    // State
+    loading: E,
+    error: v(() => a.value),
+    hasError: g,
+    // Methods
+    request: i,
+    get: $,
+    post: C,
+    put: U,
+    patch: A,
+    delete: R,
+    cancel: W,
+    clearError: q
+  };
+};
+export {
+  j as useHttp
+};

package/dist/composables/usePartner.d.ts

@@ -0,0 +1,4 @@
+export declare const usePartner: () => {
+    getPartnerName: () => string;
+    getProductType: () => string;
+};

package/dist/composables/usePartner.js

@@ -0,0 +1,16 @@
+import { DefaultProductType as o } from "../enums/defaults.js";
+const p = () => {
+  const e = {
+    email: "newsletter"
+  };
+  return {
+    getPartnerName: () => window.location.hostname.split(".")[0] || "",
+    getProductType: () => {
+      const t = window.location.pathname.split("/").filter(Boolean)[0] || o;
+      return e[t] || t;
+    }
+  };
+};
+export {
+  p as usePartner
+};

package/dist/composables/useStripo.d.ts

@@ -0,0 +1,4 @@
+import type { Metadata, Template } from '@@/Types/stripo';
+export declare const useStripo: (metadata: Metadata) => {
+    initPlugin: (template: Template) => Promise<void>;
+};

package/dist/composables/useStripo.js

@@ -0,0 +1,74 @@
+import { useCustomInterfaceAppearance as m } from "./useCustomInterfaceAppearance.js";
+import { useToaster as g } from "./useToaster.js";
+import { useStripoApi as E } from "../services/stripoApi.js";
+import { useEditorStore as S } from "../stores/editor.js";
+const _ = (c) => {
+  const { handleError: d } = g(), { getToken: u, getCustomFonts: a } = E(), l = (e, i = []) => {
+    const r = S(), { html: t, css: n } = e;
+    window.UIEditor.initEditor(
+      document.querySelector("#guido-editor"),
+      {
+        metadata: c,
+        html: t,
+        css: n,
+        locale: "en",
+        undoButtonSelector: "#guido__undo-button",
+        redoButtonSelector: "#guido__redo-button",
+        mobileViewButtonSelector: ".guido__view-option-selection-mobile",
+        desktopViewButtonSelector: ".guido__view-option-selection-desktop",
+        codeEditorButtonSelector: "#guido__code-button",
+        editorFonts: {
+          showDefaultStandardFonts: !0,
+          showDefaultNotStandardFonts: !0,
+          customFonts: i
+        },
+        async onTokenRefreshRequest(o) {
+          try {
+            const s = await u();
+            o(s);
+          } catch (s) {
+            d(s, "Failed to refresh token");
+          }
+        },
+        onTemplateLoaded() {
+          try {
+            const { importCss: o } = m();
+            o();
+          } catch (o) {
+            d(o, "Failed to load custom interface appearance");
+          }
+        },
+        onCodeEditorVisibilityChanged(o) {
+          r.isCodeEditorOpen = o;
+        },
+        onEditorVisualModeChanged(o) {
+          r.editorVisualMode = o.toLowerCase();
+        },
+        onVersionHistoryVisibilityChanged(o) {
+          r.isVersionHistoryOpen = o;
+        }
+      }
+    );
+  }, p = (e) => new Promise((i, r) => {
+    if (document.getElementById("UiEditorScript")) {
+      e(), i();
+      return;
+    }
+    const t = document.createElement("script");
+    t.id = "UiEditorScript", t.type = "module", t.src = "https://plugins.stripo.email/resources/uieditor/latest/UIEditor.js", t.onload = () => {
+      e(), i();
+    }, t.onerror = () => {
+      const n = new Error("Failed to load Stripo UIEditor script");
+      r(n);
+    }, document.body.appendChild(t);
+  });
+  return { initPlugin: async (e) => {
+    await p(async () => {
+      const i = await a();
+      l(e, i);
+    });
+  } };
+};
+export {
+  _ as useStripo
+};

package/dist/composables/useTemplates.d.ts

@@ -0,0 +1,5 @@
+import type { Template } from '@@/Types/stripo';
+export declare const useTemplates: () => {
+    getDefaultTemplate: () => Promise<Template>;
+    getTemplate: (templateName: string) => Promise<Template>;
+};

package/dist/composables/useTemplates.js

@@ -0,0 +1,27 @@
+const s = () => {
+  const t = async () => {
+    const [e, a] = await Promise.all([
+      // eslint-disable-next-line import/extensions
+      import("../static/templates/default/index.html.js"),
+      import("../static/templates/default/style.css.js")
+    ]);
+    return {
+      html: e.default,
+      css: a.default
+    };
+  };
+  return {
+    getDefaultTemplate: t,
+    getTemplate: async (e) => {
+      switch (e) {
+        case "default":
+          return t();
+        default:
+          return t();
+      }
+    }
+  };
+};
+export {
+  s as useTemplates
+};

package/dist/composables/useToaster.d.ts

@@ -0,0 +1,21 @@
+export type ToasterType = 'success' | 'error' | 'info' | 'warning';
+export type ToasterOptions = {
+    type?: ToasterType;
+    message: string;
+    actionButton?: {
+        text: string;
+        onClick: () => void;
+    };
+};
+export declare const useToaster: () => {
+    isToasterVisible: import("vue").Ref<boolean>;
+    toasterMessage: import("vue").Ref<string>;
+    toasterType: import("vue").Ref<ToasterType>;
+    toasterActionButton: import("vue").Ref<({
+        text: string;
+        onClick: () => void;
+    } | undefined)[]>;
+    showToaster: (options?: ToasterOptions) => void;
+    hideToaster: () => void;
+    handleError: (error: unknown, context: string) => void;
+};

package/dist/composables/useToaster.js

@@ -0,0 +1,37 @@
+import { ref as o, watch as T } from "vue";
+const v = () => {
+  const t = o(!1), s = o(""), c = o("success"), n = o([]);
+  let a = null;
+  function i() {
+    a && (clearTimeout(a), a = null);
+  }
+  function u() {
+    t.value = !1, n.value = [], s.value = "";
+  }
+  function l(e = { message: "" }) {
+    u(), s.value = e.message, c.value = e.type || "success", n.value = e.actionButton ? [e.actionButton] : [], t.value = !0;
+  }
+  function f(e, r) {
+    const m = e instanceof Error ? e.message : String(e);
+    l({
+      type: "error",
+      message: `${r}: ${m}`
+    });
+  }
+  return T([t, s], ([e, r]) => {
+    i(), e && r && (a = setTimeout(() => {
+      u();
+    }, 6e3));
+  }), {
+    isToasterVisible: t,
+    toasterMessage: s,
+    toasterType: c,
+    toasterActionButton: n,
+    showToaster: l,
+    hideToaster: u,
+    handleError: f
+  };
+};
+export {
+  v as useToaster
+};

package/dist/composables/useTranslations.d.ts

@@ -0,0 +1,5 @@
+interface TranslationValues {
+    [key: string]: string | number | boolean;
+}
+export declare const useTranslations: () => ((key: string, params?: TranslationValues) => string) & import("lodash").MemoizedFunction;
+export {};

package/dist/composables/useTranslations.js

@@ -0,0 +1,18 @@
+import memoize from "../node_modules/lodash-es/memoize.js";
+import { ref } from "vue";
+const useTranslations = () => {
+  const translations = ref(eval(window.GuidoConfig.translationsPath)), trans = (n, t) => {
+    const r = translations.value[n];
+    return r ? t ? Object.entries(t).reduce(
+      (e, [o, i]) => e.replace(new RegExp(`{${o}}`, "g"), String(i)),
+      r
+    ) : r : (console.warn(`Translation key not found: ${n}`), n);
+  };
+  return memoize(
+    trans,
+    (n, t) => !t || Object.keys(t).length === 0 ? n : JSON.stringify({ key: n, params: t })
+  );
+};
+export {
+  useTranslations
+};

package/dist/composables/useVersionHistoryApi.d.ts

@@ -0,0 +1,8 @@
+export declare const useVersionHistoryApi: () => {
+    openVersionHistory: () => void;
+    closeVersionHistory: () => void;
+    switchToDesktopPreview: () => void;
+    switchToMobilePreview: () => void;
+    previewVersion: (id: string) => void;
+    restoreVersion: (id: string) => void;
+};

package/dist/composables/useVersionHistoryApi.js

@@ -0,0 +1,53 @@
+import { useVersionHistoryStore as p } from "../stores/version-history.js";
+import { useToaster as c } from "./useToaster.js";
+const l = () => {
+  const i = p(), { showToaster: s } = c(), t = (e) => {
+    i.$reset(), i.updateState(e);
+  }, n = () => {
+    i.$reset();
+  };
+  return {
+    openVersionHistory: () => {
+      window.StripoEditorApi.versionHistoryApi.openVersionHistory(t, n);
+    },
+    closeVersionHistory: () => {
+      window.StripoEditorApi.versionHistoryApi.closeVersionHistory();
+    },
+    switchToDesktopPreview: () => {
+      window.StripoEditorApi.versionHistoryApi.switchToDesktopPreview();
+    },
+    switchToMobilePreview: () => {
+      window.StripoEditorApi.versionHistoryApi.switchToMobilePreview();
+    },
+    previewVersion: (e) => {
+      window.StripoEditorApi.versionHistoryApi.previewVersion(e, (o) => {
+        const r = o instanceof Error ? o.message : String(o);
+        s({
+          type: "error",
+          message: `Error compiling email: ${r}`
+        });
+      });
+    },
+    restoreVersion: (e) => {
+      window.StripoEditorApi.versionHistoryApi.restoreVersion(
+        e,
+        () => {
+          s({
+            type: "success",
+            message: `${e} patch restored successfully.`
+          });
+        },
+        (o) => {
+          const r = o instanceof Error ? o.message : String(o);
+          s({
+            type: "error",
+            message: `Error compiling email: ${r}`
+          });
+        }
+      );
+    }
+  };
+};
+export {
+  l as useVersionHistoryApi
+};

package/dist/enums/defaults.d.ts

@@ -0,0 +1,4 @@
+import type { GuidoConfig } from '@@/Types/generic';
+export declare const DefaultGuidoConfig: GuidoConfig;
+export declare const DefaultProductType = "newsletter";
+export declare const DefaultUsername = "Guido User";

package/dist/enums/defaults.js

@@ -0,0 +1,8 @@
+const t = {
+  translationsPath: "window.trans.en"
+}, e = "newsletter", n = "Guido User";
+export {
+  t as DefaultGuidoConfig,
+  e as DefaultProductType,
+  n as DefaultUsername
+};