@medyll/idae-be 0.85.0 → 0.87.0

package/dist/be.d.ts

@@ -6,10 +6,11 @@ import { EventsHandler, type EventHandlerHandle } from './modules/events.js';
 import { type ClassHandlerHandler, ClassesHandler } from './modules/classes.js';
 import { DomHandler, type DomHandlerHandle } from './modules/dom.js';
 import { PositionHandler, type PositionHandlerHandle } from './modules/position.js';
-import { WalkHandler } from './modules/walk.js';
+import { WalkHandler, type WalkHandlerHandle } from './modules/walk.js';
 import { TextHandler, type TextHandlerHandle } from './modules/text.js';
-import { TimersHandler } from './modules/timers.js';
+import { TimersHandler, type TimerHandlerHandle } from './modules/timers.js';
 export declare class Be {
+    [key: string]: unknown;
     inputNode: HTMLElement | HTMLElement[] | string;
     isWhat: IsWhat;
     timerOut: NodeJS.Timeout | null;
@@ -71,7 +72,7 @@ export declare class Be {
     removeClass: ClassesHandler['remove'];
     toggleClass: ClassesHandler['toggle'];
     replaceClass: ClassesHandler['replace'];
-    walk: (actions: DataHandlerHandle) => Be;
+    walk: (actions: WalkHandlerHandle) => Be;
     private walkHandler;
     up: WalkHandler['up'];
     next: WalkHandler['next'];
@@ -84,7 +85,7 @@ export declare class Be {
     firstChild: WalkHandler['firstChild'];
     find: WalkHandler['find'];
     findAll: WalkHandler['findAll'];
-    timers: (actions: TextHandlerHandle) => Be;
+    timers: (actions: TimerHandlerHandle) => Be;
     private timerHandler;
     timeout: TimersHandler['timeout'];
     interval: TimersHandler['interval'];
@@ -123,14 +124,9 @@ export declare class Be {
         data?: T;
         headers?: Record<string, string>;
     }): Promise<any>;
-    get node(): HTMLElement | HTMLElement[];
     eachNode(callback: (el: HTMLElement) => void, firstChild?: boolean): void;
-    /** DOM
-     * Handles various DOM operations on the element(s).
-     * @param actions An object specifying the DOM actions to perform.
-     * @returns The Be instance for method chaining.
-     */
     get html(): string | null;
+    get node(): HTMLElement | HTMLElement[];
     private attach;
     private handle;
 }

package/dist/be.js

@@ -118,11 +118,11 @@ export class Be {
         this.attach(StylesHandler, 'Style');
         // dataSet
         this.dataHandler = new DataHandler(this);
-        this.data = this.handle(this.styleHandler);
+        this.data = this.handle(this.dataHandler);
         this.attach(DataHandler, 'Data');
         // attributes
         this.attrHandler = new AttrHandler(this);
-        this.attrs = this.handle(this.styleHandler);
+        this.attrs = this.handle(this.attrHandler);
         this.attach(AttrHandler, 'Attr');
         // position
         this.positionHandler = new PositionHandler(this);
@@ -130,7 +130,7 @@ export class Be {
         this.attach(PositionHandler);
         // text
         this.textHandler = new TextHandler(this);
-        this.dom = this.handle(this.textHandler);
+        this.text = this.handle(this.textHandler);
         this.attach(TextHandler, 'Text');
         // dom and handle
         this.domHandler = new DomHandler(this);
@@ -263,16 +263,6 @@ export class Be {
             headers: options.headers || {}
         }).then((response) => response.json());
     }
-    get node() {
-        switch (this.isWhat) {
-            case 'element':
-                return this.inputNode;
-            case 'array':
-                return Array.from(this.inputNode);
-            case 'qy':
-                return Array.from(document.querySelectorAll(this.inputNode));
-        }
-    }
     eachNode(callback, firstChild) {
         switch (this.isWhat) {
             case 'element':
@@ -294,14 +284,19 @@ export class Be {
                 break;
         }
     }
-    /** DOM
-     * Handles various DOM operations on the element(s).
-     * @param actions An object specifying the DOM actions to perform.
-     * @returns The Be instance for method chaining.
-     */
     get html() {
         return this.isWhat === 'element' ? this.inputNode.innerHTML : null;
     }
+    get node() {
+        switch (this.isWhat) {
+            case 'element':
+                return this.inputNode;
+            case 'array':
+                return Array.from(this.inputNode);
+            case 'qy':
+                return Array.from(document.querySelectorAll(this.inputNode));
+        }
+    }
     attach(Handler, suffix = '') {
         const fromMethods = Handler.methods || [];
         fromMethods.forEach((method) => {

package/dist/modules/attrs.d.ts

@@ -10,14 +10,66 @@ export type AttrHandlerHandle = {
     get: AttrHandler['get'];
     delete: AttrHandler['delete'];
 };
+/**
+ * Handles attribute operations for Be elements.
+ */
 export declare class AttrHandler implements CommonHandler<AttrHandler, AttrHandler> {
     private beElement;
     static methods: attrMethods[];
+    /**
+     * Initializes the AttrHandler with a Be element.
+     * @param element - The Be element to operate on.
+     */
     constructor(element: Be);
+    /**
+     * Handles dynamic method calls for attribute operations.
+     * @param actions - The actions to perform (e.g., set, get, delete).
+     * @returns The Be element for chaining.
+     */
     handle(actions: Partial<AttrHandlerHandle>): Be;
+    /**
+     * Retrieves the value of an attribute.
+     * @param name - The name of the attribute to retrieve.
+     * @returns The value of the attribute, or `null` if not found.
+     * @example
+     * // HTML: <div id="test" data-role="admin"></div>
+     * const beInstance = be('#test');
+     * const role = beInstance.getAttr('data-role');
+     * console.log(role); // Output: "admin"
+     */
     get(name?: string): string | null;
+    /**
+     * Sets one or more attributes on the element(s).
+     * @param nameOrObject - A key-value pair or an object containing multiple key-value pairs.
+     * @param value - The value to set if a single key is provided.
+     * @returns The Be element for chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.setAttr('data-role', 'admin'); // Sets a single attribute
+     * beInstance.setAttr({ class: 'highlight', title: 'Hello' }); // Sets multiple attributes
+     */
     set(nameOrObject: string | Record<string, string>, value?: string): Be;
+    /**
+     * Deletes one or more attributes from the element(s).
+     * @param nameOrObject - A key or an object containing multiple keys to delete.
+     * @returns The Be element for chaining.
+     * @example
+     * // HTML: <div id="test" data-role="admin" class="highlight"></div>
+     * const beInstance = be('#test');
+     * beInstance.deleteAttr('data-role'); // Deletes a single attribute
+     * beInstance.deleteAttr({ class: '' }); // Deletes multiple attributes
+     */
     delete(nameOrObject: string | Record<string, string>): Be;
+    /**
+     * Retrieves all attributes as a key-value pair object.
+     * @returns An object containing all attributes, or `null` if not applicable.
+     * @example
+     * // HTML: <div id="test" data-role="admin" class="highlight"></div>
+     * const beInstance = be('#test');
+     * const attributes = beInstance.attrs.valueOf();
+     * console.log(attributes); // Output: { id: "test", "data-role": "admin", class: "highlight" }
+     */
     valueOf(): Record<string, string> | null;
 }
 export {};

package/dist/modules/attrs.js

@@ -5,12 +5,24 @@ var attrMethods;
     attrMethods["get"] = "get";
     attrMethods["delete"] = "delete";
 })(attrMethods || (attrMethods = {}));
+/**
+ * Handles attribute operations for Be elements.
+ */
 export class AttrHandler {
     beElement;
     static methods = Object.values(attrMethods);
+    /**
+     * Initializes the AttrHandler with a Be element.
+     * @param element - The Be element to operate on.
+     */
     constructor(element) {
         this.beElement = element;
     }
+    /**
+     * Handles dynamic method calls for attribute operations.
+     * @param actions - The actions to perform (e.g., set, get, delete).
+     * @returns The Be element for chaining.
+     */
     handle(actions) {
         Object.entries(actions).forEach(([method, props]) => {
             switch (method) {
@@ -22,15 +34,18 @@ export class AttrHandler {
                     break;
             }
         });
-        /* this.beElement.eachNode((el) => {
-            if (actions.delete) {
-                this.delete(actions.delete);
-            }
-            if (actions.set) {
-            }
-        }); */
         return this.beElement;
     }
+    /**
+     * Retrieves the value of an attribute.
+     * @param name - The name of the attribute to retrieve.
+     * @returns The value of the attribute, or `null` if not found.
+     * @example
+     * // HTML: <div id="test" data-role="admin"></div>
+     * const beInstance = be('#test');
+     * const role = beInstance.getAttr('data-role');
+     * console.log(role); // Output: "admin"
+     */
     get(name) {
         if (typeof this.beElement.inputNode === 'string')
             return (document.querySelector(this.beElement.inputNode || '')?.getAttribute(name || '') || null);
@@ -39,6 +54,17 @@ export class AttrHandler {
         const el = this.beElement.inputNode;
         return name ? el.getAttribute(name) : null;
     }
+    /**
+     * Sets one or more attributes on the element(s).
+     * @param nameOrObject - A key-value pair or an object containing multiple key-value pairs.
+     * @param value - The value to set if a single key is provided.
+     * @returns The Be element for chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.setAttr('data-role', 'admin'); // Sets a single attribute
+     * beInstance.setAttr({ class: 'highlight', title: 'Hello' }); // Sets multiple attributes
+     */
     set(nameOrObject, value) {
         this.beElement.eachNode((el) => {
             if (typeof nameOrObject === 'string' && value !== undefined) {
@@ -52,6 +78,16 @@ export class AttrHandler {
         });
         return this.beElement;
     }
+    /**
+     * Deletes one or more attributes from the element(s).
+     * @param nameOrObject - A key or an object containing multiple keys to delete.
+     * @returns The Be element for chaining.
+     * @example
+     * // HTML: <div id="test" data-role="admin" class="highlight"></div>
+     * const beInstance = be('#test');
+     * beInstance.deleteAttr('data-role'); // Deletes a single attribute
+     * beInstance.deleteAttr({ class: '' }); // Deletes multiple attributes
+     */
     delete(nameOrObject) {
         this.beElement.eachNode((el) => {
             if (typeof nameOrObject === 'string') {
@@ -65,6 +101,15 @@ export class AttrHandler {
         });
         return this.beElement;
     }
+    /**
+     * Retrieves all attributes as a key-value pair object.
+     * @returns An object containing all attributes, or `null` if not applicable.
+     * @example
+     * // HTML: <div id="test" data-role="admin" class="highlight"></div>
+     * const beInstance = be('#test');
+     * const attributes = beInstance.attrs.valueOf();
+     * console.log(attributes); // Output: { id: "test", "data-role": "admin", class: "highlight" }
+     */
     valueOf() {
         if (this.beElement.isWhat !== 'element')
             return null;

package/dist/modules/classes.d.ts

@@ -35,22 +35,48 @@ export declare class ClassesHandler implements CommonHandler<ClassesHandler, Cla
     methods: string[] | keyof ClassesHandler;
     valueOf(): string;
     handle(actions: ClassHandlerHandlerHandle): Be;
+    /**
+     * Adds one or more classes to the element(s).
+     * @param className - The class or classes to add.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.addClass('highlight'); // Adds a single class
+     * beInstance.addClass(['highlight', 'active']); // Adds multiple classes
+     */
     add(className: string | string[]): Be;
     /**
-     * Toggle a class on the element(s).
-     * @param className The class to toggle.
+     * Toggles a class on the element(s).
+     * @param className - The class or classes to toggle.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test" class="highlight"></div>
+     * const beInstance = be('#test');
+     * beInstance.toggleClass('highlight'); // Removes the "highlight" class
+     * beInstance.toggleClass('active'); // Adds the "active" class
      */
     toggle(className: string | string[]): Be;
     /**
-     * Replace a class on the element(s).
+     * Replaces a class on the element(s) with another class.
+     * @param sourceClassName - The class to replace.
+     * @param targetClassName - The class to replace it with.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test" class="old-class"></div>
+     * const beInstance = be('#test');
+     * beInstance.replaceClass('old-class', 'new-class'); // Replaces "old-class" with "new-class"
      */
     replace(sourceClassName: string, targetClassName: string): Be;
     /**
-     * Remove a class from the element(s).
-     * @param className The class to remove.
+     * Removes one or more classes from the element(s).
+     * @param className - The class or classes to remove.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test" class="highlight active"></div>
+     * const beInstance = be('#test');
+     * beInstance.removeClass('highlight'); // Removes the "highlight" class
+     * beInstance.removeClass(['highlight', 'active']); // Removes multiple classes
      */
     remove(className: string | string[]): Be;
 }

package/dist/modules/classes.js

@@ -31,15 +31,30 @@ export class ClassesHandler {
         });
         return this.beElement;
     }
+    /**
+     * Adds one or more classes to the element(s).
+     * @param className - The class or classes to add.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.addClass('highlight'); // Adds a single class
+     * beInstance.addClass(['highlight', 'active']); // Adds multiple classes
+     */
     add(className) {
         const classesToAdd = Array.isArray(className) ? className : className.split(' ');
         this.beElement.eachNode((el) => el.classList.add(...classesToAdd.filter((c) => c.trim() !== '')));
         return this.beElement;
     }
     /**
-     * Toggle a class on the element(s).
-     * @param className The class to toggle.
+     * Toggles a class on the element(s).
+     * @param className - The class or classes to toggle.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test" class="highlight"></div>
+     * const beInstance = be('#test');
+     * beInstance.toggleClass('highlight'); // Removes the "highlight" class
+     * beInstance.toggleClass('active'); // Adds the "active" class
      */
     toggle(className) {
         const classesToToggle = Array.isArray(className) ? className : className.split(' ');
@@ -49,17 +64,28 @@ export class ClassesHandler {
         return this.beElement;
     }
     /**
-     * Replace a class on the element(s).
+     * Replaces a class on the element(s) with another class.
+     * @param sourceClassName - The class to replace.
+     * @param targetClassName - The class to replace it with.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test" class="old-class"></div>
+     * const beInstance = be('#test');
+     * beInstance.replaceClass('old-class', 'new-class'); // Replaces "old-class" with "new-class"
      */
     replace(sourceClassName, targetClassName) {
         this.beElement.eachNode((el) => el.classList.replace(sourceClassName, targetClassName));
         return this.beElement;
     }
     /**
-     * Remove a class from the element(s).
-     * @param className The class to remove.
+     * Removes one or more classes from the element(s).
+     * @param className - The class or classes to remove.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test" class="highlight active"></div>
+     * const beInstance = be('#test');
+     * beInstance.removeClass('highlight'); // Removes the "highlight" class
+     * beInstance.removeClass(['highlight', 'active']); // Removes multiple classes
      */
     remove(className) {
         const classesToRemove = Array.isArray(className) ? className : className.split(' ');

package/dist/modules/data.d.ts

@@ -37,6 +37,11 @@ export declare class DataHandler implements CommonHandler<DataHandler> {
      * Retrieves the value of a `data-*` attribute.
      * @param key - The key of the `data-*` attribute to retrieve.
      * @returns The value of the attribute, or `null` if not found.
+     * @example
+     * // HTML: <div id="test" data-role="admin"></div>
+     * const beInstance = be('#test');
+     * const role = beInstance.getData('role');
+     * console.log(role); // Output: "admin"
      */
     get(key: string): string | null;
     /**
@@ -44,23 +49,43 @@ export declare class DataHandler implements CommonHandler<DataHandler> {
      * @param keyOrObject - A key-value pair or an object containing multiple key-value pairs.
      * @param value - The value to set if a single key is provided.
      * @returns The Be element for chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.setData('role', 'admin'); // Sets a single `data-role` attribute
+     * beInstance.setData({ role: 'admin', type: 'user' }); // Sets multiple `data-*` attributes
      */
     set(keyOrObject: string | Record<string, string>, value?: string): Be;
     /**
      * Deletes one or more `data-*` attributes.
      * @param keyOrObject - A key or an object containing multiple keys to delete.
      * @returns The Be element for chaining.
+     * @example
+     * // HTML: <div id="test" data-role="admin" data-type="user"></div>
+     * const beInstance = be('#test');
+     * beInstance.deleteData('role'); // Deletes the `data-role` attribute
+     * beInstance.deleteData({ type: '' }); // Deletes the `data-type` attribute
      */
     delete(keyOrObject: string | Record<string, string>): Be;
     /**
      * Retrieves the value of a specific `data-*` attribute.
      * @param key - The key of the `data-*` attribute to retrieve.
      * @returns The value of the attribute, or `null` if not found.
+     * @example
+     * // HTML: <div id="test" data-role="admin"></div>
+     * const beInstance = be('#test');
+     * const role = beInstance.getKey('role');
+     * console.log(role); // Output: "admin"
      */
     getKey(key: string | string[]): string | null;
     /**
      * Retrieves all `data-*` attributes as a DOMStringMap.
      * @returns A DOMStringMap containing all `data-*` attributes, or `null` if not applicable.
+     * @example
+     * // HTML: <div id="test" data-role="admin" data-type="user"></div>
+     * const beInstance = be('#test');
+     * const dataAttributes = beInstance.data.valueOf();
+     * console.log(dataAttributes); // Output: { role: "admin", type: "user" }
      */
     valueOf(): DOMStringMap | null;
 }

package/dist/modules/data.js

@@ -40,6 +40,11 @@ export class DataHandler {
      * Retrieves the value of a `data-*` attribute.
      * @param key - The key of the `data-*` attribute to retrieve.
      * @returns The value of the attribute, or `null` if not found.
+     * @example
+     * // HTML: <div id="test" data-role="admin"></div>
+     * const beInstance = be('#test');
+     * const role = beInstance.getData('role');
+     * console.log(role); // Output: "admin"
      */
     get(key) {
         if (this.beElement.isWhat !== 'element')
@@ -51,6 +56,11 @@ export class DataHandler {
      * @param keyOrObject - A key-value pair or an object containing multiple key-value pairs.
      * @param value - The value to set if a single key is provided.
      * @returns The Be element for chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.setData('role', 'admin'); // Sets a single `data-role` attribute
+     * beInstance.setData({ role: 'admin', type: 'user' }); // Sets multiple `data-*` attributes
      */
     set(keyOrObject, value) {
         this.beElement.eachNode((el) => {
@@ -69,6 +79,11 @@ export class DataHandler {
      * Deletes one or more `data-*` attributes.
      * @param keyOrObject - A key or an object containing multiple keys to delete.
      * @returns The Be element for chaining.
+     * @example
+     * // HTML: <div id="test" data-role="admin" data-type="user"></div>
+     * const beInstance = be('#test');
+     * beInstance.deleteData('role'); // Deletes the `data-role` attribute
+     * beInstance.deleteData({ type: '' }); // Deletes the `data-type` attribute
      */
     delete(keyOrObject) {
         this.beElement.eachNode((el) => {
@@ -89,6 +104,11 @@ export class DataHandler {
      * Retrieves the value of a specific `data-*` attribute.
      * @param key - The key of the `data-*` attribute to retrieve.
      * @returns The value of the attribute, or `null` if not found.
+     * @example
+     * // HTML: <div id="test" data-role="admin"></div>
+     * const beInstance = be('#test');
+     * const role = beInstance.getKey('role');
+     * console.log(role); // Output: "admin"
      */
     getKey(key) {
         if (this.beElement.isWhat !== 'element')
@@ -98,6 +118,11 @@ export class DataHandler {
     /**
      * Retrieves all `data-*` attributes as a DOMStringMap.
      * @returns A DOMStringMap containing all `data-*` attributes, or `null` if not applicable.
+     * @example
+     * // HTML: <div id="test" data-role="admin" data-type="user"></div>
+     * const beInstance = be('#test');
+     * const dataAttributes = beInstance.data.valueOf();
+     * console.log(dataAttributes); // Output: { role: "admin", type: "user" }
      */
     valueOf() {
         if (this.beElement.isWhat !== 'element')

package/dist/modules/dom.d.ts

@@ -66,6 +66,9 @@ export interface DomHandlerHandle {
 export interface DomHandlerInterface {
     insert(mode: 'afterbegin' | 'afterend' | 'beforebegin' | 'beforeend', element: HTMLElement | Be, callback?: HandlerCallBackFn): Be;
 }
+/**
+ * Handles DOM manipulation operations for Be elements.
+ */
 export declare class DomHandler implements DomHandlerInterface, CommonHandler<DomHandler, DomHandlerHandle> {
     private beElement;
     static methods: domMethods[];
@@ -83,18 +86,122 @@ export declare class DomHandler implements DomHandlerInterface, CommonHandler<Do
      * @returns The Be instance for method chaining.
      */
     handle(actions: DomHandlerHandle): Be;
+    /**
+     * Updates the content of the element(s).
+     * @param content - The new content to set.
+     * @param callback - Optional callback function.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.update('<p>Updated content</p>'); // Updates the content of the element
+     */
     update(content: string, callback?: HandlerCallBackFn): Be;
+    /**
+     * Appends content to the element(s).
+     * @param content - The content to append (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after appending.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.append('<span>Appended</span>'); // Appends content to the element
+     */
     append(content: Content, callback?: HandlerCallBackFn): Be;
+    /**
+     * Prepends content to the element(s).
+     * @param content - The content to prepend (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after prepending.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.prepend('<span>Prepended</span>'); // Prepends content to the element
+     */
     prepend(content: Content, callback?: HandlerCallBackFn): Be;
+    /**
+     * Inserts content into the element(s) at a specified position.
+     * @param mode - The position to insert the content ('afterbegin', 'afterend', 'beforebegin', 'beforeend').
+     * @param element - The content to insert (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after insertion.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.insert('afterbegin', '<span>Inserted</span>'); // Inserts content at the beginning
+     */
     insert(mode: 'afterbegin' | 'afterend' | 'beforebegin' | 'beforeend', element: HTMLElement | Be | string, callback?: HandlerCallBackFn): Be;
+    /**
+     * Inserts content at the beginning of the element(s).
+     * @param content - The content to insert (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after insertion.
+     * @returns The Be instance for method chaining.
+     */
     afterBegin(content: Content, callback?: HandlerCallBackFn): Be;
+    /**
+     * Inserts content after the element(s).
+     * @param content - The content to insert (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after insertion.
+     * @returns The Be instance for method chaining.
+     */
     afterEnd(content: Content, callback?: HandlerCallBackFn): Be;
+    /**
+     * Inserts content before the element(s).
+     * @param content - The content to insert (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after insertion.
+     * @returns The Be instance for method chaining.
+     */
     beforeBegin(content: Content, callback?: HandlerCallBackFn): Be;
+    /**
+     * Inserts content at the end of the element(s).
+     * @param content - The content to insert (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after insertion.
+     * @returns The Be instance for method chaining.
+     */
     beforeEnd(content: Content, callback?: HandlerCallBackFn): Be;
+    /**
+     * Replaces the element(s) with new content.
+     * @param content - The content to replace the element(s) with (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after replacement.
+     * @returns The Be instance for method chaining.
+     */
     replace(content: Content, callback?: HandlerCallBackFn): Be;
+    /**
+     * Removes the element(s) from the DOM.
+     * @param callback - Optional callback function to execute after removal.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"><span>To be removed</span></div>
+     * const beInstance = be('#test span');
+     * beInstance.remove(); // Removes the span element
+     */
     remove(callback?: HandlerCallBackFn): Be;
+    /**
+     * Clears the content of the element(s).
+     * @param callback - Optional callback function to execute after clearing.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"><span>Content</span></div>
+     * const beInstance = be('#test');
+     * beInstance.clear(); // Clears the content of the div
+     */
     clear(callback?: HandlerCallBackFn): Be;
+    /**
+     * Normalizes the content of the element(s).
+     * @param callback - Optional callback function to execute after normalization.
+     * @returns The Be instance for method chaining.
+     */
     normalize(callback?: HandlerCallBackFn): Be;
+    /**
+     * Wraps the element(s) with a new element.
+     * @param tag - The tag name of the wrapper element (default is 'div').
+     * @param callback - Optional callback function to execute after wrapping.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.wrap('section'); // Wraps the div with a <section> element
+     */
     wrap(tag?: string, callback?: HandlerCallBackFn): Be;
     private adjacentElement;
     private normalizeContent;