@pcg/dynamic-components 1.0.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,1816 @@
+import * as Y from "yjs";
+import { Entries } from "type-fest";
+import { JSONContent } from "@tiptap/core";
+
+//#region src/assertions/basic.d.ts
+
+/**
+ * Checks if the given parameter is callable (a function).
+ * @param {unknown} fn - The function to check.
+ * @returns {boolean} Returns true if `fn` is a function, false otherwise.
+ * @example
+ * isCallable(() => {});  // Returns true
+ * isCallable('Hello');  // Returns false
+ */
+declare const isCallable: (fn: unknown) => fn is (...args: any[]) => any;
+/**
+ * Checks if the given value is a string.
+ * @param {unknown} val - The value to check.
+ * @returns {boolean} Returns true if `val` is a string, false otherwise.
+ * @example
+ * isString('Hello');  // Returns true
+ * isString(123);  // Returns false
+ */
+declare const isString: (val: unknown) => val is string;
+/**
+ * Checks if the given value is a number.
+ * @param {unknown} val - The value to check.
+ * @returns {boolean} Returns true if `val` is a number, false otherwise.
+ * @example
+ * isNumber(123);  // Returns true
+ * isNumber('Hello');  // Returns false
+ */
+declare const isNumber: (val: unknown) => val is number;
+/**
+ * Checks if a given value can be used as an index (a non-negative integer).
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if `value` can be used as an index, false otherwise.
+ * @example
+ * isIndex(2);  // Returns true
+ * isIndex('2');  // Returns true
+ * isIndex(-1);  // Returns false
+ */
+declare const isIndex: (value: unknown) => value is number;
+/**
+ * Checks if the given value is null or undefined.
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if `value` is null or undefined, false otherwise.
+ * @example
+ * isNullOrUndefined(null);  // Returns true
+ * isNullOrUndefined(undefined);  // Returns true
+ * isNullOrUndefined('Hello');  // Returns false
+ */
+declare const isNullOrUndefined: (value: unknown) => value is undefined | null;
+//#endregion
+//#region src/assertions/containers.d.ts
+/**
+ * Checks if the given value is an empty array.
+ * @param {unknown} arr - The array to check.
+ * @returns {boolean} Returns true if `arr` is an empty array, false otherwise.
+ * @example
+ * isEmptyArray([]);  // Returns true
+ * isEmptyArray([1, 2, 3]);  // Returns false
+ */
+declare const isEmptyArray: (arr: unknown) => boolean;
+/**
+ * Gets the keys of the given object.
+ * @param {T} arr - The object to get the keys from.
+ * @returns {Array<keyof T>} Returns an array of keys of the given object.
+ * @example
+ * keysOf({ a: 1, b: 2 });  // Returns ['a', 'b']
+ */
+declare const keysOf: <T>(arr: T) => (keyof T)[];
+/**
+ * Gets the entries of the given object.
+ * @param {T} arr - The object to get the entries from.
+ * @returns {Entries<T>} Returns an array of entries of the given object.
+ * @example
+ * entriesOf({ a: 1, b: 2 });  // Returns [['a', 1], ['b', 2]]
+ */
+declare const entriesOf: <T>(arr: T) => Entries<T>;
+/**
+ * Checks if the given value is an object (not an array).
+ * @param {unknown} obj - The value to check.
+ * @returns {boolean} Returns true if `obj` is an object, false otherwise.
+ * @example
+ * isObject({ a: 1 });  // Returns true
+ * isObject([1, 2, 3]);  // Returns false
+ */
+declare const isObject: (obj: unknown) => obj is Record<string, unknown>;
+/**
+ * Checks if the given value is a container (an object or an array).
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if `value` is a container, false otherwise.
+ * @example
+ * isContainerValue({ a: 1 });  // Returns true
+ * isContainerValue([1, 2, 3]);  // Returns true
+ * isContainerValue('Hello');  // Returns false
+ */
+declare const isContainerValue: (value: unknown) => value is Record<string, unknown>;
+/**
+ * Checks if the given value is an empty container (an empty object or array).
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if `value` is an empty container, false otherwise.
+ * @example
+ * isEmptyContainer({});  // Returns true
+ * isEmptyContainer([]);  // Returns true
+ * isEmptyContainer({ a: 1 });  // Returns false
+ * isEmptyContainer([1, 2, 3]);  // Returns false
+ */
+declare const isEmptyContainer: (value: unknown) => boolean;
+//#endregion
+//#region src/assertions/paths.d.ts
+/**
+ * Checks if two paths are equal.
+ * @param {(string | number)[]} path - The first path to compare.
+ * @param {(string | number)[]} toPath - The second path to compare.
+ * @returns {boolean} Returns true if both paths are of the same length and all corresponding elements are equal, false otherwise.
+ * @example
+ * isEqualPath(['items', 'id:xxx', 'name'], ['items', 'id:xxx', 'name']);  // Returns true
+ * isEqualPath(['items', 'id:yyy', 'name'], ['items', 'id:xxx', 'name']);  // Returns false
+ */
+declare const isEqualPath: (path: (string | number)[], toPath: (string | number)[]) => boolean;
+//#endregion
+//#region src/data-objects/data-object.d.ts
+/**
+ * The BaseDataObject interface represents a basic structure of a data object.
+ * It includes an `id` and a `type` string.
+ *
+ * @interface
+ * @example
+ * {
+ *   id: 'xxx',
+ *   tiptap: { ... },
+ *   type: 'RichText'
+ * }
+ */
+interface BaseDataObject {
+  /**
+   * The unique identifier for the data object.
+   */
+  id: string;
+  /**
+   * The type of the data object. It's used for differentiating different types of data objects.
+   */
+  type: string;
+}
+/**
+ * Gets the key of the data object. The key is a string combining `type` and `id` of the data object, separated by a colon.
+ * @param {BaseDataObject} dataObject - The data object to get the key from.
+ * @returns {string} Returns the key of the data object.
+ * @example
+ * getDataObjectKey({ id: 'xxx', type: 'RichText' });  // Returns 'RichText:xxx'
+ */
+declare const getDataObjectKey: (dataObject: BaseDataObject) => string;
+//#endregion
+//#region src/data-objects/rich-text.d.ts
+/**
+ * The RichText interface represents a rich text data object.
+ *
+ * @interface
+ * @example
+ * {
+ *   id: 'xx',
+ *   tiptap: { ... },
+ *   html: '<p>...</p>',
+ *   plaintext: '...',
+ *   type: 'RichText'
+ * }
+ */
+interface RichText extends BaseDataObject {
+  /**
+   * The TipTap JSON content of the rich text data object.
+   */
+  tiptap?: JSONContent;
+  /**
+   * The HTML representation of the rich text data object.
+   */
+  html?: string;
+  /**
+   * The plaintext representation of the rich text data object.
+   */
+  plaintext?: string;
+  /**
+   * The type of the rich text data object, set to 'RichText'.
+   */
+  type: 'RichText';
+}
+//#endregion
+//#region src/assertions/rich-text.d.ts
+/**
+ * Checks if the given value is a RichText object.
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if `value` is a RichText object, false otherwise.
+ * @example
+ * isRichText({ id: 'xx', ... type: 'RichText' });  // Returns true
+ */
+declare const isRichText: (value: unknown) => value is RichText;
+//#endregion
+//#region src/assertions/yjs.d.ts
+/**
+ * Checks if the given value is a Yjs Map.
+ * @param {unknown} yMap - The value to check.
+ * @returns {boolean} Returns true if `yMap` is a Yjs Map, false otherwise.
+ * @example
+ * const yMap = new Y.Map();
+ * isYMap(yMap);  // Returns true
+ */
+declare const isYMap: <T = unknown>(yMap: unknown) => yMap is Y.Map<T>;
+/**
+ * Checks if the given value is a Yjs Array.
+ * @param {unknown} yArray - The value to check.
+ * @returns {boolean} Returns true if `yArray` is a Yjs Array, false otherwise.
+ * @example
+ * const yArray = new Y.Array();
+ * isYArray(yArray);  // Returns true
+ */
+declare const isYArray: <T = unknown>(yArray: unknown) => yArray is Y.Array<T>;
+//#endregion
+//#region src/dynamic-components/fractional-indexing.d.ts
+/**
+ * @param {string | null} a
+ * @param {string | null} b
+ * @param {string=} digits
+ * @return {string}
+ */
+declare const generateKeyBetween: (a: string | null, b: string | null, digits?: string) => string;
+//#endregion
+//#region src/dynamic-components/types.d.ts
+type Point = [number, number];
+interface DynamicComponentIO {
+  id: string;
+  name: string;
+}
+/**
+ * Represents a link between two dynamic components.
+ */
+interface DynamicComponentLink {
+  /** The unique identifier of the link. */
+  id: string;
+  /** The input of the link. */
+  input: string;
+  /** The output of the link. */
+  output: string;
+}
+/**
+
+/**
+ * ValidationRules interface is used for defining the set of
+ * validation constraints for a field in a form or component.
+ *
+ * @example
+ * let rules: ValidationRules = {
+ *   required: true,
+ *   min: 1,
+ *   max: 100,
+ *   pattern: 'email'
+ * };
+ */
+interface ValidationRules {
+  /**
+   * Indicates whether the field is required or not.
+   */
+  required?: boolean;
+  /**
+   * Specifies the minimum value for the field.
+   */
+  min?: number;
+  /**
+   * Specifies the maximum value for the field.
+   */
+  max?: number;
+  /**
+   * Specifies a pattern that the field value should match.
+   */
+  pattern?: 'email' | 'url' | 'hh:mm:ss' | 'phone';
+  /**
+   *Specifies whether to trim spaces.
+   */
+  trim?: boolean;
+}
+interface ComponentStyles {
+  /**
+   * Specifies the top padding of the component.
+   */
+  paddingTop?: string;
+  /**
+   * Specifies the bottom padding of the component.
+   */
+  paddingBottom?: string;
+}
+/**
+ * DynamicComponent is a key feature of the component designer.
+ * It is a data structure used to describe dynamic components,
+ * which can be added to the content by the component designer and their properties can be edited on the fly.
+ * The output of the designer is a tree of dynamic components.
+ *
+ * For example, a text input component can be described as follows:
+ * ```typescript
+ * export interface DTextInput extends DynamicComponent {
+ *   component: 'text-input';
+ *   props: {
+ *     name?: string;
+ *     label?: string;
+ *     placeholder?: string;
+ *     maska?: string;
+ *     disabled?: boolean;
+ *     readonly?: boolean;
+ *     rules?: ValidationRules;
+ *     visible?: string;
+ *   };
+ * }
+ * ```
+ */
+interface DynamicComponent {
+  /**
+   * The unique identifier of the component.
+   */
+  id: string;
+  /**
+   * The type of the component.
+   */
+  component: string;
+  /**
+   * The variant of the component.
+   * For example, a button component can have variants like 'primary', 'secondary', etc.
+   */
+  variant?: string;
+  /**
+   * The position of the component.
+   */
+  position?: string;
+  /**
+   * A flag indicating whether the component is enabled or not.
+   */
+  enabled?: boolean;
+  /**
+   * The coordinated of the component in the canvas.
+   */
+  coordinates?: Point;
+  /**
+   * The inputs of the component.
+   * Input ports are used to connect the component to other components.
+   */
+  inputs?: DynamicComponentIO[];
+  /**
+   * The outputs of the component.
+   * Output ports are used to connect the component to other components.
+   */
+  outputs?: DynamicComponentIO[];
+  /**
+   * The properties of the component.
+   */
+  props: {
+    /**
+     * The name of the component.
+     */
+    name?: string;
+    /**
+     * The visibility of the component.
+     */
+    visible?: string;
+    /**
+     * The readonly status of the component.
+     */
+    readonly?: boolean;
+    /**
+     * The child components of the component.
+     */
+    components?: DynamicComponent[];
+    /**
+     * The validation rules for the component.
+     */
+    rules?: ValidationRules;
+    /**
+     * The styles for the component.
+     */
+    styles?: ComponentStyles;
+    /**
+     * Any other properties of the component.
+     */
+    [key: string]: unknown;
+  };
+}
+/**
+ * DynamicComponent is a key feature of the component designer.
+ * It is a data structure used to describe dynamic components ,
+ * which can be added to the content by the component designer and their properties can be edited on the fly.
+ * The output of the designer is a tree of dynamic components.
+ *
+ * DynamicComponentWithPosition is a DynamicComponent with defind fractional-indexed position.
+ *
+ * For example, a text input component can be described as follows:
+ * ```typescript
+ * {
+ *   component: 'text-input';
+ *   props: {
+ *     name: 'email';
+ *     label:: string;
+ *     placeholder?: string;
+ *     maska?: string;
+ *     disabled?: boolean;
+ *     readonly?: boolean;
+ *     rules?: ValidationRules;
+ *     visible?: string;
+ *   };
+ * }
+ * ```
+ */
+interface DynamicComponentWithPosition extends DynamicComponent {
+  /**
+   * The position of the component. This is required for DynamicComponentWithPosition.
+   */
+  position: string;
+  /**
+   * The properties of the component.
+   */
+  props: DynamicComponent['props'] & {
+    /**
+     * The child components of the component.
+     */
+    components?: DynamicComponentWithPosition[];
+  };
+}
+/**
+ * Defines a DynamicComponent.
+ * @param {T} component - The component to define.
+ * @returns {T} Returns the defined component.
+ */
+declare const defineDynamicComponent: <T extends DynamicComponent>(component: T) => T;
+/**
+ * Defines an array of DynamicComponents.
+ * @param {T[]} components - The components to define.
+ * @returns {T[]} Returns the defined components.
+ */
+declare const defineDynamicComponents: <T extends DynamicComponent>(components: T[]) => T[];
+//#endregion
+//#region src/dynamic-components/paths.d.ts
+/**
+ * Get array with components founded by rpath
+ *
+ * @example
+ * const components = [
+ *  {
+ *    id: "xxx",
+ *    component: "collection",
+ *    props: {
+ *      components: [
+ *        {
+ *           id: "yyy",
+ *           component: "text-input",
+ *           props: {
+ *             label: "Title"
+ *           }
+ *        }
+ *      ]
+ *    }
+ *  }
+ * ]
+ *
+ * const { pathWithComponents } = getComponentsSubtreeByRPath(components, ['xxx', 'yyy']);
+ *
+ * // pathWithComponents
+ * // [
+ * //   {
+ * //     id: "xxx",
+ * //     component: "collection",
+ * //     ...
+ * //   },
+ * //   {
+ * //     id: "yyy",
+ * //     component: "text-input",
+ * //     ...
+ * //  }
+ * // ]
+ *
+ */
+declare const getComponentsSubtreeByRPath: (components: DynamicComponent[], rpath: string[]) => {
+  pathWithComponents: DynamicComponent[];
+  complete: boolean;
+};
+/**
+ * Get array with components founded by values path.
+ *
+ * @example
+ * const components = [
+ *  {
+ *    id: "xxx",
+ *    component: "collection",
+ *    props: {
+ *      name: "seo",
+ *      components: [
+ *        {
+ *           id: "yyy",
+ *           component: "text-input",
+ *           props: {
+ *             label: "Title",
+ *             name: "title",
+ *           }
+ *        }
+ *      ]
+ *    }
+ *  }
+ * ]
+ *
+ * const { pathWithComponents } = getComponentsSubtreeByPath(components, ['seo', 'title']);
+ *
+ * // pathWithComponents
+ * // [
+ * //   {
+ * //     id: "xxx",
+ * //     component: "collection",
+ * //     ...
+ * //   },
+ * //   {
+ * //     id: "yyy",
+ * //     component: "text-input",
+ * //     ...
+ * //  }
+ * // ]
+ *
+ */
+declare const getComponentsSubtreeByPath: (components: DynamicComponent[], path: (string | number)[]) => {
+  pathWithComponents: DynamicComponent[];
+  complete: boolean;
+};
+//#endregion
+//#region src/dynamic-components/registry/chats.d.ts
+interface DChatTextMessage extends DynamicComponent {
+  component: 'chat-text-message';
+  props: {
+    content: RichText;
+  };
+}
+declare const isChatTextMessageComponent: (component: DynamicComponent) => component is DChatTextMessage;
+interface DChatMessageDelay extends DynamicComponent {
+  component: 'chat-message-delay';
+  props: {
+    delay: number;
+    typing: boolean;
+  };
+}
+declare const isChatMessageDelayComponent: (component: DynamicComponent) => component is DChatMessageDelay;
+//#endregion
+//#region src/dynamic-components/registry/content.d.ts
+interface DRichText extends DynamicComponent {
+  component: 'rich-text';
+  props: {
+    content: RichText;
+  };
+}
+declare const isRichTextComponent: (component: DynamicComponent) => component is DRichText;
+interface DEmbedCode extends DynamicComponent {
+  component: 'embed-code';
+  props: {
+    js?: string;
+    css?: string;
+    html?: string;
+    visible?: string;
+  };
+}
+declare const isEmbedCodeComponent: (component: DynamicComponent) => component is DEmbedCode;
+interface DImage extends DynamicComponent {
+  component: 'embed-code';
+  props: {
+    imageId: string;
+  };
+}
+declare const isImageComponent: (component: DynamicComponent) => component is DImage;
+interface DLegacyContent extends DynamicComponent {
+  component: 'legacy-content';
+  props: {
+    html: string;
+  };
+}
+declare const isLegacyContentComponent: (component: DynamicComponent) => component is DLegacyContent;
+interface DBibleQuote extends DynamicComponent {
+  component: 'bible-quote';
+  props: {
+    verseId: string;
+  };
+}
+declare const isBibleQuoteComponent: (component: DynamicComponent) => component is DBibleQuote;
+interface DBiblePassage extends DynamicComponent {
+  component: 'bible-passage';
+  props: {
+    passage: string;
+  };
+}
+declare const isBiblePassageComponent: (component: DynamicComponent) => component is DBiblePassage;
+interface TestItemVariant {
+  id: string;
+  content: RichText;
+  feedback?: RichText;
+  correct?: boolean;
+}
+interface TestItem {
+  id: string;
+  content: RichText;
+  variants: TestItemVariant[];
+}
+interface DTest extends DynamicComponent {
+  component: 'test';
+  props: {
+    title?: string;
+    items: TestItem[];
+    milestone?: string;
+  };
+}
+declare const isTestComponent: (component: DynamicComponent) => component is DTest;
+interface DStatement extends DynamicComponent {
+  component: 'statement';
+  props: {
+    content: RichText;
+  };
+}
+declare const isStatementComponent: (component: DynamicComponent) => component is DStatement;
+interface DPractice extends DynamicComponent {
+  component: 'practice';
+  props: {
+    title?: string;
+    content: RichText;
+    /**
+     * Date when the practice should be checked in ISO 8601 format
+     * @example '2023-10-01T00:08:00Z'
+     */
+    checkAt?: string;
+  };
+}
+declare const isPracticeComponent: (component: DynamicComponent) => component is DPractice;
+//#endregion
+//#region src/dynamic-components/registry/forms.d.ts
+type ISizeType = 'middle' | 'large';
+declare enum IImageRenditionType {
+  ORIGINAL = "ORIGINAL",
+  MAIN_2X = "MAIN_2X",
+  MAIN = "MAIN",
+  SMALL = "SMALL",
+  MAIN_LEGACY = "MAIN_LEGACY",
+}
+interface IRenditionOptions {
+  width: number;
+  height: number;
+  type: IImageRenditionType;
+  mimeType?: string;
+  quality?: number;
+}
+interface DHiddenInput extends DynamicComponent {
+  component: 'hidden-input';
+  props: {
+    name?: string;
+    rules?: ValidationRules;
+    testId?: string;
+  };
+}
+interface DComputedValue extends DynamicComponent {
+  component: 'computed-value';
+  props: {
+    name?: string;
+    label?: string;
+    placeholder?: string;
+    type: 'string' | 'number';
+    expression: string;
+    rules?: ValidationRules;
+    visible?: string;
+    testId?: string;
+  };
+}
+declare const isComputedValueComponent: (component: DynamicComponent) => component is DComputedValue;
+interface DTextInput extends DynamicComponent {
+  component: 'text-input';
+  props: {
+    name?: string;
+    label?: string;
+    placeholder?: string;
+    hint?: string;
+    clearable?: boolean;
+    maska?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    rules?: ValidationRules;
+    visible?: string;
+    testId?: string;
+  };
+}
+declare const isTextInputComponent: (component: DynamicComponent) => component is DTextInput;
+interface DConfirmDeletionInput extends DynamicComponent {
+  component: 'confirm-deletion-input';
+  props: {
+    title?: string;
+    text?: string;
+    keyWord: string;
+    testId?: string;
+  };
+}
+declare const isConfirmDeletionInputComponent: (component: DynamicComponent) => component is DConfirmDeletionInput;
+interface DTextarea extends DynamicComponent {
+  component: 'textarea';
+  props: {
+    name?: string;
+    label?: string;
+    placeholder?: string;
+    hint?: string;
+    rows?: number;
+    autosize?: boolean;
+    lineBreak?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    rules?: ValidationRules;
+    visible?: string;
+    testId?: string;
+  };
+}
+declare const isTextareaComponent: (component: DynamicComponent) => component is DTextarea;
+interface DHeading extends DynamicComponent {
+  component: 'heading';
+  props: {
+    text: string;
+    visible?: string;
+    testId?: string;
+  };
+}
+declare const isHeadingComponent: (component: DynamicComponent) => component is DHeading;
+interface DRichTextEditor extends DynamicComponent {
+  component: 'rich-text-editor';
+  props: {
+    name?: string;
+    label?: string;
+    placeholder?: string;
+    minHeight?: number;
+    maxLength?: number;
+    rules?: ValidationRules;
+    visible?: string;
+    testId?: string;
+  };
+}
+declare const isRichTextEditorComponent: (component: DynamicComponent) => component is DRichTextEditor;
+interface DDateTimePicker extends DynamicComponent {
+  component: 'date-time-picker';
+  props: {
+    name?: string;
+    label?: string;
+    placeholder?: string;
+    hint?: string;
+    type?: 'year' | 'month' | 'date' | 'dates' | 'week' | 'datetime' | 'datetimerange' | 'daterange' | 'monthrange';
+    readonly?: boolean;
+    format?: string;
+    clearable?: boolean;
+    rules?: {
+      required?: boolean;
+    };
+    visible?: string;
+    testId?: string;
+  };
+}
+declare const isDateTimePickerComponent: (component: DynamicComponent) => component is DDateTimePicker;
+interface DNumberInput extends DynamicComponent {
+  component: 'number-input';
+  props: {
+    name?: string;
+    label?: string;
+    placeholder?: string;
+    hint?: string;
+    autosize?: boolean;
+    readonly?: boolean;
+    rules?: ValidationRules;
+    visible?: string;
+    testId?: string;
+  };
+}
+declare const isNumberInputComponent: (component: DynamicComponent) => component is DNumberInput;
+interface DSlug extends DynamicComponent {
+  component: 'slug';
+  props: {
+    name?: string;
+    source?: string;
+    maxLength?: number;
+    readonly?: boolean;
+    rules?: {
+      required?: boolean;
+    };
+    visible?: string;
+    testId?: string;
+  };
+}
+declare const isSlugComponent: (component: DynamicComponent) => component is DSlug;
+interface DImageUploader extends DynamicComponent {
+  component: 'image-uploader';
+  props: {
+    name?: string;
+    label?: string;
+    renditions: {
+      id: string;
+      position: string;
+      width: number;
+      height: number;
+      type: IImageRenditionType;
+    }[];
+    btnText?: string;
+    size?: ISizeType;
+    rounded?: ISizeType;
+    zoomable?: boolean;
+    downloadable?: boolean;
+    height?: number;
+    width?: number;
+    tooltipContent?: string;
+    hideTooltip?: boolean;
+    maxFileSize?: number;
+    readonly?: boolean;
+    visible?: string;
+    rules?: {
+      required?: boolean;
+    };
+    testId?: string;
+  };
+}
+declare const isImageUploaderComponent: (component: DynamicComponent) => component is DImageUploader;
+interface DRawImageUploader extends DynamicComponent {
+  component: 'raw-image-uploader';
+  props: {
+    name?: string;
+    label?: string;
+    btnText?: string;
+    size?: ISizeType;
+    rounded?: boolean;
+    zoomable?: boolean;
+    downloadable?: boolean;
+    height?: number;
+    width?: number;
+    hideTooltip?: boolean;
+    tooltipContent?: string;
+    maxFileSize?: number;
+    visible?: string;
+    readonly?: boolean;
+    rules?: {
+      required?: boolean;
+    };
+    testId?: string;
+  };
+}
+declare const isRawImageUploaderComponent: (component: DynamicComponent) => component is DRawImageUploader;
+interface DRawImagesUploader extends DynamicComponent {
+  component: 'raw-images-uploader';
+  props: {
+    name?: string;
+    label?: string;
+    btnText?: string;
+    size?: ISizeType;
+    rounded?: boolean;
+    zoomable?: boolean;
+    downloadable?: boolean;
+    height?: number;
+    width?: number;
+    tooltipContent?: string;
+    hideTooltip?: boolean;
+    maxFileSize?: number;
+    visible?: string;
+    readonly?: boolean;
+    rules?: {
+      required?: boolean;
+      max?: number;
+    };
+    testId?: string;
+  };
+}
+declare const isRawImagesUploaderComponent: (component: DynamicComponent) => component is DRawImagesUploader;
+interface DSimpleImageUploader extends DynamicComponent {
+  component: 'simple-image-uploader';
+  props: {
+    name?: string;
+    label?: string;
+    rendition: {
+      width: number;
+      height: number;
+      type: IImageRenditionType;
+    };
+    btnText?: string;
+    size?: ISizeType;
+    rounded?: boolean;
+    zoomable?: boolean;
+    downloadable?: boolean;
+    width: number;
+    height: number;
+    hideTooltip?: boolean;
+    tooltipContent?: string;
+    maxFileSize?: number;
+    readonly?: boolean;
+    visible?: string;
+    rules?: {
+      required?: boolean;
+    };
+    testId?: string;
+  };
+}
+declare const isSimpleImageUploaderComponent: (component: DynamicComponent) => component is DSimpleImageUploader;
+interface DRadioGroup extends DynamicComponent {
+  component: 'radio-group';
+  props: {
+    name?: string;
+    label?: string;
+    cols?: number;
+    direction?: 'col' | 'row';
+    items: {
+      id: string;
+      position: string;
+      value: unknown;
+      label: string;
+    }[];
+    readonly?: boolean;
+    rules?: {
+      required?: boolean;
+    };
+    visible?: string;
+    testId?: string;
+  };
+}
+declare const isRadioGroupComponent: (component: DynamicComponent) => component is DRadioGroup;
+interface DSelect extends DynamicComponent {
+  component: 'select';
+  props: {
+    name?: string;
+    label?: string;
+    placeholder?: string;
+    hint?: string;
+    clearable?: boolean;
+    options: {
+      id: string;
+      position: string;
+      value: unknown;
+      label: string;
+      imageUrl?: string;
+      disabled?: boolean;
+    }[];
+    readonly?: boolean;
+    multiple?: boolean;
+    rules?: {
+      required?: boolean;
+      max?: number;
+    };
+    visible?: string;
+    testId?: string;
+  };
+}
+declare const isSelectComponent: (cmp: DynamicComponent) => cmp is DSelect;
+interface DEntitySelect extends DynamicComponent {
+  component: 'entity-select';
+  props: {
+    name?: string;
+    label?: string;
+    placeholder?: string;
+    hint?: string;
+    entityType: string;
+    labelKey?: string;
+    idKey?: string;
+    filter?: Record<string, unknown>;
+    limit?: number;
+    multiple?: boolean;
+    visible?: string;
+    clearable?: boolean;
+    rules?: {
+      required?: boolean;
+    };
+    readonly?: boolean;
+    excludeIds?: string[];
+    imageUrlKey?: string;
+    defaultImageUrl?: string;
+    testId?: string;
+  };
+}
+declare const isEntitySelectComponent: (cmp: DynamicComponent) => cmp is DEntitySelect;
+interface DCheckbox extends DynamicComponent {
+  component: 'checkbox';
+  props: {
+    name?: string;
+    label?: string;
+    readonly?: boolean;
+    rules?: {
+      required?: boolean;
+    };
+    visible?: string;
+    testId?: string;
+  };
+}
+declare const isCheckboxComponent: (component: DynamicComponent) => component is DCheckbox;
+interface DCheckboxGroup extends DynamicComponent {
+  component: 'checkbox-group';
+  props: {
+    name?: string;
+    label?: string;
+    orientation?: 'horizontal' | 'vertical';
+    items: {
+      id: string;
+      position: string;
+      value: unknown;
+      label: string;
+    }[];
+    readonly?: boolean;
+    visible?: string;
+    rules?: {
+      required?: boolean;
+    };
+    testId?: string;
+  };
+}
+declare const isCheckboxGroupComponent: (component: DynamicComponent) => component is DCheckboxGroup;
+interface DSwitch extends DynamicComponent {
+  component: 'switch';
+  props: {
+    name?: string;
+    label?: string;
+    readonly?: boolean;
+    visible?: string;
+    rules?: {
+      required?: boolean;
+    };
+    testId?: string;
+  };
+}
+declare const isSwitchComponent: (component: DynamicComponent) => component is DSwitch;
+interface DFileUploader extends DynamicComponent {
+  component: 'file-uploader';
+  props: {
+    name?: string;
+    label?: string;
+    accept?: string;
+    placeholder?: string;
+    maxFileSize?: number;
+    downloadable?: boolean;
+    readonly?: boolean;
+    visible?: string;
+    rules?: {
+      required?: boolean;
+    };
+    testId?: string;
+  };
+}
+declare const isFileUploaderComponent: (component: DynamicComponent) => component is DFileUploader;
+//#endregion
+//#region src/dynamic-components/registry/layout.d.ts
+interface DColumn extends DynamicComponent {
+  component: 'column';
+  props: {
+    size: number;
+    visible?: string;
+    justifySelf?: 'start' | 'center' | 'end' | 'stretch';
+    placeSelf?: 'start' | 'center' | 'end' | 'stretch';
+    components: DynamicComponent[];
+  };
+}
+declare const isColumnComponent: (component: DynamicComponent) => component is DColumn;
+interface DRow extends DynamicComponent {
+  component: 'row';
+  props: {
+    components: DColumn[];
+    visible?: string;
+    placeItems?: 'start' | 'center' | 'end' | 'stretch';
+    justifyItems?: 'start' | 'center' | 'end' | 'stretch';
+  };
+}
+declare const isRowComponent: (component: DynamicComponent) => component is DRow;
+interface DCollection extends DynamicComponent {
+  component: 'collection';
+  props: {
+    name?: string;
+    heading: string;
+    components: DynamicComponent[];
+    rules?: ValidationRules;
+    readonly?: boolean;
+    visible?: string;
+  };
+}
+declare const isCollectionComponent: (component: DynamicComponent) => component is DCollection;
+interface DRepeatableCollection extends DynamicComponent {
+  component: 'repeatable-collection';
+  props: {
+    name?: string;
+    heading: string;
+    collectionTitle?: string;
+    useTabs?: boolean;
+    cols?: number;
+    tabName?: string;
+    confirmDeletion?: boolean;
+    addButtonText?: string;
+    readonly?: boolean;
+    components: DynamicComponent[];
+    visible?: string;
+    rules?: {
+      required?: boolean;
+    };
+  };
+}
+declare const isRepeatableCollectionComponent: (component: DynamicComponent) => component is DRepeatableCollection;
+interface DRowSettings extends DynamicComponent {
+  component: 'row-settings';
+  props: {
+    label?: string;
+  };
+}
+declare const isRowSettingsComponent: (component: DynamicComponent) => component is DRowSettings;
+//#endregion
+//#region src/dynamic-components/registry/uikit-dynamic-component.d.ts
+type FormDynamicComponent = DTextInput | DCheckbox | DTextarea | DSelect | DEntitySelect | DRadioGroup | DCheckboxGroup | DFileUploader | DImageUploader | DSimpleImageUploader | DRawImageUploader | DSlug | DEmbedCode | DRichTextEditor | DNumberInput | DSwitch | DHeading | DRawImagesUploader | DDateTimePicker | DComputedValue | DHiddenInput | DConfirmDeletionInput;
+type UiKitContentDynamicComponent = DRichText | DEmbedCode | DImage | DBibleQuote | DBiblePassage;
+type UiKitLayoutDynamicComponent = DRow | DColumn | DRowSettings | DCollection | DRepeatableCollection;
+type UiKitChatDynamicComponent = DChatTextMessage;
+type UiKitDynamicComponent = FormDynamicComponent | UiKitContentDynamicComponent | UiKitLayoutDynamicComponent | UiKitChatDynamicComponent;
+//#endregion
+//#region src/dynamic-components/tools.d.ts
+declare const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+declare const customAlphabet: (alphabet: string, defaultSize?: number) => (size?: number) => string;
+declare const uid: (size?: number) => string;
+/**
+ * Gets the path to a property in a component.
+ * @param {(string | number)[]} componentPath - The path to the component.
+ * @param {string} name - The name of the property.
+ * @returns {(string | number)[]} Returns the path to the property.
+ * @example
+ * getComponentPropertyPath(['components', 0], 'name');  // Returns ['components', 0, 'props', 'name']
+ */
+declare const getComponentPropertyPath: (componentPath: (string | number)[], name: string) => (string | number)[];
+/**
+ * Creates a copy of a dynamic component.
+ * @param {DynamicComponent} component - The component to copy.
+ * @param {Y.Doc} yDoc - The Yjs document to update with the copied component.
+ * @returns {DynamicComponent} Returns the copied component.
+ */
+declare const copyDynamicComponent: (component: DynamicComponent, yDoc?: Y.Doc) => DynamicComponent;
+/**
+ * Sorts an array of dynamic components and generates a position for each one.
+ * @param {DynamicComponent[]} components - The components to sort.
+ * @returns {DynamicComponentWithPosition[]} Returns the sorted components with positions.
+ */
+declare const sortDynamicComponents: (components: DynamicComponent[]) => DynamicComponentWithPosition[];
+/**
+ * Searches for a dynamic component in a tree that matches a condition.
+ * @param {DynamicComponent[]} components - The tree of components to search.
+ * @param {(cmp: DynamicComponent) => boolean} isMatches - The condition to match.
+ * @returns {DynamicComponent | null} Returns the matching component, or null if no match was found.
+ */
+declare const searchDynamicComponentInTree: (components: DynamicComponent[], isMatches: (cmp: DynamicComponent) => boolean) => DynamicComponent | null;
+declare const getRelativePoint: (point: Point, relative: Point) => Point;
+/**
+ * Creates a copy of a dynamic component and set its position (fractional-index) rely on the index of the component.
+ * @param components - The components without positions.
+ */
+declare const makeDynamicComponentsWithPosition: (components: DynamicComponent[]) => DynamicComponentWithPosition[];
+//#endregion
+//#region src/paths/array-keys.d.ts
+/**
+ * In the system you are using, two types of keys are used to identify elements in an array: ID keys and position keys.
+ * These keys provide a flexible and robust way to refer to specific elements in an array, particularly when dealing with arrays of objects.
+ *
+ * 1. **ID Keys:**
+ * These keys have a prefix of 'id:' and are followed by the unique identifier of an object in the array.
+ * For example, in your array `items: [{ id: 'xxx', name: 'John' }]`, you can refer to the object with `id: 'xxx'` using the ID key 'id:xxx'.
+ * This is particularly useful when you have a unique identifier for each object in your array.
+ * With this, even if objects move around in the array, you can always accurately refer to a specific object using its unique ID.
+ *
+ * 2. **Position Keys:**
+ * These keys have a prefix of 'pos:' and are followed by a position indicator.
+ * Position keys provide a way to refer to an object in an array based on its position rather than its content.
+ * This can be useful when the position of an object in an array is significant and you want to refer to an object based on where it is in the array.
+ *
+ * In your path system, you can use either type of key as part of the path to refer to specific elements in an array.
+ * For example, if you have an object like `{ items: [{ id: 'xxx', name: 'John' }] }`,
+ * you can refer to the name of the first item in the array using either an ID key or a position key in the path:
+ *
+ * - Using an ID key: `['items', 'id:xxx', 'name']`
+ * - Using a position key: `['items', 'pos:0', 'name']`
+ *
+ * This system of using ID and position keys in paths gives you a powerful and flexible way to refer to specific elements in complex, nested objects.
+ */
+declare const POSITION_ARRAY_KEY_PREFIX = "pos:";
+/**
+ * Checks if the given key is a position array key.
+ * @param {unknown} key - The key to check.
+ * @returns {boolean} Returns true if `key` is a position array key, false otherwise.
+ * @example
+ * isPositionArrayKey('pos:0');  // Returns true
+ * isPositionArrayKey('id:0');  // Returns false
+ */
+declare const isPositionArrayKey: (key: unknown) => key is string;
+/**
+ * Creates a position array key.
+ * @param {string} position - The position to create the key for.
+ * @returns {string} Returns the created position array key.
+ * @example
+ * createPositionArrayKey('0');  // Returns 'pos:0'
+ */
+declare const createPositionArrayKey: (position: string) => string;
+/**
+ * Extracts the position from a position array key.
+ * @param {string} key - The position array key to extract the position from.
+ * @returns {string} Returns the extracted position.
+ * @example
+ * extractPositionFromArrayKey('pos:0');  // Returns '0'
+ */
+declare const extractPositionFromArrayKey: (key: string) => string;
+declare const ID_PATH_KEY_PREFIX = "id:";
+/**
+ * Checks if the given key is an ID array key.
+ * @param {unknown} key - The key to check.
+ * @returns {boolean} Returns true if `key` is an ID array key, false otherwise.
+ * @example
+ * isIdArrayKey('id:123');  // Returns true
+ * isIdArrayKey('pos:0');  // Returns false
+ */
+declare const isIdArrayKey: (key: unknown) => key is string;
+/**
+ * Creates an ID array key.
+ * @param {string} id - The ID to create the key for.
+ * @returns {string} Returns the created ID array key.
+ * @example
+ * createIdArrayKey('123');  // Returns 'id:123'
+ */
+declare const createIdArrayKey: (id: string) => string;
+/**
+ * Extracts the ID from an ID array key.
+ * @param {string} key - The ID array key to extract the ID from.
+ * @returns {string} Returns the extracted ID.
+ * @example
+ * extractIdFromArrayKey('id:123');  // Returns '123'
+ */
+declare const extractIdFromArrayKey: (key: string) => string;
+/**
+ * Checks if the given key is an array key (either a position array key or an ID array key).
+ * @param {unknown} key - The key to check.
+ * @returns {boolean} Returns true if `key` is an array key, false otherwise.
+ * @example
+ * isArrayKey('id:123');  // Returns true
+ * isArrayKey('pos:0');  // Returns true
+ * isArrayKey('abc');  // Returns false
+ */
+declare const isArrayKey: (key: unknown) => key is string;
+/**
+ * Extracts the index from an array key in a given array.
+ * @param {unknown} array - The array to extract the index from.
+ * @param {string} key - The array key to extract the index from.
+ * @returns {number} Returns the extracted index.
+ * @example
+ * getIndexByArrayKey(['a', 'b', 'c'], 'pos:1');  // Returns 1
+ */
+declare const getIndexByArrayKey: (array: unknown, key: string) => number;
+//#endregion
+//#region src/paths/types.d.ts
+/**
+ * The NestedRecord type represents a deeply nested object structure. It can be one of the following:
+ * - A Record with string keys and unknown values
+ * - An object with string keys and NestedRecord values
+ * - An array of NestedRecords
+ * - An array of unknown values
+ *
+ * This type is useful when working with deeply nested data structures where the shape of the data is not known beforehand.
+ *
+ * @example
+ * let record: NestedRecord = {
+ *   key: "value",
+ *   nested: {
+ *     innerKey: "innerValue",
+ *     array: [
+ *       {
+ *         deepKey: "deepValue"
+ *       }
+ *     ]
+ *   },
+ * };
+ */
+type NestedRecord = Record<string, unknown> | {
+  [k: string]: NestedRecord;
+} | NestedRecord[] | unknown[];
+/**
+ * Represents the payload for a set operation in a NestedRecord.
+ */
+interface SetPayload<T> {
+  /**
+   * The path to the field in the NestedRecord.
+   */
+  path: (string | number)[];
+  /**
+   * The real path to the field in the NestedRecord, represented as an array of component (editor) IDs.
+   */
+  rpath: string[];
+  /**
+   * The change like input letter in text input
+   */
+  atomic?: boolean;
+  /**
+   * The new value for the field.
+   */
+  value: T;
+}
+/**
+ * Represents the payload for an unset operation in a NestedRecord.
+ */
+interface UnsetPayload {
+  /**
+   * The path to the field in the NestedRecord.
+   */
+  path: (string | number)[];
+  /**
+   * The real path to the field in the NestedRecord, represented as an array of component (editor) IDs.
+   */
+  rpath: string[];
+}
+/**
+ * Represents the payload for a push operation in a NestedRecord.
+ */
+interface PushPayload<T> {
+  /**
+   * The path to the field in the NestedRecord.
+   */
+  path: (string | number)[];
+  /**
+   * The real path to the field in the NestedRecord, represented as an array of component (editor) IDs.
+   */
+  rpath: string[];
+  /**
+   * The value to push into the field.
+   */
+  value: T;
+}
+/**
+ * Represents the payload for a pull operation in a NestedRecord.
+ */
+interface PullPayload {
+  /**
+   * The path to the field in the NestedRecord.
+   */
+  path: (string | number)[];
+  /**
+   * The real path to the field in the NestedRecord, represented as an array of component (editor) IDs.
+   */
+  rpath: string[];
+  /**
+   * The key of the value to pull from the field.
+   */
+  key: string | number;
+}
+/**
+ * Represents the payload for a move operation in a NestedRecord.
+ */
+interface MovePayload {
+  /**
+   * The path to the field in the NestedRecord.
+   */
+  path: (string | number)[];
+  /**
+   * The real path to the field in the NestedRecord, represented as an array of component (editor) IDs.
+   */
+  rpath: string[];
+  /**
+   * The old fractional position of the field
+   */
+  oldPosition: string;
+  /**
+   * The fractional position of the related field, rely on which the field should be moved.
+   */
+  relativePosition: string;
+  /**
+   * Indicates whether the field should be inserted before or after the relative position.
+   */
+  insert: 'before' | 'after';
+}
+//#endregion
+//#region src/paths/array-ops.d.ts
+/**
+ * Pushes a value into a nested array in an object using a path.
+ * @param {NestedRecord} object - The object to push the value into.
+ * @param {(string | number)[]} path - The path to the array in the object.
+ * @param {unknown} value - The value to push.
+ * @example
+ * let obj = { items: ['John'] };
+ * pushInPath(obj, ['items'], 'Jane');  // obj is now { items: ['John', 'Jane'] }
+ */
+declare const pushInPath: (object: NestedRecord, path: (string | number)[], value: unknown) => void;
+/**
+ * Inserts values into a nested array in an object at a specified index or key using a path.
+ * @param {NestedRecord} object - The object to insert the values into.
+ * @param {(string | number)[]} path - The path to the array in the object.
+ * @param {string | number} keyOrIndex - The index or key at which to insert the values.
+ * @param {unknown[]} values - The values to insert.
+ * @example
+ * let obj = { items: ['John', 'Jane'] };
+ * insertInPath(obj, ['items'], 1, ['Joe']);  // obj is now { items: ['John', 'Joe', 'Jane'] }
+ */
+declare const insertInPath: (object: NestedRecord, path: (string | number)[], keyOrIndex: string | number, values: unknown[]) => void;
+/**
+ * Removes a value from a nested array in an object at a specified index or array key using a path.
+ * @param {NestedRecord} object - The object to remove the value from.
+ * @param {(string | number)[]} path - The path to the array in the object.
+ * @param {string | number} key - The index or key at which to remove the value.
+ * @example
+ * let obj = { items: ['John', 'Joe', 'Jane'] };
+ * pullFromPath(obj, ['items'], 1);  // obj is now { items: ['John', 'Jane'] }
+ */
+declare const pullFromPath: (object: NestedRecord, path: (string | number)[], key: string | number) => void;
+/**
+ * Moves an item to a new position relative to another item in the array or object at the specified path.
+ *
+ * @example
+ * moveInYPath(values, ['components'], 'a0', 'b1', 'after');
+ */
+declare const moveInPath: (object: NestedRecord, path: (string | number)[], oldPosition: string, relativePosition: string, insert: "before" | "after") => string;
+//#endregion
+//#region src/paths/basic-ops.d.ts
+/**
+ * Gets a nested property value from an object using a path.
+ * @param {NestedRecord | undefined} object - The object to get the value from.
+ * @param {(string | number)[]} path - The path to the value in the object.
+ * @returns {TValue | undefined} Returns the value at the specified path in the object.
+ * @example
+ * getFromPath({ items: [{ name: 'John' }] }, ['items', 0, 'name']);  // Returns 'John'
+ */
+declare const getFromPath: <TValue = unknown>(object: NestedRecord | undefined, path: (string | number)[]) => TValue | undefined;
+/**
+ * Sets a nested property value in a path, creates the path properties if they don't exist.
+ * @param {NestedRecord} object - The object to set the value in.
+ * @param {(string | number)[]} path - The path to the value in the object.
+ * @param {unknown} value - The value to set.
+ * @example
+ * let obj = { items: [{ name: 'John' }] };
+ * setInPath(obj, ['items', 0, 'name'], 'Jane');  // obj is now { items: [{ name: 'Jane' }] }
+ */
+declare const setInPath: (object: NestedRecord, path: (string | number)[], value: unknown) => void;
+/**
+ * Removes a nested property from an object using a path.
+ * @param {NestedRecord} object - The object to remove the value from.
+ * @param {(string | number)[]} path - The path to the value in the object.
+ * @example
+ * let obj = { items: [{ name: 'John' }] };
+ * unsetPath(obj, ['items', 0, 'name']);  // obj is now { items: [{}] }
+ */
+declare const unsetPath: (object: NestedRecord, path: (string | number)[]) => void;
+/** Checks if a nested property exists in an object using a path.
+ * @param {NestedRecord | undefined} object - The object to check the value in.
+ * @param {(string | number)[]} path - The path to the value in the object.
+ * @returns {boolean} Returns true if the value exists at the specified path, false otherwise.
+ * @example
+ * existsInPath({ items: [{ name: 'John' }] }, ['items', 0, 'name']);  // Returns true
+ * existsInPath({ items: [{ name: 'John' }] }, ['items', 1, 'name']);  // Returns false
+ */
+declare const existsInPath: (object: NestedRecord | undefined, path: (string | number)[]) => boolean;
+/** * Compares two paths for equality.
+ * @param {(string | number)[]} pathA - The first path to compare.
+ * @param {(string | number)[]} pathB - The second path to compare.
+ * @returns {boolean} Returns true if the paths are equal, false otherwise.
+ * @example
+ * isSamePath(['items', 0, 'name'], ['items', 0, 'name']);  // Returns true
+ * isSamePath(['items', 0, 'name'], ['items', 1, 'name']);  // Returns false
+ */
+declare const isSamePath: (pathA: (string | number)[], pathB: (string | number)[]) => boolean;
+//#endregion
+//#region src/paths/constants.d.ts
+declare const PATH_REGEXP: RegExp;
+//#endregion
+//#region src/paths/tools.d.ts
+/**
+ * Joins a path with additional items.
+ * @param {(string | number)[]} path - The initial path.
+ * @param {...(string | number)[]} items - The items to add to the path.
+ * @returns {(string | number)[]} Returns the joined path.
+ * @throws {Error} If `path` is not an array or if any of `items` are not a string or an integer.
+ * @example
+ * joinPath(['items', 'id:xxx'], 'name');  // Returns ['items', 'id:xxx', 'name']
+ */
+declare const joinPath: (path: (string | number)[], ...items: (string | number)[]) => (string | number)[];
+/**
+ * Compares two fractional-based position strings for sorting.
+ * @param {string} aPosition - The first fractional-based position string.
+ * @param {string} bPosition - The second fractional-based position string.
+ * @returns {number} Returns -1 if `aPosition` comes before `bPosition`, 1 if `aPosition` comes after `bPosition`, or 0 if they are equal.
+ * @example
+ * sortByPosition('a1', 'a2');  // Returns -1
+ */
+declare const sortByPosition: (aPosition: string, bPosition: string) => 0 | 1 | -1;
+//#endregion
+//#region src/y-components/types.d.ts
+/**
+ * Represents a dynamic component in Y.js.
+ * Each component is represented as a Y.Map object where each key-value pair corresponds to a property of the component.
+ */
+type YComponent = Y.Map<unknown>;
+/**
+ * Represents an array of dynamic components in Y.js.
+ * Each component in the array is represented as a YComponent.
+ */
+type YComponentsArray = Y.Array<YComponent>;
+/**
+ * Represents the properties of a dynamic component in Y.js.
+ * Each property is represented as a key-value pair in a Y.Map object.
+ */
+type YComponentProps = Y.Map<unknown>;
+//#endregion
+//#region src/y-components/tools.d.ts
+/**
+ * This function converts dynamic component properties to Y.Map representation.
+ */
+declare const dynamicComponentPropsToYComponentProps: (props: Record<string, unknown>) => Y.Map<unknown>;
+/**
+ * This function converts a dynamic component to Y.Map representation.
+ */
+declare const dynamicComponentToYMap: (component: DynamicComponent, yMap?: Y.Map<unknown>) => YComponent;
+/**
+ * This function converts an array of dynamic components to Y.Array representation.
+ */
+declare const dynamicComponentsToYArray: (components: DynamicComponent[], yArray?: Y.Array<unknown>) => Y.Array<unknown>;
+/**
+ * This function checks if a given Y.Map object is a YComponent.
+ */
+declare const isYComponent: (yComponent: unknown) => yComponent is YComponent;
+/**
+ * This function converts a YComponent to a dynamic component.
+ */
+declare const yComponentToDynamicComponent: (yComponent: YComponent, extractContent?: boolean) => DynamicComponentWithPosition;
+/**
+ * This function converts a dynamic component to YComponent.
+ */
+declare const dynamicComponentToYComponent: (component: DynamicComponent) => YComponent;
+/**
+ * This function retrieves the properties of a YComponent.
+ */
+declare const getYComponentProps: (yComponent: YComponent) => Y.Map<unknown>;
+/**
+ * This function retrieves the array of components of a YComponent.
+ */
+declare const getYComponentComponentsArray: (yComponent: YComponent) => Y.Array<YComponent>;
+/**
+ * This function checks if a YComponent has a components array.
+ * @example
+ * // component
+ * {
+ *   id: "column",
+ *   component: "column",
+ *   props: {
+ *     components: [...] <= has components array
+ *   }
+ * }
+ */
+declare const yComponentHasComponentsYArray: (yComponent: YComponent) => boolean;
+/**
+ * This function retrieves the parent component of a YArray of YComponents.
+ * @example
+ * // parent component
+ * {
+ *   id: "column",
+ *   component: "column",
+ *   props: {
+ *     components: [...] <= components array
+ *   }
+ * }
+ */
+declare const getYComponentsArrayParentComponent: (yArray: Y.Array<YComponent>) => YComponent | null;
+/**
+ * This function finds a Y.Component in a Y.Array by its ID.
+ */
+declare const findYComponentInArray: (yArray: Y.Array<YComponent>, componentId: string) => YComponent;
+//#endregion
+//#region src/y-tools/array-path-ops.d.ts
+/**
+ * Pushes a value to the end of the Y.Array at the specified path.
+ *
+ * @example
+ * let yMap = new Y.Map();
+ * yMap.set('names', new Y.Array());
+ * pushInYPath(yMap, ['names'], 'John');
+ * // yMap now looks like: { names: ['John'] }
+ */
+declare const pushInYPath: (entry: Y.Array<any> | Y.Map<any>, path: (string | number)[], value: any) => void;
+/**
+ * Moves an item to a new position relative to another item in the Y.Array or Y.Map at the specified path.
+ *
+ * @example
+ * moveInYPath(yMap, ['components'], 'a0', 'b1', 'after');
+ */
+declare const moveInYPath: (entry: Y.Array<any> | Y.Map<any>, path: (string | number)[], oldPosition: string, relativePosition: string, insert: "before" | "after") => string;
+/**
+ * Removes an item from the Y.Array or Y.Map at the specified path.
+ *
+ * @example
+ * let yArray = new Y.Array();
+ * yArray.push(['item1', 'item2', 'item3']);
+ * pullFromYPath(yArray, [1]);
+ * // yArray now looks like: ['item1', 'item3']
+ */
+declare const pullFromYPath: (entry: Y.Array<any> | Y.Map<any>, path: (string | number)[], key: string | number) => void;
+interface MoveYMapToStartOptions {
+  yArray: Y.Array<Y.Map<unknown>>;
+  yMap: Y.Map<unknown>;
+}
+/**
+ * Moves a Y.Map to the start of a Y.Array.
+ * */
+declare const moveYMapToStart: ({
+  yArray,
+  yMap
+}: MoveYMapToEndOptions) => void;
+interface MoveYMapToEndOptions {
+  yArray: Y.Array<Y.Map<unknown>>;
+  yMap: Y.Map<unknown>;
+}
+/**
+ * Moves a Y.Map to the end of a Y.Array.
+ * */
+declare const moveYMapToEnd: ({
+  yArray,
+  yMap
+}: MoveYMapToEndOptions) => void;
+interface MoveYMapBeforeOptions {
+  yArray: Y.Array<Y.Map<unknown>>;
+  yMap: Y.Map<unknown>;
+  relativePosition: string;
+}
+/**
+ * Moves a Y.Map before another Y.Map in a Y.Array.
+ * */
+declare const moveYMapBefore: ({
+  yArray,
+  yMap,
+  relativePosition
+}: MoveYMapBeforeOptions) => void;
+interface MoveYMapAfterOptions {
+  yArray: Y.Array<Y.Map<unknown>>;
+  yMap: Y.Map<unknown>;
+  relativePosition: string;
+}
+/**
+ * Moves a Y.Map after another Y.Map in a Y.Array.
+ * */
+declare const moveYMapAfter: ({
+  yArray,
+  yMap,
+  relativePosition
+}: MoveYMapAfterOptions) => void;
+interface InsertYMapToEndOptions {
+  yArray: Y.Array<Y.Map<unknown>>;
+  yMap: Y.Map<unknown>;
+}
+/**
+ * Inserts a Y.Map to the end of a Y.Array.
+ * */
+declare const insertYMapToEnd: (opts: InsertYMapToEndOptions) => void;
+interface InsertYMapBeforeOptions {
+  yArray: Y.Array<Y.Map<unknown>>;
+  yMap: Y.Map<unknown>;
+  relativePosition: string;
+}
+/**
+ * Inserts a Y.Map before another Y.Map in a Y.Array.
+ * */
+declare const insertYMapBefore: (opts: InsertYMapBeforeOptions) => void;
+interface InsertYMapAfterOptions {
+  yArray: Y.Array<Y.Map<unknown>>;
+  yMap: Y.Map<unknown>;
+  relativePosition: string;
+}
+/**
+ * Inserts a Y.Map before another Y.Map in a Y.Array.
+ * */
+declare const insertYMapAfter: (opts: InsertYMapAfterOptions) => void;
+//#endregion
+//#region src/y-tools/basic-path-ops.d.ts
+/**
+ * Sets a value at a given path within a Y.Map or Y.Array.
+ *
+ * @example
+ * let ymap = new Y.Map();
+ * setInYPath(ymap, ['key'], 'value');
+ * // ymap now looks like: { key: 'value' }
+ */
+declare const setInYPath: (ymap: Y.Map<unknown> | Y.Array<unknown>, path: (string | number)[], value: unknown) => void;
+/**
+ * Removes a nested property from a Y.Map or Y.Array.
+ *
+ * @example
+ * let ymap = new Y.Map();
+ * ymap.set('key', 'value');
+ * unsetYPath(ymap, ['key']);
+ * // ymap now looks like: {}
+ */
+declare const unsetYPath: (yType: Y.Map<unknown> | Y.Array<unknown>, path: (string | number)[]) => void;
+/**
+ * Retrieves a nested property value from a Y.Map or Y.Array.
+ *
+ * @example
+ * let ymap = new Y.Map();
+ * ymap.set('key', 'value');
+ * const value = getFromYPath(ymap, ['key']);
+ * // value is now: 'value'
+ */
+declare const getFromYPath: (entry: Y.Array<any> | Y.Map<any>, path: (string | number)[]) => unknown | null;
+//#endregion
+//#region src/y-tools/tools.d.ts
+/**
+ * Returns the index of the first item in a Y.Array that matches a condition.
+ *
+ * @example
+ * let yArray = new Y.Array();
+ * yArray.push(['item1', 'item2', 'item3']);
+ * const index = findIndexInYArray(yArray, (item) => item === 'item2');
+ * // index is now: 1
+ */
+declare const findIndexInYArray: <T = unknown>(yArray: Y.Array<T>, isMatches: (item: T) => boolean) => number;
+/**
+ * Returns the first item in a Y.Array that matches a condition.
+ *
+ * @example
+ * let yArray = new Y.Array();
+ * yArray.push(['item1', 'item2', 'item3']);
+ * const item = findInYArray(yArray, (item) => item === 'item2');
+ * // item is now: 'item2'
+ */
+declare const findInYArray: <T = unknown>(yArray: Y.Array<T>, isMatches: (item: T) => boolean) => T | null;
+/**
+ * Converts an object to a Y.Map.
+ *
+ * @example
+ * const object = { key: 'value' };
+ * const yMap = objectToYMap(object);
+ * // yMap now looks like: { key: 'value' }
+ */
+declare const objectToYMap: (values: object) => Y.Map<unknown>;
+/**
+ * Converts an array to a Y.Array.
+ *
+ * @example
+ * const array = ['item1', 'item2', 'item3'];
+ * const yArray = arrayToYArray(array);
+ * // yArray now looks like: ['item1', 'item2', 'item3']
+ */
+declare const arrayToYArray: (array: unknown[], yArray?: Y.Array<unknown>) => Y.Array<unknown>;
+/**
+ * Returns a sorted Y.Array based on the position of each Y.Map in it.
+ *
+ * @example
+ * let yArray = new Y.Array();
+ * let yMap1 = new Y.Map();
+ * let yMap2 = new Y.Map();
+ * yMap1.set('position', 'a0');
+ * yMap2.set('position', 'b0');
+ * yArray.push([yMap2, yMap1]);
+ * const sortedYArray = getSortedYArray(yArray);
+ * // sortedYArray now looks like: [ yMap1, yMap2 ]
+ */
+declare const getSortedYArray: <T extends Y.Map<any>>(yArray: Y.Array<T>) => T[];
+/**
+ * Returns references to a Y.Map and its neighbors in a Y.Array based on its position.
+ *
+ * @example
+ * let yArray = new Y.Array();
+ * let yMap1 = new Y.Map();
+ * let yMap2 = new Y.Map();
+ * yMap1.set('position', 'a0');
+ * yMap2.set('position', 'b0');
+ * yArray.push([yMap2, yMap1]);
+ * const refs = getYArrayRefsByPosition(yArray, 'a0');
+ * // refs now looks like: { index: 0, ref: yMap1, right: yMap2, left: undefined, sortedArray: [yMap1, yMap2] }
+ */
+declare const getYArrayRefsByPosition: <T extends Y.Map<unknown>>(yArray: Y.Array<T>, position: string) => {
+  index: number;
+  ref: T;
+  right: T;
+  left: T;
+  sortedArray: T[];
+};
+//#endregion
+//#region src/y-tools/types.d.ts
+/**
+ * Represents changes in Y.js awareness state. Contains arrays of added, removed, and updated items.
+ */
+interface AwarenessStateChange {
+  added: number[];
+  removed: number[];
+  updated: number[];
+}
+/**
+ * Represents the awareness state. This includes a cursor, user information (id, name, avatarUrl), and a color.
+ *
+ * @example
+ * const awarenessState: AwarenessState = {
+ *   cursor: ['xxx', 'yyy'], // rpath
+ *   user: {
+ *     id: 'abc123',
+ *     name: 'John Doe',
+ *     avatarUrl: 'https://example.com/avatar.jpg'
+ *   },
+ *   color: '#ff0000'
+ * };
+ */
+interface AwarenessState {
+  cursor: string[];
+  user: {
+    id: string;
+    name: string;
+    avatarUrl?: string;
+  };
+  color: string;
+}
+//#endregion
+//#region src/y-tools/y-array-keys.d.ts
+/**
+ * Returns the index of an item in a Y.Array based on its key.
+ * The key can represent either the id or the position of the item in the array.
+ *
+ * @example
+ * let yArray = new Y.Array();
+ * let yMap = new Y.Map();
+ * yMap.set('id', '123');
+ * yMap.set('position', 'a0');
+ * yArray.push([yMap]);
+ * const index = getYArrayIndexByArrayKey(yArray, 'id:123');
+ * const index = getYArrayIndexByArrayKey(yArray, 'pos:a0');
+ * // index is now: 0
+ */
+declare const getYArrayIndexByArrayKey: (yArray: unknown, key: string) => number;
+//#endregion
+export { AwarenessState, AwarenessStateChange, BaseDataObject, ComponentStyles, DBiblePassage, DBibleQuote, DChatMessageDelay, DChatTextMessage, DCheckbox, DCheckboxGroup, DCollection, DColumn, DComputedValue, DConfirmDeletionInput, DDateTimePicker, DEmbedCode, DEntitySelect, DFileUploader, DHeading, DHiddenInput, DImage, DImageUploader, DLegacyContent, DNumberInput, DPractice, DRadioGroup, DRawImageUploader, DRawImagesUploader, DRepeatableCollection, DRichText, DRichTextEditor, DRow, DRowSettings, DSelect, DSimpleImageUploader, DSlug, DStatement, DSwitch, DTest, DTextInput, DTextarea, DynamicComponent, DynamicComponentIO, DynamicComponentLink, DynamicComponentWithPosition, FormDynamicComponent, ID_PATH_KEY_PREFIX, IImageRenditionType, IRenditionOptions, ISizeType, InsertYMapAfterOptions, InsertYMapBeforeOptions, InsertYMapToEndOptions, MovePayload, MoveYMapAfterOptions, MoveYMapBeforeOptions, MoveYMapToEndOptions, MoveYMapToStartOptions, NestedRecord, PATH_REGEXP, POSITION_ARRAY_KEY_PREFIX, Point, PullPayload, PushPayload, RichText, SetPayload, TestItem, TestItemVariant, UiKitChatDynamicComponent, UiKitContentDynamicComponent, UiKitDynamicComponent, UiKitLayoutDynamicComponent, UnsetPayload, ValidationRules, YComponent, YComponentProps, YComponentsArray, arrayToYArray, copyDynamicComponent, createIdArrayKey, createPositionArrayKey, customAlphabet, defineDynamicComponent, defineDynamicComponents, dynamicComponentPropsToYComponentProps, dynamicComponentToYComponent, dynamicComponentToYMap, dynamicComponentsToYArray, entriesOf, existsInPath, extractIdFromArrayKey, extractPositionFromArrayKey, findInYArray, findIndexInYArray, findYComponentInArray, generateKeyBetween, getComponentPropertyPath, getComponentsSubtreeByPath, getComponentsSubtreeByRPath, getDataObjectKey, getFromPath, getFromYPath, getIndexByArrayKey, getRelativePoint, getSortedYArray, getYArrayIndexByArrayKey, getYArrayRefsByPosition, getYComponentComponentsArray, getYComponentProps, getYComponentsArrayParentComponent, insertInPath, insertYMapAfter, insertYMapBefore, insertYMapToEnd, isArrayKey, isBiblePassageComponent, isBibleQuoteComponent, isCallable, isChatMessageDelayComponent, isChatTextMessageComponent, isCheckboxComponent, isCheckboxGroupComponent, isCollectionComponent, isColumnComponent, isComputedValueComponent, isConfirmDeletionInputComponent, isContainerValue, isDateTimePickerComponent, isEmbedCodeComponent, isEmptyArray, isEmptyContainer, isEntitySelectComponent, isEqualPath, isFileUploaderComponent, isHeadingComponent, isIdArrayKey, isImageComponent, isImageUploaderComponent, isIndex, isLegacyContentComponent, isNullOrUndefined, isNumber, isNumberInputComponent, isObject, isPositionArrayKey, isPracticeComponent, isRadioGroupComponent, isRawImageUploaderComponent, isRawImagesUploaderComponent, isRepeatableCollectionComponent, isRichText, isRichTextComponent, isRichTextEditorComponent, isRowComponent, isRowSettingsComponent, isSamePath, isSelectComponent, isSimpleImageUploaderComponent, isSlugComponent, isStatementComponent, isString, isSwitchComponent, isTestComponent, isTextInputComponent, isTextareaComponent, isYArray, isYComponent, isYMap, joinPath, keysOf, makeDynamicComponentsWithPosition, moveInPath, moveInYPath, moveYMapAfter, moveYMapBefore, moveYMapToEnd, moveYMapToStart, objectToYMap, pullFromPath, pullFromYPath, pushInPath, pushInYPath, searchDynamicComponentInTree, setInPath, setInYPath, sortByPosition, sortDynamicComponents, uid, unsetPath, unsetYPath, urlAlphabet, yComponentHasComponentsYArray, yComponentToDynamicComponent };
+//# sourceMappingURL=index.d.ts.map