@nextsparkjs/core 0.1.0-beta.67 → 0.1.0-beta.69

package/dist/lib/actions/team.actions.js

@@ -0,0 +1,220 @@
+"use server";
+import { revalidatePath } from "next/cache";
+import { headers } from "next/headers";
+import { getTypedSession } from "../auth.js";
+import { TeamService } from "../services/team.service.js";
+import { TeamMemberService } from "../services/team-member.service.js";
+async function getAuthUser() {
+  var _a;
+  const headersList = await headers();
+  const session = await getTypedSession(headersList);
+  if (!((_a = session == null ? void 0 : session.user) == null ? void 0 : _a.id)) {
+    return { success: false, error: "Authentication required" };
+  }
+  return { success: true, userId: session.user.id };
+}
+async function verifyTeamPermission(userId, teamId, requiredRoles = ["owner", "admin"]) {
+  const hasPermission = await TeamMemberService.hasPermission(
+    userId,
+    teamId,
+    requiredRoles
+  );
+  if (!hasPermission) {
+    return { success: false, error: "Permission denied. Required role: " + requiredRoles.join(" or ") };
+  }
+  return { success: true };
+}
+async function updateTeam(teamId, data) {
+  try {
+    if (!(teamId == null ? void 0 : teamId.trim())) {
+      return { success: false, error: "Team ID is required" };
+    }
+    if (!data || Object.keys(data).length === 0) {
+      return { success: false, error: "No fields provided for update" };
+    }
+    const authResult = await getAuthUser();
+    if (!authResult.success) {
+      return { success: false, error: authResult.error };
+    }
+    const { userId } = authResult;
+    const permResult = await verifyTeamPermission(userId, teamId, ["owner", "admin"]);
+    if (!permResult.success) {
+      return { success: false, error: permResult.error };
+    }
+    const updatePayload = {};
+    if (data.name !== void 0) updatePayload.name = data.name;
+    if (data.slug !== void 0) updatePayload.slug = data.slug;
+    if (data.description !== void 0) updatePayload.description = data.description;
+    if (data.avatarUrl !== void 0) updatePayload.avatarUrl = data.avatarUrl;
+    if (data.settings !== void 0) updatePayload.settings = data.settings;
+    if (Object.keys(updatePayload).length === 0) {
+      return { success: false, error: "No valid fields provided for update" };
+    }
+    if (updatePayload.slug) {
+      const isAvailable = await TeamService.isSlugAvailable(updatePayload.slug, teamId);
+      if (!isAvailable) {
+        return { success: false, error: "Team slug is already taken" };
+      }
+    }
+    const updatedTeam = await TeamService.update(teamId, updatePayload, userId);
+    revalidatePath("/dashboard/settings/team");
+    revalidatePath("/dashboard");
+    return { success: true, data: updatedTeam };
+  } catch (error) {
+    console.error("[updateTeam] Error:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to update team"
+    };
+  }
+}
+async function inviteMember(teamId, email, role = "member") {
+  try {
+    if (!(teamId == null ? void 0 : teamId.trim())) {
+      return { success: false, error: "Team ID is required" };
+    }
+    if (!(email == null ? void 0 : email.trim())) {
+      return { success: false, error: "Email is required" };
+    }
+    const validRoles = ["admin", "member", "viewer"];
+    if (!validRoles.includes(role)) {
+      return { success: false, error: "Invalid role. Must be admin, member, or viewer" };
+    }
+    const authResult = await getAuthUser();
+    if (!authResult.success) {
+      return { success: false, error: authResult.error };
+    }
+    const { userId } = authResult;
+    const permResult = await verifyTeamPermission(userId, teamId, ["owner", "admin"]);
+    if (!permResult.success) {
+      return { success: false, error: permResult.error };
+    }
+    const { UserService } = await import("../services/user.service.js");
+    const targetUser = await UserService.getUserByEmail(email, userId);
+    if (!targetUser) {
+      return { success: false, error: "User not found. They must create an account first." };
+    }
+    const existingMember = await TeamMemberService.getByTeamAndUser(teamId, targetUser.id);
+    if (existingMember) {
+      return { success: false, error: "User is already a member of this team" };
+    }
+    const member = await TeamMemberService.add(teamId, targetUser.id, role, {
+      invitedBy: userId
+    });
+    revalidatePath("/dashboard/settings/team");
+    revalidatePath("/dashboard/settings/team/members");
+    return {
+      success: true,
+      data: {
+        memberId: member.id,
+        userId: member.userId,
+        teamId: member.teamId,
+        role: member.role
+      }
+    };
+  } catch (error) {
+    console.error("[inviteMember] Error:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to invite member"
+    };
+  }
+}
+async function removeMember(teamId, memberId) {
+  try {
+    if (!(teamId == null ? void 0 : teamId.trim())) {
+      return { success: false, error: "Team ID is required" };
+    }
+    if (!(memberId == null ? void 0 : memberId.trim())) {
+      return { success: false, error: "Member ID is required" };
+    }
+    const authResult = await getAuthUser();
+    if (!authResult.success) {
+      return { success: false, error: authResult.error };
+    }
+    const { userId } = authResult;
+    const permResult = await verifyTeamPermission(userId, teamId, ["owner", "admin"]);
+    if (!permResult.success) {
+      return { success: false, error: permResult.error };
+    }
+    const targetUserId = memberId;
+    if (targetUserId === userId) {
+      const selfRole = await TeamMemberService.getRole(teamId, userId);
+      if (selfRole === "owner") {
+        return { success: false, error: "Cannot remove yourself as owner. Transfer ownership first." };
+      }
+    }
+    const targetRole = await TeamMemberService.getRole(teamId, targetUserId);
+    if (targetRole === "owner") {
+      return { success: false, error: "Cannot remove team owner. Transfer ownership first." };
+    }
+    const requestorRole = await TeamMemberService.getRole(teamId, userId);
+    if (requestorRole === "admin" && targetRole === "admin" && targetUserId !== userId) {
+      return { success: false, error: "Admins cannot remove other admins. Only the owner can do that." };
+    }
+    await TeamMemberService.remove(teamId, targetUserId);
+    revalidatePath("/dashboard/settings/team");
+    revalidatePath("/dashboard/settings/team/members");
+    return { success: true };
+  } catch (error) {
+    console.error("[removeMember] Error:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to remove member"
+    };
+  }
+}
+async function updateMemberRole(teamId, memberId, role) {
+  try {
+    if (!(teamId == null ? void 0 : teamId.trim())) {
+      return { success: false, error: "Team ID is required" };
+    }
+    if (!(memberId == null ? void 0 : memberId.trim())) {
+      return { success: false, error: "Member ID is required" };
+    }
+    const validRoles = ["admin", "member", "viewer"];
+    if (!validRoles.includes(role)) {
+      return { success: false, error: "Invalid role. Must be admin, member, or viewer. Use transferOwnership for owner." };
+    }
+    const authResult = await getAuthUser();
+    if (!authResult.success) {
+      return { success: false, error: authResult.error };
+    }
+    const { userId } = authResult;
+    const requestorRole = await TeamMemberService.getRole(teamId, userId);
+    if (!requestorRole) {
+      return { success: false, error: "You are not a member of this team" };
+    }
+    const targetUserId = memberId;
+    const currentRole = await TeamMemberService.getRole(teamId, targetUserId);
+    if (!currentRole) {
+      return { success: false, error: "Member not found in this team" };
+    }
+    if (currentRole === "owner") {
+      return { success: false, error: "Cannot change owner role. Use transferOwnership instead." };
+    }
+    if ((role === "admin" || currentRole === "admin") && requestorRole !== "owner") {
+      return { success: false, error: "Only the team owner can promote to or demote from admin" };
+    }
+    if (requestorRole === "admin" && (role === "member" || role === "viewer")) {
+    } else if (requestorRole !== "owner" && requestorRole !== "admin") {
+      return { success: false, error: "Permission denied. You must be an owner or admin." };
+    }
+    const updatedMember = await TeamMemberService.updateRole(teamId, targetUserId, role);
+    revalidatePath("/dashboard/settings/team");
+    revalidatePath("/dashboard/settings/team/members");
+    return { success: true, data: updatedMember };
+  } catch (error) {
+    console.error("[updateMemberRole] Error:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to update member role"
+    };
+  }
+}
+export {
+  inviteMember,
+  removeMember,
+  updateMemberRole,
+  updateTeam
+};

