@levo-so/core 0.1.49 → 0.1.52

package/dist/client.d.ts

@@ -18,52 +18,52 @@ export declare const createLevoClient: (options: ILevoClientOptions) => {
             current_tab: string;
             all_tabs: string;
         };
-        initiate: (properties: import("./types").ILevoAudience.Properties) => Promise<any>;
+        initiate: (properties: import(".").ILevoAudience.Properties) => Promise<any>;
         identify: (options?: {
             withLock?: boolean;
         }) => Promise<void>;
-        track: <T extends import("./types").ILevoAudience.Properties>(event: import("./types").AnalyticsEventType, properties: T & import("./types").ILevoAudience.Properties) => Promise<any>;
-        bounce: (properties: import("./types").ILevoAudience.Properties) => Promise<void>;
+        track: <T extends import(".").ILevoAudience.Properties>(event: import(".").AnalyticsEventType, properties: T & import(".").ILevoAudience.Properties) => Promise<any>;
+        bounce: (properties: import(".").ILevoAudience.Properties) => Promise<void>;
     };
     readonly blog: {
-        getAllBlogs: (blog_key: string, data?: import("./types").LevoQuery.FindQuery, options?: import("./types").BlogClient.OptionParams) => Promise<import("./types").IResponseMultiple<import("./types").IPost>>;
-        getSingleBlog: (blog_key: string, slug: string, options?: import("./types").BlogClient.OptionParams) => Promise<import("./types").IResponseSingle<import("./types").IPost, any>>;
+        getAllBlogs: (blog_key: string, data?: import(".").LevoQuery.FindQuery, options?: import(".").BlogClient.OptionParams) => Promise<import(".").IResponseMultiple<import(".").BlogClient.BlogData>>;
+        getSingleBlog: (blog_key: string, slug: string, options?: import(".").BlogClient.OptionParams) => Promise<import(".").IResponseSingle<import(".").BlogClient.BlogData>>;
     };
     readonly membership: {
-        getOAuthURL: (options?: import("wretch").WretchOptions) => Promise<import("./types").ILevoMembership.OAuthURLList>;
+        getOAuthURL: (options?: import("wretch").WretchOptions) => Promise<import(".").ILevoMembership.OAuthURLList>;
         signOut: <T = {
             status: boolean;
         }>(options?: import("wretch").WretchOptions) => Promise<T>;
-        getMe: <T = import("./types").ILevoMembership.Account>(options?: import("wretch").WretchOptions) => Promise<T>;
-        updateMe: <T = import("./types").ILevoMembership.Account, D = Partial<Pick<import("./types").ILevoMembership.Account, "first_name" | "last_name" | "username" | "profile_picture">>>(data: D, options?: import("wretch").WretchOptions) => Promise<T>;
-        createPassword: <T = import("./types").ILevoMembership.Account>(data: import("./types").ILevoMembership.Request.CreatePassword, options?: import("wretch").WretchOptions) => Promise<T>;
-        isLoggedIn: <T = import("./types").ILevoMembership.Account>(options?: import("wretch").WretchOptions) => Promise<T | null>;
-        requestMagicLink: (data: import("./types").ILevoMembership.Request.RequestMagicLink, options?: import("wretch").WretchOptions) => Promise<Pick<import("./types").ILevoMembership.Otp, "_id" | "content">>;
-        requestOtp: (data: import("./types").ILevoMembership.Request.RequestOtp, options?: import("wretch").WretchOptions) => Promise<Pick<import("./types").ILevoMembership.Otp, "_id" | "content">>;
-        signInWithOtp: <T = import("./types").ILevoMembership.Account>(data: import("./types").ILevoMembership.Request.SignInWithOtp, options?: import("wretch").WretchOptions) => Promise<T | null>;
-        signInWithPassword: <T = import("./types").ILevoMembership.Account>(data: import("./types").ILevoMembership.Request.SignInWithPassword, options?: import("wretch").WretchOptions) => Promise<T | null>;
-        signUpWithPassword: <T = import("./types").ILevoMembership.Account>(data: import("./types").ILevoMembership.Request.SignUpWithPassword, options?: import("wretch").WretchOptions) => Promise<T | null>;
+        getMe: <T = import(".").ILevoMembership.Account>(options?: import("wretch").WretchOptions) => Promise<T>;
+        updateMe: <T = import(".").ILevoMembership.Account>(data: import(".").ILevoMembership.Request.UpdateMe, options?: import("wretch").WretchOptions) => Promise<T>;
+        createPassword: <T = import(".").ILevoMembership.Account>(data: import(".").ILevoMembership.Request.CreatePassword, options?: import("wretch").WretchOptions) => Promise<T>;
+        isLoggedIn: <T = import(".").ILevoMembership.Account>(options?: import("wretch").WretchOptions) => Promise<T | null>;
+        requestMagicLink: (data: import(".").ILevoMembership.Request.RequestMagicLink, options?: import("wretch").WretchOptions) => Promise<Pick<import(".").ILevoMembership.Otp, "_id" | "content">>;
+        requestOtp: (data: import(".").ILevoMembership.Request.RequestOtp, options?: import("wretch").WretchOptions) => Promise<Pick<import(".").ILevoMembership.Otp, "_id" | "content">>;
+        signInWithOtp: <T = import(".").ILevoMembership.Account>(data: import(".").ILevoMembership.Request.SignInWithOtp, options?: import("wretch").WretchOptions) => Promise<T>;
+        signInWithPassword: <T = import(".").ILevoMembership.Account>(data: import(".").ILevoMembership.Request.SignInWithPassword, options?: import("wretch").WretchOptions) => Promise<T>;
+        signUpWithPassword: <T = import(".").ILevoMembership.Account>(data: import(".").ILevoMembership.Request.SignUpWithPassword, options?: import("wretch").WretchOptions) => Promise<T>;
     };
     readonly collection: {
-        getAllCollections: (data?: import("./types").LevoQuery.FindQuery<"description" | "id" | "workspace_id" | "created_at" | "updated_at" | "key" | "readonly" | "hidden" | "icon" | "name" | "sections" | "views" | "title_field" | "settings" | "module_name" | "on_submit" | "on_update" | "allow_draft">, options?: import("wretch").WretchOptions) => Promise<import("./types").IResponseMultiple<import("./types").ILemaCollection>>;
-        getCollectionByIDExpanded: <T = import("./types").ILemaCollection>(id: string, options?: import("wretch").WretchOptions) => Promise<import("./types").IResponseSingle<T, any>>;
-        createCollection: (data: import("./types").ILemaCollection) => Promise<import("./types").IResponseSingle<import("./types").ILemaCollection, any>>;
+        getAllCollections: (data?: import(".").LevoQuery.FindQuery<"id" | "workspace_id" | "description" | "created_at" | "updated_at" | "key" | "readonly" | "hidden" | "icon" | "name" | "sections" | "views" | "title_field" | "email_field" | "settings" | "module_name" | "on_submit" | "on_update" | "allow_draft">, options?: import("wretch").WretchOptions) => Promise<import(".").IResponseMultiple<import(".").ILemaCollection>>;
+        getCollectionByIDExpanded: <T = import(".").ILemaCollection>(id: string, options?: import("wretch").WretchOptions) => Promise<import(".").IResponseSingle<T>>;
+        createCollection: (data: import(".").ILemaCollection) => Promise<import(".").IResponseSingle<import(".").ILemaCollection>>;
         saveCollectionData: ({ collection_id, data, options, }: {
             collection_id: string;
             data: any;
             options?: import("wretch").WretchOptions;
-        }) => Promise<import("./types").IResponseSingle<any, any>>;
+        }) => Promise<import(".").IResponseSingle<any>>;
         getCollectionContentList: ({ collection_key, page, search, limit, where, }: {
             collection_key: string;
-        } & import("./types").LevoQuery.FindQuery) => Promise<import("./types").IResponseMultiple<Record<string, unknown>>>;
-        saveDraftEntry: (collection_key: string, data: any) => Promise<import("./types").IResponseSingle<import("./types").IDraftEntry, any>>;
-        editDraftEntry: (collection_key: string, id: string, data: any) => Promise<import("./types").IResponseSingle<import("./types").IDraftEntry, any>>;
-        getDraftEntry: (collection_key: string) => Promise<import("./types").IResponseMultiple<import("./types").IDraftEntry>>;
-        submitDraftEntry: (collection_key: string, data: any) => Promise<import("./types").IResponseSingle<import("./types").IDraftEntry, any>>;
+        } & import(".").LevoQuery.FindQuery) => Promise<import(".").IResponseMultiple<Record<string, unknown>>>;
+        saveDraftEntry: (collection_key: string, data: any) => Promise<import(".").IResponseSingle<import(".").IDraftEntry>>;
+        editDraftEntry: (collection_key: string, id: string, data: any) => Promise<import(".").IResponseSingle<import(".").IDraftEntry>>;
+        getDraftEntry: (collection_key: string) => Promise<import(".").IResponseMultiple<import(".").IDraftEntry>>;
+        submitDraftEntry: (collection_key: string, data: any) => Promise<import(".").IResponseSingle<import(".").IDraftEntry>>;
     };
     readonly media: {
-        mediaBulkUpload: (formData: FormData, options?: import("wretch").WretchOptions) => Promise<import("./types").IResponseMultiple<import("./types").IMedia>>;
-        getAllMedia: (data?: import("./types").LevoQuery.FindQuery) => Promise<import("./types").IResponseMultiple<import("./types").IMedia>>;
+        mediaBulkUpload: (formData: FormData, options?: import("wretch").WretchOptions) => Promise<import(".").IResponseMultiple<import(".").IMedia>>;
+        getAllMedia: (data?: import(".").LevoQuery.FindQuery) => Promise<import(".").IResponseMultiple<import(".").IMedia>>;
     };
     readonly logger: {
         debug: (...args: any[]) => void;

package/dist/constants/index.d.ts

@@ -4,4 +4,5 @@ export * from "./collection/fieldKind";
 export * from "./collection/fieldInterfaces";
 export * from "./media";
 export * from "./oauthProvider";
+export * from "./integration";
 //# sourceMappingURL=index.d.ts.map

package/dist/constants/integration.d.ts

@@ -0,0 +1,25 @@
+export declare const LEVO_INTEGRATIONS: {
+    readonly beacon: "so.levo.beacon";
+    readonly blog: "so.levo.blog";
+    readonly collection: "so.levo.collection";
+    readonly event: "so.levo.event";
+    readonly membership: "so.levo.membership";
+    readonly payment: "so.levo.payment";
+    readonly studio: "so.levo.studio";
+    readonly search_console: "com.google.search_console";
+};
+export declare const LEVO_INTEGRATIONS_LIST: ("so.levo.beacon" | "so.levo.blog" | "so.levo.collection" | "so.levo.event" | "so.levo.membership" | "so.levo.payment" | "so.levo.studio" | "com.google.search_console")[];
+export type ILevoIntegrationList = (typeof LEVO_INTEGRATIONS)[keyof typeof LEVO_INTEGRATIONS][];
+export type ILevoIntegrationInstance = {
+    id: string;
+    name: string;
+    publisher: string;
+    description: string;
+    url: string | null;
+    logo: string | null;
+    dashboard_url: string | null;
+    sidebar_icon: string | null;
+    show_on_sidebar: boolean;
+    key: string;
+};
+//# sourceMappingURL=integration.d.ts.map

package/dist/index.js

@@ -272,62 +272,89 @@ var getUserProperties = async () => {
 var LevoError = class extends Error {
   code;
   title;
-  message;
   status;
+  type;
   errors;
   constructor(data) {
-    super(data?.message || data?.description);
+    super(data.description);
     this.name = "Levo Request Error";
-    this.status = data?.status;
-    this.code = data?.code;
-    this.message = data?.message || data?.description;
-    this.title = data?.title;
-    this.errors = data?.errors || [];
+    this.status = data.status;
+    this.code = data.code;
+    this.title = data.title;
+    this.type = data.type;
+    this.errors = data.errors;
+  }
+  /**
+   * Get validation errors for form fields
+   */
+  get fieldErrors() {
+    return this.errors || [];
+  }
+  /**
+   * Check if this is a validation error with field-specific errors
+   */
+  get hasFieldErrors() {
+    return Boolean(this.errors?.length);
   }
 };
 
 // src/utils/getLevoError.ts
 var getLevoError = (error) => {
-  if (error instanceof WretchError) {
+  if (error instanceof LevoError) {
+    return error;
+  }
+  if (error instanceof WretchError && error?.json) {
     const errorResponse = error?.json;
-    if (typeof errorResponse === "object" && errorResponse?.content) {
-      const errorMessage = errorResponse?.content;
-      return new LevoError(errorMessage);
+    return new LevoError({
+      status: errorResponse?.content?.status || 500,
+      code: errorResponse?.content?.code || `Unknown`,
+      title: errorResponse?.content?.title || `HTTP ${error?.status || 500} Error`,
+      description: errorResponse?.content?.description || `Request failed with status ${error?.status || 500}`,
+      type: errorResponse?.content?.type,
+      errors: errorResponse?.content?.errors
+    });
+  }
+  if (error instanceof TypeError) {
+    if (error?.message.includes("Failed to fetch") || error?.message.includes("Network request failed") || error?.message.includes("fetch")) {
+      return new LevoError({
+        status: 0,
+        code: "NETWORK_ERROR",
+        title: "Network Error",
+        description: "Unable to connect to the server. Please check your internet connection."
+      });
+    }
+    if (error?.message.includes("CORS") || error?.message.includes("cross-origin")) {
+      return new LevoError({
+        status: 0,
+        code: "CORS_ERROR",
+        title: "CORS Error",
+        description: "Cross-origin request blocked. Please contact support."
+      });
     }
   }
-  let displayMessage = error?.message || "Something unexpected happened.";
-  switch (error?.message) {
-    case "Network Error":
-      displayMessage = "Couldn't connect to our servers.";
-      break;
+  if (error?.name === "AbortError" || error instanceof DOMException) {
+    return new LevoError({
+      status: 408,
+      code: "REQUEST_TIMEOUT",
+      title: "Request Timeout",
+      description: "The request was cancelled or timed out. Please try again."
+    });
+  }
+  if (error?.request) {
+    return new LevoError({
+      status: error?.response?.status || 500,
+      code: error?.code || "REQUEST_ERROR",
+      title: "Request Error",
+      description: error?.message || "An error occurred while making the request"
+    });
   }
   return new LevoError({
-    status: "500",
-    title: "Network Error",
-    description: displayMessage,
-    code: "UNKNOWN_ERROR"
+    status: 500,
+    code: "UNKNOWN_ERROR",
+    title: "Unexpected Error",
+    description: error?.message || "Something unexpected happened"
   });
 };
-var getParsedError = (error) => {
-  if (error instanceof WretchError) {
-    const errorResponse = error?.json;
-    if (typeof errorResponse === "object" && errorResponse?.content) {
-      return errorResponse?.content;
-    }
-  }
-  let displayMessage = error?.message || "Something unexpected happened.";
-  switch (error?.message) {
-    case "Network Error":
-      displayMessage = "Couldn't connect to our servers.";
-      break;
-  }
-  return {
-    status: "500",
-    title: "Network Error",
-    description: displayMessage,
-    code: "UNKNOWN_ERROR"
-  };
-};
 
 // src/utils/lock.ts
 var LocalStorageLock = class {
@@ -447,14 +474,20 @@ var createLevoAudienceModule = (core, httpClient) => {
       withLock
     });
   };
-  const request = (url, data) => {
+  const request = async (url, data) => {
     const headers = {
       Accept: "application/json",
       "Content-Type": "application/json"
     };
-    return httpClient.instance.url(core?.insightsUrl, true).url(url).options({
-      keepAlive: true
-    }).headers(headers).post(data).json();
+    try {
+      const response = await httpClient.instance.url(core?.insightsUrl, true).url(url).options({
+        keepAlive: true
+      }).headers(headers).post(data).json();
+      return response;
+    } catch (error) {
+      console.warn(`Analytics request failed for ${url}:`, error);
+      return null;
+    }
   };
   const initiate = async (properties) => {
     if (core.NODE_ENV === "development") {
@@ -496,12 +529,11 @@ var createLevoAudienceModule = (core, httpClient) => {
           tab_count: getTabCount()
         };
         let isQueued = false;
-        try {
+        if (navigator.sendBeacon) {
           isQueued = navigator.sendBeacon(
             `${core?.insightsUrl}/v1/insights/event/collect`,
             JSON.stringify(collectInput)
           );
-        } catch (e) {
         }
         if (!isQueued) {
           request("/v1/insights/event/collect", collectInput);
@@ -548,15 +580,18 @@ var createLevoAudienceModule = (core, httpClient) => {
         if (!identifyLock || identifyLock.acquireLock()) {
           request(`/v1/insights/event/welcome`, welcomeInput).then((data) => {
             is_identified = true;
-            _session = data.content.data.session;
-            _device = data.content.data.device;
+            if (data?.content?.data?.session) {
+              _session = data?.content.data.session;
+            }
+            if (data?.content?.data?.device) {
+              _device = data?.content.data.device;
+            }
             let isQueued = false;
-            try {
+            if (navigator.sendBeacon) {
               isQueued = navigator.sendBeacon(
                 `${core?.insightsUrl}/v1/insights/event/bulk?workspace=${core?.workspace}`,
                 JSON.stringify(_batch)
               );
-            } catch (e) {
             }
             if (!isQueued) {
               request("/v1/insights/event/bulk", _batch);
@@ -785,7 +820,7 @@ var createLogBatch = (options = {}) => {
     try {
       await sendLogs(tasks);
     } catch (e) {
-      console.log("error sending logs", e);
+      console.error("error sending logs", e);
     } finally {
       lastFlush = /* @__PURE__ */ new Date();
     }
@@ -927,19 +962,23 @@ var createLevoLogger = (core, options = {}) => {
 
 // src/modules/blog.ts
 var createLevoBlogModule = (core, httpClient, audience = null) => {
-  const getAllBlogs = (blog_key, data = {}, options) => {
+  const getAllBlogs = async (blog_key, data = {}, options) => {
     return httpClient.instance.url(`/v1/blog/${blog_key}/post/query`).query({ ...options?.params || {} }).options({
       headers: {
         "Levo-Workspace": options?.workspace_id || void 0
       }
-    }).post(data).json();
+    }).post(data).json().then((response) => response).catch((error) => {
+      throw getLevoError(error);
+    });
   };
-  const getSingleBlog = (blog_key, slug, options) => {
+  const getSingleBlog = async (blog_key, slug, options) => {
     return httpClient.instance.url(`/v1/blog/${blog_key}/post/${slug}`).query({ ...options?.params || {} }).options({
       headers: {
         "Levo-Workspace": options?.workspace_id || void 0
       }
-    }).get().json();
+    }).get().json().then((response) => response).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   return {
     getAllBlogs,
@@ -950,20 +989,28 @@ var createLevoBlogModule = (core, httpClient, audience = null) => {
 // src/modules/collection.ts
 var createLevoCollectionModule = (core, httpsClient, audience = null) => {
   const getAllCollections = async (data = {}, options = {}) => {
-    return httpsClient.instance.url("/v1/bevy/collection/query").options(options).post(data).json();
+    return httpsClient.instance.url("/v1/bevy/collection/query").options(options).post(data).json().then((response) => response).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const getCollectionByIDExpanded = async (id, options = {}) => {
-    return httpsClient.instance.url(`/v1/bevy/collection/${id}`).options(options).get().json();
+    return httpsClient.instance.url(`/v1/bevy/collection/${id}`).options(options).get().json().then((response) => response).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const createCollection = async (data) => {
-    return httpsClient.instance.url("/v1/bevy/collection").post(data).json();
+    return httpsClient.instance.url("/v1/bevy/collection").post(data).json().then((response) => response).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const saveCollectionData = async ({
     collection_id,
     data,
     options = {}
   }) => {
-    return httpsClient.instance.url(`/v1/bevy/content/${collection_id}`).options(options).post(data).json();
+    return httpsClient.instance.url(`/v1/bevy/content/${collection_id}`).options(options).post(data).json().then((response) => response).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const getCollectionContentList = async ({
     collection_key,
@@ -977,19 +1024,29 @@ var createLevoCollectionModule = (core, httpsClient, audience = null) => {
       limit,
       search,
       where
-    }).json();
+    }).json().then((response) => response).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const saveDraftEntry = async (collection_key, data) => {
-    return httpsClient.instance.url(`/v1/bevy/content/${collection_key}/save-entry`).post(data).json();
+    return httpsClient.instance.url(`/v1/bevy/content/${collection_key}/save-entry`).post(data).json().then((response) => response).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const editDraftEntry = async (collection_key, id, data) => {
-    return httpsClient.instance.url(`/v1/bevy/content/${collection_key}/${id}/edit-entry`).put(data).json();
+    return httpsClient.instance.url(`/v1/bevy/content/${collection_key}/${id}/edit-entry`).put(data).json().then((response) => response).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const getDraftEntry = async (collection_key) => {
-    return httpsClient.instance.url(`/v1/bevy/content/${collection_key}/list-entry`).get().json();
+    return httpsClient.instance.url(`/v1/bevy/content/${collection_key}/list-entry`).get().json().then((response) => response).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const submitDraftEntry = async (collection_key, data) => {
-    return httpsClient.instance.url(`/v1/bevy/content/${collection_key}/submit-entry`).post(data).json();
+    return httpsClient.instance.url(`/v1/bevy/content/${collection_key}/submit-entry`).post(data).json().then((response) => response).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   return {
     getAllCollections,
@@ -1006,11 +1063,15 @@ var createLevoCollectionModule = (core, httpsClient, audience = null) => {
 
 // src/modules/media.ts
 var createLevoMediaModule = (core, httpsClient, audience = null) => {
-  const mediaBulkUpload = (formData, options = {}) => {
-    return httpsClient.instance.url("/v1/assets/media/bulk").options(options).post(formData).json();
+  const mediaBulkUpload = async (formData, options = {}) => {
+    return httpsClient.instance.url("/v1/assets/media/bulk").options(options).post(formData).json().then((response) => response).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const getAllMedia = async (data = {}) => {
-    return await httpsClient.instance.url("/v1/assets/media/query").post(data).json();
+    return httpsClient.instance.url("/v1/assets/media/query").post(data).json().then((response) => response).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   return {
     mediaBulkUpload,
@@ -1028,8 +1089,7 @@ var LevoOAuthProviderList = [
 // src/modules/membership.ts
 var createLevoMembershipModule = (core, httpsClient, audience = null) => {
   const getOAuthURL = async (options = {}) => {
-    try {
-      const response = await httpsClient.instance.url("/v1/membership/auth/oauth/get-redirect-url").options(options).get().json();
+    return httpsClient.instance.url("/v1/membership/auth/oauth/get-redirect-url").options(options).get().json().then((response) => {
       const result = response?.content?.data;
       const providers = Object.keys(result);
       if (typeof window !== "undefined") {
@@ -1053,58 +1113,63 @@ var createLevoMembershipModule = (core, httpsClient, audience = null) => {
         }
       }
       return result;
-    } catch {
+    }).catch(() => {
       return LevoOAuthProviderList.reduce((acc, provider) => {
         acc[provider] = null;
         return acc;
       }, {});
-    }
+    });
   };
   const signOut = async (options = {}) => {
-    return httpsClient.instance.url("/v1/membership/auth/sign-out").options(options).post("").json();
+    return httpsClient.instance.url("/v1/membership/auth/sign-out").options(options).post("").json().then((response) => response?.content?.data).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const getMe = async (options = {}) => {
-    const response = await httpsClient.instance.url("/v1/membership/auth/get-me").options(options).get().json();
-    return response?.content?.data;
+    return httpsClient.instance.url("/v1/membership/auth/get-me").options(options).get().json().then((response) => response?.content?.data).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const updateMe = async (data, options = {}) => {
-    const response = await httpsClient.instance.url("/v1/membership/auth/update-me").options(options).put(data).json();
-    return response?.content?.data;
+    return httpsClient.instance.url("/v1/membership/auth/update-me").options(options).put(data).json().then((response) => response?.content?.data).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const createPassword = async (data, options = {}) => {
-    const response = await httpsClient.instance.url("/v1/membership/auth/change-password").options(options).put(data).json();
-    return response?.content?.data;
+    return httpsClient.instance.url("/v1/membership/auth/change-password").options(options).put(data).json().then((response) => response?.content?.data).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const isLoggedIn = async (options = {}) => {
-    try {
-      const account = await getMe(options);
-      return account;
-    } catch (_) {
-      return null;
-    }
+    return getMe(options).then((account) => account).catch(() => null);
   };
   const requestMagicLink = async (data, options = {}) => {
     if (typeof window !== "undefined" && !data.redirect_uri) {
       data.redirect_uri = window.location.href;
     }
-    const response = await httpsClient.instance.url("/v1/membership/auth/request-magic-link").options(options).post(data).json();
-    return response?.content?.data;
+    return httpsClient.instance.url("/v1/membership/auth/request-magic-link").options(options).post(data).json().then((response) => response?.content?.data).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const requestOtp = async (data, options = {}) => {
-    const response = await httpsClient.instance.url("/v1/membership/auth/request-otp").options(options).post(data).json();
-    return response?.content?.data;
+    return httpsClient.instance.url("/v1/membership/auth/request-otp").options(options).post(data).json().then((response) => response?.content?.data).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const signInWithOtp = async (data, options = {}) => {
-    const response = await httpsClient.instance.url("/v1/membership/auth/signin-with-otp").options(options).post(data).json();
-    return response?.content?.data;
+    return httpsClient.instance.url("/v1/membership/auth/signin-with-otp").options(options).post(data).json().then((response) => response?.content?.data).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const signInWithPassword = async (data, options = {}) => {
-    const response = await httpsClient.instance.url("/v1/membership/auth/signin-with-password").options(options).post(data).json();
-    return response?.content?.data;
+    return httpsClient.instance.url("/v1/membership/auth/signin-with-password").options(options).post(data).json().then((response) => response?.content?.data).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   const signUpWithPassword = async (data, options = {}) => {
-    const response = await httpsClient.instance.url("/v1/membership/auth/signup-with-password").options(options).post(data).json();
-    return response?.content?.data;
+    return httpsClient.instance.url("/v1/membership/auth/signup-with-password").options(options).post(data).json().then((response) => response?.content?.data).catch((error) => {
+      throw getLevoError(error);
+    });
   };
   return {
     getOAuthURL,
@@ -1284,7 +1349,12 @@ var defaultByKinds = {
   identifier: null,
   record: null,
   group: [],
-  collection: null,
+  collection: {
+    o2m: null,
+    m2o: null,
+    o2o: null,
+    m2m: []
+  },
   richtext: {
     html: "",
     text: "",
@@ -1444,6 +1514,19 @@ var MediaKind = MediaKindList.reduce(
   {}
 );
 
+// src/constants/integration.ts
+var LEVO_INTEGRATIONS = {
+  beacon: "so.levo.beacon",
+  blog: "so.levo.blog",
+  collection: "so.levo.collection",
+  event: "so.levo.event",
+  membership: "so.levo.membership",
+  payment: "so.levo.payment",
+  studio: "so.levo.studio",
+  search_console: "com.google.search_console"
+};
+var LEVO_INTEGRATIONS_LIST = Object.values(LEVO_INTEGRATIONS);
+
 // src/utils/formatImagePath.ts
 var formatImagePath = (string) => {
   const parts = string.split("/");
@@ -1455,4 +1538,4 @@ var formatImagePath = (string) => {
   return "";
 };
 
-export { AnalyticsEvents, AnalyticsEventsList, FieldInterfaces, FieldInterfacesList, FieldKind, FieldKindList, LevoError, LevoOAuthProviderList, LocalStorageLock, MediaKind, MediaKindList, createLevoClient, defaultByKinds, formatImagePath, formatsByInterface, getLevoError, getParsedError, interfaceKinds };
+export { AnalyticsEvents, AnalyticsEventsList, FieldInterfaces, FieldInterfacesList, FieldKind, FieldKindList, LEVO_INTEGRATIONS, LEVO_INTEGRATIONS_LIST, LevoError, LevoOAuthProviderList, LocalStorageLock, MediaKind, MediaKindList, createLevoClient, defaultByKinds, formatImagePath, formatsByInterface, getLevoError, interfaceKinds };

package/dist/modules/blog.d.ts

@@ -4,7 +4,7 @@ import { ILevoControl } from "../control";
 import { ILevoAudienceModule } from "../control/audience";
 import { IHttpClient } from "../httpClient";
 export declare const createLevoBlogModule: (core: ILevoControl, httpClient: IHttpClient, audience?: ILevoAudienceModule | null) => {
-    getAllBlogs: (blog_key: string, data?: LevoQuery.FindQuery, options?: BlogClient.OptionParams) => Promise<IResponseMultiple<import("..").IPost>>;
-    getSingleBlog: (blog_key: string, slug: string, options?: BlogClient.OptionParams) => Promise<IResponseSingle<import("..").IPost, any>>;
+    getAllBlogs: (blog_key: string, data?: LevoQuery.FindQuery, options?: BlogClient.OptionParams) => Promise<IResponseMultiple<BlogClient.BlogData>>;
+    getSingleBlog: (blog_key: string, slug: string, options?: BlogClient.OptionParams) => Promise<IResponseSingle<BlogClient.BlogData>>;
 };
 //# sourceMappingURL=blog.d.ts.map

package/dist/modules/collection.d.ts

@@ -7,20 +7,20 @@ import { IHttpClient } from "../httpClient";
 type ColumnKeys = Prettify<keyof ILemaCollection>;
 export declare const createLevoCollectionModule: (core: ILevoControl, httpsClient: IHttpClient, audience?: ILevoAudienceModule | null) => {
     getAllCollections: (data?: LevoQuery.FindQuery<ColumnKeys>, options?: WretchOptions) => Promise<IResponseMultiple<ILemaCollection>>;
-    getCollectionByIDExpanded: <T = ILemaCollection>(id: string, options?: WretchOptions) => Promise<IResponseSingle<T, any>>;
-    createCollection: (data: ILemaCollection) => Promise<IResponseSingle<ILemaCollection, any>>;
+    getCollectionByIDExpanded: <T = ILemaCollection>(id: string, options?: WretchOptions) => Promise<IResponseSingle<T>>;
+    createCollection: (data: ILemaCollection) => Promise<IResponseSingle<ILemaCollection>>;
     saveCollectionData: ({ collection_id, data, options, }: {
         collection_id: string;
         data: any;
         options?: WretchOptions;
-    }) => Promise<IResponseSingle<any, any>>;
+    }) => Promise<IResponseSingle<any>>;
     getCollectionContentList: ({ collection_key, page, search, limit, where, }: {
         collection_key: string;
     } & LevoQuery.FindQuery) => Promise<IResponseMultiple<Record<string, unknown>>>;
-    saveDraftEntry: (collection_key: string, data: any) => Promise<IResponseSingle<IDraftEntry, any>>;
-    editDraftEntry: (collection_key: string, id: string, data: any) => Promise<IResponseSingle<IDraftEntry, any>>;
+    saveDraftEntry: (collection_key: string, data: any) => Promise<IResponseSingle<IDraftEntry>>;
+    editDraftEntry: (collection_key: string, id: string, data: any) => Promise<IResponseSingle<IDraftEntry>>;
     getDraftEntry: (collection_key: string) => Promise<IResponseMultiple<IDraftEntry>>;
-    submitDraftEntry: (collection_key: string, data: any) => Promise<IResponseSingle<IDraftEntry, any>>;
+    submitDraftEntry: (collection_key: string, data: any) => Promise<IResponseSingle<IDraftEntry>>;
 };
 export {};
 //# sourceMappingURL=collection.d.ts.map

package/dist/modules/membership.d.ts

@@ -9,13 +9,13 @@ export declare const createLevoMembershipModule: (core: ILevoControl, httpsClien
         status: boolean;
     }>(options?: WretchOptions) => Promise<T>;
     getMe: <T = ILevoMembership.Account>(options?: WretchOptions) => Promise<T>;
-    updateMe: <T = ILevoMembership.Account, D = Partial<Pick<ILevoMembership.Account, "first_name" | "last_name" | "username" | "profile_picture">>>(data: D, options?: WretchOptions) => Promise<T>;
+    updateMe: <T = ILevoMembership.Account>(data: ILevoMembership.Request.UpdateMe, options?: WretchOptions) => Promise<T>;
     createPassword: <T = ILevoMembership.Account>(data: ILevoMembership.Request.CreatePassword, options?: WretchOptions) => Promise<T>;
     isLoggedIn: <T = ILevoMembership.Account>(options?: WretchOptions) => Promise<T | null>;
     requestMagicLink: (data: ILevoMembership.Request.RequestMagicLink, options?: WretchOptions) => Promise<Pick<ILevoMembership.Otp, "_id" | "content">>;
     requestOtp: (data: ILevoMembership.Request.RequestOtp, options?: WretchOptions) => Promise<Pick<ILevoMembership.Otp, "_id" | "content">>;
-    signInWithOtp: <T = ILevoMembership.Account>(data: ILevoMembership.Request.SignInWithOtp, options?: WretchOptions) => Promise<T | null>;
-    signInWithPassword: <T = ILevoMembership.Account>(data: ILevoMembership.Request.SignInWithPassword, options?: WretchOptions) => Promise<T | null>;
-    signUpWithPassword: <T = ILevoMembership.Account>(data: ILevoMembership.Request.SignUpWithPassword, options?: WretchOptions) => Promise<T | null>;
+    signInWithOtp: <T = ILevoMembership.Account>(data: ILevoMembership.Request.SignInWithOtp, options?: WretchOptions) => Promise<T>;
+    signInWithPassword: <T = ILevoMembership.Account>(data: ILevoMembership.Request.SignInWithPassword, options?: WretchOptions) => Promise<T>;
+    signUpWithPassword: <T = ILevoMembership.Account>(data: ILevoMembership.Request.SignUpWithPassword, options?: WretchOptions) => Promise<T>;
 };
 //# sourceMappingURL=membership.d.ts.map