package/dist/lib/actions/user.actions.d.ts

@@ -0,0 +1,99 @@
+import type { EntityActionResult, EntityActionVoidResult } from './types';
+/**
+ * Profile update data that can be passed to updateProfile
+ */
+export interface UpdateProfileData {
+    firstName?: string;
+    lastName?: string;
+    name?: string;
+    country?: string;
+    timezone?: string;
+    language?: string;
+}
+/**
+ * Result of profile update with user data
+ */
+export interface ProfileUpdateResult {
+    id: string;
+    email: string;
+    name?: string;
+    firstName?: string;
+    lastName?: string;
+    image?: string;
+    country?: string;
+    timezone?: string;
+    language?: string;
+}
+/**
+ * Update the current user's profile information
+ *
+ * Auth is automatically obtained from session - users can only update their own profile.
+ *
+ * @param data - Profile fields to update
+ * @returns Updated user data wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * const result = await updateProfile({
+ *   firstName: 'John',
+ *   lastName: 'Doe',
+ *   timezone: 'America/New_York'
+ * })
+ *
+ * if (result.success) {
+ *   console.log('Profile updated:', result.data)
+ * } else {
+ *   console.error('Error:', result.error)
+ * }
+ * ```
+ */
+export declare function updateProfile(data: UpdateProfileData): Promise<EntityActionResult<ProfileUpdateResult>>;
+/**
+ * Update the current user's avatar image
+ *
+ * Accepts FormData with an 'avatar' or 'image' field containing the image URL or file path.
+ * For actual file uploads, the file should be uploaded to storage first and the URL passed here.
+ *
+ * @param formData - FormData with 'avatar' or 'image' field containing the image URL
+ * @returns Updated user data wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * // After uploading file to storage
+ * const formData = new FormData()
+ * formData.append('avatar', imageUrl)
+ * const result = await updateAvatar(formData)
+ *
+ * if (result.success) {
+ *   console.log('Avatar updated:', result.data.image)
+ * }
+ * ```
+ */
+export declare function updateAvatar(formData: FormData): Promise<EntityActionResult<ProfileUpdateResult>>;
+/**
+ * Delete the current user's account
+ *
+ * This is a destructive operation that:
+ * - Removes the user from all teams
+ * - Deletes user metadata
+ * - Deletes the user account
+ *
+ * Teams owned by the user must have ownership transferred first or be deleted.
+ *
+ * @returns Success status
+ *
+ * @example
+ * ```typescript
+ * // Show confirmation dialog first!
+ * const confirmed = window.confirm('Are you sure? This cannot be undone.')
+ * if (confirmed) {
+ *   const result = await deleteAccount()
+ *   if (result.success) {
+ *     // Redirect to goodbye page or login
+ *     router.push('/goodbye')
+ *   }
+ * }
+ * ```
+ */
+export declare function deleteAccount(): Promise<EntityActionVoidResult>;
+//# sourceMappingURL=user.actions.d.ts.map

package/dist/lib/actions/user.actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.actions.d.ts","sourceRoot":"","sources":["../../../src/lib/actions/user.actions.ts"],"names":[],"mappings":"AAoCA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAMzE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAMD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,CAAC,CA2DlD;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,CAAC,CAsElD;AAMD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAsDrE"}

package/dist/lib/actions/user.actions.js

@@ -0,0 +1,149 @@
+"use server";
+import { revalidatePath } from "next/cache";
+import { headers } from "next/headers";
+import { getTypedSession } from "../auth.js";
+import { UserService } from "../services/user.service.js";
+async function updateProfile(data) {
+  var _a;
+  try {
+    const headersList = await headers();
+    const session = await getTypedSession(headersList);
+    if (!((_a = session == null ? void 0 : session.user) == null ? void 0 : _a.id)) {
+      return { success: false, error: "Authentication required" };
+    }
+    const userId = session.user.id;
+    if (!data || Object.keys(data).length === 0) {
+      return { success: false, error: "No fields provided for update" };
+    }
+    const updatePayload = {};
+    if (data.firstName !== void 0) updatePayload.firstName = data.firstName;
+    if (data.lastName !== void 0) updatePayload.lastName = data.lastName;
+    if (data.name !== void 0) updatePayload.name = data.name;
+    if (data.country !== void 0) updatePayload.country = data.country;
+    if (data.timezone !== void 0) updatePayload.timezone = data.timezone;
+    if (data.language !== void 0) updatePayload.language = data.language;
+    if (Object.keys(updatePayload).length === 0) {
+      return { success: false, error: "No valid fields provided for update" };
+    }
+    const updatedUser = await UserService.updateUser(userId, updatePayload, userId);
+    revalidatePath("/dashboard/settings");
+    revalidatePath("/dashboard/settings/profile");
+    return {
+      success: true,
+      data: {
+        id: updatedUser.id,
+        email: updatedUser.email,
+        name: updatedUser.name ?? void 0,
+        firstName: updatedUser.firstName ?? void 0,
+        lastName: updatedUser.lastName ?? void 0,
+        image: updatedUser.image ?? void 0,
+        country: updatedUser.country ?? void 0,
+        timezone: updatedUser.timezone ?? void 0,
+        language: updatedUser.language ?? void 0
+      }
+    };
+  } catch (error) {
+    console.error("[updateProfile] Error:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to update profile"
+    };
+  }
+}
+async function updateAvatar(formData) {
+  var _a;
+  try {
+    const headersList = await headers();
+    const session = await getTypedSession(headersList);
+    if (!((_a = session == null ? void 0 : session.user) == null ? void 0 : _a.id)) {
+      return { success: false, error: "Authentication required" };
+    }
+    const userId = session.user.id;
+    const avatarValue = formData.get("avatar") ?? formData.get("image");
+    if (!avatarValue) {
+      return { success: false, error: "Avatar image is required" };
+    }
+    let imageUrl;
+    if (typeof avatarValue === "string") {
+      imageUrl = avatarValue;
+    } else {
+      return {
+        success: false,
+        error: "Please upload the image first and pass the URL"
+      };
+    }
+    if (!imageUrl.startsWith("http://") && !imageUrl.startsWith("https://") && !imageUrl.startsWith("/")) {
+      return { success: false, error: "Invalid image URL format" };
+    }
+    const updatedUser = await UserService.updateUser(
+      userId,
+      { image: imageUrl },
+      userId
+    );
+    revalidatePath("/dashboard/settings");
+    revalidatePath("/dashboard/settings/profile");
+    revalidatePath("/dashboard");
+    return {
+      success: true,
+      data: {
+        id: updatedUser.id,
+        email: updatedUser.email,
+        name: updatedUser.name ?? void 0,
+        firstName: updatedUser.firstName ?? void 0,
+        lastName: updatedUser.lastName ?? void 0,
+        image: updatedUser.image ?? void 0,
+        country: updatedUser.country ?? void 0,
+        timezone: updatedUser.timezone ?? void 0,
+        language: updatedUser.language ?? void 0
+      }
+    };
+  } catch (error) {
+    console.error("[updateAvatar] Error:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to update avatar"
+    };
+  }
+}
+async function deleteAccount() {
+  var _a;
+  try {
+    const headersList = await headers();
+    const session = await getTypedSession(headersList);
+    if (!((_a = session == null ? void 0 : session.user) == null ? void 0 : _a.id)) {
+      return { success: false, error: "Authentication required" };
+    }
+    const userId = session.user.id;
+    const { TeamService } = await import("../services/team.service.js");
+    const ownedTeams = await TeamService.getByOwnerId(userId);
+    if (ownedTeams.length > 0) {
+      return {
+        success: false,
+        error: "Cannot delete account while owning teams. Transfer ownership or delete teams first."
+      };
+    }
+    await UserService.deleteAllUserMetas(userId, userId);
+    const { mutateWithRLS } = await import("../db.js");
+    const result = await mutateWithRLS(
+      'DELETE FROM "users" WHERE id = $1',
+      [userId],
+      userId
+    );
+    if (result.rowCount === 0) {
+      return { success: false, error: "User not found" };
+    }
+    revalidatePath("/");
+    return { success: true };
+  } catch (error) {
+    console.error("[deleteAccount] Error:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to delete account"
+    };
+  }
+}
+export {
+  deleteAccount,
+  updateAvatar,
+  updateProfile
+};

package/dist/lib/selectors/core-selectors.d.ts

@@ -429,8 +429,13 @@ export declare const CORE_SELECTORS: {
             readonly slugInput: "builder-slug-input";
             readonly externalLink: "builder-external-link";
             readonly viewToggle: "builder-view-toggle";
-            readonly viewEditor: "builder-view-editor";
             readonly viewPreview: "builder-view-preview";
+            readonly viewSettings: "builder-view-settings";
+            readonly viewportToggle: {
+                readonly container: "builder-viewport-toggle";
+                readonly mobileBtn: "builder-viewport-mobile";
+                readonly desktopBtn: "builder-viewport-desktop";
+            };
             readonly statusSelector: "builder-status-selector";
             readonly statusOption: "builder-status-option-{value}";
             readonly statusDot: "builder-status-dot";
@@ -445,7 +450,7 @@ export declare const CORE_SELECTORS: {
             readonly container: "block-picker";
             readonly tabBlocks: "block-picker-tab-blocks";
             readonly tabPatterns: "block-picker-tab-patterns";
-            readonly tabConfig: "block-picker-tab-config";
+            readonly tabLayout: "block-picker-tab-layout";
             readonly tabIndicator: "block-picker-tab-indicator";
             readonly searchWrapper: "block-picker-search-wrapper";
             readonly searchIcon: "block-picker-search-icon";
@@ -474,39 +479,36 @@ export declare const CORE_SELECTORS: {
             readonly patternCardBlockCount: "block-picker-pattern-blocks-{id}";
             readonly patternCardInsertButton: "block-picker-pattern-insert-{id}";
         };
-        readonly entityFieldsPanel: {
-            readonly container: "entity-fields-panel";
-            readonly field: "entity-field-{name}";
-            readonly categoryList: "entity-field-categories";
-            readonly categoryItem: "entity-field-category-{slug}";
-            readonly categoryCheckbox: "entity-field-category-checkbox-{slug}";
-            readonly categoryBadge: "entity-field-category-badge-{slug}";
-        };
-        readonly layoutCanvas: {
-            readonly container: "layout-canvas";
-            readonly empty: "layout-canvas-empty";
-            readonly dropZone: "layout-canvas-dropzone";
-            readonly sortableBlock: {
-                readonly container: "sortable-block-{id}";
-                readonly card: "sortable-block-card-{id}";
-                readonly dragHandle: "sortable-block-drag-{id}";
-                readonly name: "sortable-block-name-{id}";
-                readonly category: "sortable-block-category-{id}";
-                readonly propsPreview: "sortable-block-props-{id}";
-                readonly duplicateBtn: "sortable-block-duplicate-{id}";
-                readonly removeBtn: "sortable-block-remove-{id}";
-                readonly error: "sortable-block-error-{id}";
-            };
+        readonly treeView: {
+            readonly container: "builder-tree-view";
+            readonly empty: "builder-tree-empty";
+            readonly node: "builder-tree-node-{id}";
+            readonly nodeIcon: "builder-tree-node-icon-{id}";
+            readonly nodeName: "builder-tree-node-name-{id}";
+            readonly nodeDragHandle: "builder-tree-node-drag-{id}";
+            readonly nodeSelected: "builder-tree-node-selected";
+            readonly patternGroup: "builder-tree-pattern-{ref}";
+            readonly patternGroupHeader: "builder-tree-pattern-header-{ref}";
+            readonly patternGroupBlocks: "builder-tree-pattern-blocks-{ref}";
         };
         readonly previewCanvas: {
             readonly container: "preview-canvas";
             readonly wrapper: "preview-canvas-wrapper";
             readonly content: "preview-canvas-content";
             readonly empty: "preview-canvas-empty";
+            readonly viewport: "preview-canvas-viewport-{mode}";
+            readonly viewportMobile: "preview-canvas-mobile";
+            readonly viewportDesktop: "preview-canvas-desktop";
+            readonly iframePreview: {
+                readonly container: "preview-iframe-container";
+                readonly loading: "preview-iframe-loading";
+                readonly frame: "preview-iframe-frame";
+            };
             readonly block: "preview-block-{id}";
             readonly blockWrapper: "preview-block-wrapper-{id}";
             readonly blockSelected: "preview-block-selected-{id}";
             readonly editingBadge: "preview-block-editing-{id}";
+            readonly blockGeneric: "preview-block-";
             readonly floatingToolbar: {
                 readonly container: "floating-toolbar-{id}";
                 readonly dragHandle: "floating-toolbar-drag-{id}";
@@ -518,6 +520,32 @@ export declare const CORE_SELECTORS: {
             readonly moveUp: "preview-block-move-up-{id}";
             readonly moveDown: "preview-block-move-down-{id}";
         };
+        readonly configPanel: {
+            readonly container: "builder-config-panel";
+            readonly scroll: "builder-config-scroll";
+            readonly entityFieldsSection: {
+                readonly container: "builder-config-entity-section";
+                readonly trigger: "builder-config-entity-trigger";
+                readonly content: "builder-config-entity-content";
+                readonly field: "builder-config-entity-field-{name}";
+            };
+            readonly seoMetaSection: {
+                readonly container: "builder-config-seo-section";
+                readonly trigger: "builder-config-seo-trigger";
+                readonly content: "builder-config-seo-content";
+                readonly metaTitle: "builder-config-seo-title";
+                readonly metaDescription: "builder-config-seo-description";
+                readonly metaKeywords: "builder-config-seo-keywords";
+                readonly ogImage: "builder-config-seo-og-image";
+                readonly customFields: {
+                    readonly container: "builder-config-custom-fields";
+                    readonly fieldKey: "builder-config-custom-key-{index}";
+                    readonly fieldValue: "builder-config-custom-value-{index}";
+                    readonly fieldRemove: "builder-config-custom-remove-{index}";
+                    readonly addButton: "builder-config-custom-add";
+                };
+            };
+        };
         readonly patternReference: {
             readonly container: "pattern-reference-{ref}";
             readonly badge: "pattern-reference-badge-{ref}";
@@ -525,25 +553,6 @@ export declare const CORE_SELECTORS: {
             readonly locked: "pattern-reference-locked-{ref}";
             readonly editLink: "pattern-reference-edit-link-{ref}";
         };
-        readonly entityMetaPanel: {
-            readonly container: "entity-meta-panel";
-            readonly seoSection: {
-                readonly trigger: "entity-meta-seo-trigger";
-                readonly content: "entity-meta-seo-content";
-                readonly metaTitle: "entity-meta-seo-title";
-                readonly metaDescription: "entity-meta-seo-description";
-                readonly metaKeywords: "entity-meta-seo-keywords";
-                readonly ogImage: "entity-meta-seo-og-image";
-            };
-            readonly customFields: {
-                readonly trigger: "entity-meta-custom-trigger";
-                readonly content: "entity-meta-custom-content";
-                readonly fieldKey: "entity-meta-custom-key-{index}";
-                readonly fieldValue: "entity-meta-custom-value-{index}";
-                readonly fieldRemove: "entity-meta-custom-remove-{index}";
-                readonly addButton: "entity-meta-custom-add";
-            };
-        };
         readonly blockPropertiesPanel: {
             readonly container: "block-properties-panel";
             readonly header: "block-properties-header";
@@ -556,6 +565,7 @@ export declare const CORE_SELECTORS: {
             readonly tabAdvanced: "block-properties-tab-advanced";
             readonly empty: "block-properties-empty";
             readonly error: "block-properties-error";
+            readonly resetPropsBtn: "block-properties-reset-btn";
             readonly patternLocked: "block-properties-pattern-locked";
             readonly patternTitle: "block-properties-pattern-title";
             readonly patternEditLink: "block-properties-pattern-edit";
@@ -584,6 +594,50 @@ export declare const CORE_SELECTORS: {
             readonly categoryBadge: "entity-field-category-badge-{id}";
             readonly categoryRemove: "entity-field-category-remove-{id}";
         };
+        readonly layoutCanvas: {
+            readonly container: "layout-canvas";
+            readonly empty: "layout-canvas-empty";
+            readonly dropZone: "layout-canvas-dropzone";
+            readonly sortableBlock: {
+                readonly container: "sortable-block-{id}";
+                readonly card: "sortable-block-card-{id}";
+                readonly dragHandle: "sortable-block-drag-{id}";
+                readonly name: "sortable-block-name-{id}";
+                readonly category: "sortable-block-category-{id}";
+                readonly propsPreview: "sortable-block-props-{id}";
+                readonly duplicateBtn: "sortable-block-duplicate-{id}";
+                readonly removeBtn: "sortable-block-remove-{id}";
+                readonly error: "sortable-block-error-{id}";
+                readonly generic: "sortable-block-";
+            };
+        };
+        readonly entityFieldsPanel: {
+            readonly container: "entity-fields-panel";
+            readonly field: "entity-field-{name}";
+            readonly categoryList: "entity-field-categories";
+            readonly categoryItem: "entity-field-category-{slug}";
+            readonly categoryCheckbox: "entity-field-category-checkbox-{slug}";
+            readonly categoryBadge: "entity-field-category-badge-{slug}";
+        };
+        readonly entityMetaPanel: {
+            readonly container: "entity-meta-panel";
+            readonly seoSection: {
+                readonly trigger: "entity-meta-seo-trigger";
+                readonly content: "entity-meta-seo-content";
+                readonly metaTitle: "entity-meta-seo-title";
+                readonly metaDescription: "entity-meta-seo-description";
+                readonly metaKeywords: "entity-meta-seo-keywords";
+                readonly ogImage: "entity-meta-seo-og-image";
+            };
+            readonly customFields: {
+                readonly trigger: "entity-meta-custom-trigger";
+                readonly content: "entity-meta-custom-content";
+                readonly fieldKey: "entity-meta-custom-key-{index}";
+                readonly fieldValue: "entity-meta-custom-value-{index}";
+                readonly fieldRemove: "entity-meta-custom-remove-{index}";
+                readonly addButton: "entity-meta-custom-add";
+            };
+        };
     };
     readonly settings: {
         readonly container: "settings-container";