powerpagestoolkit 2.221.12 → 2.701.4

package/dist/import_map.json

@@ -0,0 +1,6 @@
+{
+  "imports": {
+    "powerpagestoolkit/": "./",
+    "powerpagestoolkit": "./index.js"
+  }
+}

package/dist/src/constants/eventMapping.d.ts

@@ -0,0 +1,7 @@
+/// <reference path="../globals.d.ts" />
+/**
+ * For use in setting up event management in the instances of DOMNodeReference
+ * @see {@link DOMNodeReference}
+ */
+declare const eventMapping: Record<string, keyof HTMLElementEventMap>;
+export default eventMapping;

package/dist/src/constants/symbols.d.ts

@@ -0,0 +1,14 @@
+/// <reference path="../globals.d.ts" />
+export declare const init: unique symbol;
+export declare const destroy: unique symbol;
+export declare const valueSync: unique symbol;
+export declare const dateSync: unique symbol;
+export declare const getElementValue: unique symbol;
+export declare const attachVisibilityController: unique symbol;
+export declare const attachRadioButtons: unique symbol;
+export declare const bindMethods: unique symbol;
+export declare const debounceTime: unique symbol;
+export declare const observers: unique symbol;
+export declare const boundEventListeners: unique symbol;
+export declare const isValidFormElement: unique symbol;
+export declare const registerEventListener: unique symbol;

package/dist/{API.d.ts → src/core/API.d.ts}

@@ -1,10 +1,18 @@
-declare const API: {
+/// <reference path="../globals.d.ts" />
+/**
+ * Provides abstract class `API` that allows basic create, read, and update operations in DataVerse via the PowerPages API
+ * @method `createRecord` - Create a record in DataVerse
+ * @method `getRecord<T>` - Get a record by ID from DataVerse
+ * @method `getMultiple` - Get multiple records from DataVerse; with optional OData filtering
+ * @method `updateRecord` - Update a record by ID in DataVerse
+ */
+declare abstract class API {
     /**
-     *
-     * @param {Schema} schema an instance of a schema class, containing the desired information for the POST request
+     * @param tableSetName The dataverse set name for the table that you are updating a record in
+     * @param data The JSON of the fields and data that are to be updated on the targeted record
      * @returns a Promise resolving the successful results *[record id]* of the POST request, or rejecting the failed results *[error]* of the POST request.
      */
-    createRecord(schema: Schema): Promise<string>;
+    static createRecord(tableSetName: string, data: JSON): Promise<string>;
     /**
      *
      * @param tableSetName The DataVerse SET name of the table being queried
@@ -12,14 +20,14 @@ declare const API: {
      * @param selectColumns *OPTIONAL* if desired, enter your own custom OData query for advanced GET results. Format = select=column1,column2,column3...
      * @returns a Promise resolving the successful results of the GET request, or rejecting the failed results of the GET request
      */
-    getRecord(tableSetName: string, recordID: string, selectColumns?: string): Promise<object>;
+    static getRecord<T>(tableSetName: string, recordID: string, selectColumns?: string): Promise<T>;
     /**
      *
      * @param tableSetName The dataverse set name of the table being queried
      * @param queryParameters *OPTIONAL* the OData query parameters for refining search results: *format = $filter=filters&$select=columns*
      * @returns a Promise resolving the successful results of the GET request, or rejecting the failed results of the GET request
      */
-    getMultiple(tableSetName: string, queryParameters?: string): Promise<Array<object>>;
+    static getMultiple(tableSetName: string, queryParameters?: string): Promise<Array<object>>;
     /**
      *
      * @param tableSetName The dataverse set name for the table that you are updating a record in
@@ -27,6 +35,6 @@ declare const API: {
      * @param data The JSON of the fields and data that are to be updated on the targeted record
      * @returns A Promise with the results of the API execution
      */
-    updateRecord(tableSetName: string, recordId: string, data: object): Promise<any>;
-};
+    static updateRecord(tableSetName: string, recordId: string, data: object): Promise<any>;
+}
 export default API;

package/dist/src/core/DOMNodeReference.d.ts

@@ -0,0 +1,227 @@
+/// <reference path="../globals.d.ts" />
+import * as s from "../constants/symbols.d.ts";
+export default class DOMNodeReference {
+    target: Element | string;
+    logicalName?: string;
+    root: Element;
+    protected [s.debounceTime]: number;
+    protected isLoaded: boolean;
+    protected defaultDisplay: string;
+    protected [s.observers]: Array<MutationObserver>;
+    protected [s.boundEventListeners]: Array<BoundEventListener>;
+    protected isRadio: boolean;
+    protected radioType: RadioType | null;
+    /**
+     * The value of the element that this node represents
+     * stays in syncs with the live DOM elements?.,m  via event handler
+     */
+    value: any;
+    /**
+     * The element targeted when instantiating DOMNodeReference.
+     * Made available in order to perform normal DOM traversal,
+     * or access properties not available through this class.
+     */
+    element: HTMLElement;
+    protected visibilityController: HTMLElement;
+    checked: boolean;
+    /**
+     * Represents the 'yes' option of a boolean radio field.
+     * This property is only available when the parent node
+     * is a main field for a boolean radio input.
+     */
+    yesRadio: DOMNodeReference | null;
+    /**
+     * Represents the 'no' option of a boolean radio field.
+     * This property is only available when the parent node
+     * is a main field for a boolean radio input.
+     */
+    noRadio: DOMNodeReference | null;
+    /**
+     * Creates an instance of DOMNodeReference.
+     * @param target - The CSS selector to find the desired DOM element.
+     * @param root - Optionally specify the element within to search for the element targeted by 'target'
+     * Defaults to 'document.body'
+     */
+    /******/ /******/ constructor(target: Element | string, root: Element | undefined, debounceTime: number);
+    private extractLogicalName;
+    [s.init](): Promise<void>;
+    /**
+     * Initializes value synchronization with appropriate event listeners
+     * based on element type.
+     */
+    protected [s.valueSync](): void;
+    private determineEventType;
+    private isDateInput;
+    protected [s.isValidFormElement](element: Element): element is FormElement;
+    protected [s.registerEventListener](element: Element, eventType: keyof HTMLElementEventMap, handler: (e: Event) => unknown): void;
+    protected [s.dateSync](element: HTMLInputElement): Promise<void>;
+    /**
+     * Gets the current value of the element based on its type
+     * @protected
+     * @returns Object containing value and optional checked state
+     */
+    protected [s.getElementValue](): ElementValue;
+    protected [s.attachVisibilityController](): void;
+    protected [s.attachRadioButtons](): Promise<void>;
+    protected [s.bindMethods](): void;
+    protected [s.destroy](): void;
+    /**
+     * Updates the value and checked state based on element type
+     * @public
+     */
+    updateValue(e?: Event): void;
+    protected validateValue(value: any): any;
+    /**
+     * Sets up an event listener based on the specified event type, executing the specified
+     * event handler
+     * @param eventType - The DOM event to watch for
+     * @param eventHandler - The callback function that runs when the
+     * specified event occurs.
+     * @returns - Instance of this [provides option to method chain]
+     */
+    on(eventType: keyof HTMLElementEventMap, eventHandler: (e: Event) => void): DOMNodeReference;
+    /**
+     * Hides the element by setting its display style to "none".
+     * @returns - Instance of this [provides option to method chain]
+     */
+    hide(): DOMNodeReference;
+    /**
+     * Shows the element by restoring its default display style.
+     * @returns - Instance of this [provides option to method chain]
+     */
+    show(): DOMNodeReference;
+    /**
+     * @param shouldShow - Either a function that returns true or false,
+     * or a natural boolean to determine the visibility of this
+     * @returns - Instance of this [provides option to method chain]
+     */
+    toggleVisibility(shouldShow: ((instance: DOMNodeReference) => boolean) | boolean): DOMNodeReference;
+    /**
+     * Sets the value of the HTML element.
+     * @param value - The value to set for the HTML element.
+     * for parents of boolean radios, pass true or false as value, or
+     * an expression returning a boolean
+     * @returns - Instance of this [provides option to method chain]
+     */
+    setValue(value: (() => any) | any): DOMNodeReference;
+    /**
+     * Disables the element so that users cannot input any data
+     * @returns - Instance of this [provides option to method chain]
+     */
+    disable(): DOMNodeReference;
+    /**
+     * Clears all values and states of the element.
+     * Handles different input types appropriately, and can be called
+     * on an element containing N child inputs to clear all
+     *
+     * @returns - Instance of this [provides option to method chain]
+     * @throws If clearing values fails
+     */
+    clearValue(): Promise<DOMNodeReference>;
+    /**
+     * Enables the element so that users can input data
+     * @returns - Instance of this [provides option to method chain]
+     */
+    enable(): DOMNodeReference;
+    /**
+     * @param elements - The elements to prepend to the element targeted by this.
+     * @returns - Instance of this [provides option to method chain]
+     */
+    prepend(...elements: HTMLElement[]): DOMNodeReference;
+    /**
+     * Appends child elements to the HTML element.
+     * @param elements - The elements to append to the element targeted by this.
+     * @returns - Instance of this [provides option to method chain]
+     */
+    append(...elements: HTMLElement[]): DOMNodeReference;
+    /**
+     * Inserts elements before the HTML element.
+     * @param elements - The elements to insert before the HTML element.
+     * @returns - Instance of this [provides option to method chain]
+     */
+    before(...elements: HTMLElement[]): DOMNodeReference;
+    /**
+     * Inserts elements after the HTML element.
+     * @param elements - The elements to insert after the HTML element.
+     * @returns - Instance of this [provides option to method chain]
+     */
+    after(...elements: HTMLElement[]): DOMNodeReference;
+    /**
+     * Retrieves the label associated with the HTML element.
+     * @returns {HTMLElement} The label element associated with this element.
+     */
+    getLabel(): HTMLElement | null;
+    /**
+     * Adds a tooltip with specified text to the label associated with the HTML element.
+     * @param innerHTML - The innerHTML to append into the tooltip.
+     * @param containerStyle - Optional object with CSS Styles to apply to the info element
+     * @returns - Instance of this [provides option to method chain]
+     */
+    addLabelTooltip(innerHTML: string, containerStyle?: Partial<CSSStyleDeclaration>): DOMNodeReference;
+    /**
+     * Adds a tooltip with the specified text to the element
+     * @param innerHTML - The innerHTML to append into the tooltip
+     * @param containerStyle - Optional object with CSS Styles to apply to the info element
+     * @returns - Instance of this [provides option to method chain]
+     */
+    addTooltip(innerHTML: string, containerStyle?: Partial<CSSStyleDeclaration>): DOMNodeReference;
+    /**
+     * Sets the inner HTML content of the HTML element.
+     * @param {string} string - The text to set as the inner HTML of the element.
+     * @returns - Instance of this [provides option to method chain]
+     */
+    setInnerHTML(string: string): this;
+    /**
+     * Removes this element from the DOM
+     * @returns - Instance of this [provides option to method chain]
+     */
+    remove(): this;
+    /**
+     * @param options and object containing the styles you want to set : {key: value} e.g.: {'display': 'block'}
+     * @returns - Instance of this [provides option to method chain]
+     */
+    setStyle(options: Partial<CSSStyleDeclaration>): this;
+    /**
+     * Unchecks both the yes and no radio buttons if they exist.
+     * @returns - Instance of this [provides option to method chain]
+     */
+    uncheckRadios(): DOMNodeReference;
+    /**
+     * Applies a business rule to manage visibility, required state, value, and disabled state dynamically.
+     * @see {@link BusinessRule}
+     * @param rule The business rule containing conditions for various actions.
+     * @param dependencies For re-evaluation conditions when the state of the dependencies change
+     * @returns Instance of this for method chaining.
+     */
+    applyBusinessRule(rule: BusinessRule, dependencies: DOMNodeReference[]): DOMNodeReference;
+    /**
+     * Sets up tracking for dependencies using both event listeners and mutation observers.
+     * @protected
+     * @param handler The function to execute when dependencies change
+     * @param dependencies Array of dependent DOM nodes to track
+     * @param options Additional configuration options. clearValuesOnHide defaults to false.
+     * all other options defaults to true
+     */
+    protected _configDependencyTracking(handler: () => void, dependencies: Array<DOMNodeReference>, options?: {
+        clearValuesOnHide?: boolean;
+        observeVisibility?: boolean;
+        trackInputEvents?: boolean;
+        trackRadioButtons?: boolean;
+    }): void;
+    /**
+     * Sets the required level for the field by adding or removing the "required-field" class on the label.
+     *
+     * @param isRequired Determines whether the field should be marked as required.
+     * If true, the "required-field" class is added to the label; if false, it is removed.
+     * @returns Instance of this [provides option to method chain]
+     */
+    setRequiredLevel(isRequired: (() => boolean) | boolean): DOMNodeReference;
+    /**
+     * Executes a callback function once the element is fully loaded.
+     * If the element is already loaded, the callback is called immediately.
+     * Otherwise, a MutationObserver is used to detect when the element is added to the DOM.
+     * @param callback A callback function to execute once the element is loaded.
+     * Receives instance of 'this' as an argument
+     */
+    onceLoaded(callback: (instance: DOMNodeReference) => any): any;
+}

package/dist/src/core/DOMNodeReferenceArray.d.ts

@@ -0,0 +1,12 @@
+/// <reference path="../globals.d.ts" />
+import type DOMNodeReference from "./DOMNodeReference.d.ts";
+export default class DOMNodeReferenceArray extends Array<DOMNodeReference> {
+    /**
+     * Hides all the containers of the DOMNodeReference instances in the array.
+     */
+    hideAll(this: DOMNodeReferenceArray): DOMNodeReferenceArray;
+    /**
+     * Shows all the containers of the DOMNodeReference instances in the array.
+     */
+    showAll(this: DOMNodeReferenceArray): DOMNodeReferenceArray;
+}

package/dist/src/core/List.d.ts

@@ -0,0 +1,13 @@
+/// <reference path="../globals.d.ts" />
+export default class List {
+    private static _instance;
+    private _root;
+    private _listItems;
+    private _observer;
+    private constructor();
+    static get(): List;
+    private _observe;
+    private _update;
+    private _destroy;
+    destroy(): void;
+}

package/dist/src/core/bindForm.d.ts

@@ -0,0 +1,28 @@
+/// <reference path="../globals.d.ts" />
+import type DOMNodeReference from "./DOMNodeReference.d.ts";
+import type DOMNodeReferenceArray from "./DOMNodeReferenceArray.d.ts";
+/**
+ * When loading into a page in PowerPages that has a form,
+ * you can use this function by passing in the GUID of the form, and you will receive an array/record
+ * of {@link DOMNodeReference}s that represent all fields, sections, sub-grids, and tabs of the given form.
+ * Access these properties of the {@link BoundForm} using the logical name of the control you need to access: form['logical_name']
+ * you can then execute all the methods available from DOMNodeReference
+ * @param formId - The string GUID of the form you want to bind to
+ * @returns An array of DOMNodeReferences, accessible as properties of a Record<string, DOMNodeReference> i.e. formProp = form["some_logicalName"]
+ * @example
+ * ```js
+ * bindForm("form-guid-0000").then((form) => {
+ *    //...use the form
+ *    const field = form["field_logical_name"]
+ *    // or
+ *    form["other_logical_name"].someMethod()
+ * })
+ *
+ * // or
+ *
+ * const form = await bindForm("form-guid-0000")
+ * ```
+ *  @see {@link BoundForm}
+ *  @see {@link DOMNodeReference}
+ */
+export default function bindForm(formId: string): Promise<DOMNodeReferenceArray & Record<string, DOMNodeReference>>;

package/dist/src/core/createDOMNodeReferences.d.ts

@@ -0,0 +1,88 @@
+/// <reference path="../globals.d.ts" />
+import DOMNodeReference from "./DOMNodeReference.d.ts";
+import type DOMNodeReferenceArray from "./DOMNodeReferenceArray.d.ts";
+/**
+ * Creates and initializes a DOMNodeReference instance.
+ * @see {@link CreationOptions}
+ * @param  **target** - The selector, using `querySelector` syntax, for the desired DOM element. Or, the `HTMLElement` itself for which to create a DOMNodeReference.
+ * @param **options** - Options for advanced retrieval of elements
+ * @param **options.multiple** - Should this call return an array of instantiated references, or just a single? Defaults to false, returning a single instance
+ * @param **options.root** - Optionally specify the element within to search for the element targeted by 'target'. Defaults to `document.body`
+ * @param **options.timeoutMs** - Optionally specify the amount of time that should be waited to find the targeted element before throwing error - useful for async DOM loading. Relies on MutationObserver.  ***WARNING***: Implementing multiple references with timeout can result in infinite loading.
+ * @returns  A promise that resolves to a Proxy of the initialized DOMNodeReference instance.
+ *
+ * @see {@link DOMNodeReference}
+ * @see {@link DOMNodeReferenceArray}
+ * @see {@link enhanceArray}
+ */
+export default function createDOMNodeReference(target: string | HTMLElement, options?: {
+    /**
+     * Should this call return an array of instantiated references, or just a single?
+     * Defaults to false, returning a single instance.
+     */
+    multiple?: (() => boolean) | boolean;
+    /**
+     * Optionally specify the element within which to search for the element targeted by 'target'.
+     * Defaults to 'document.body'.
+     */
+    root?: HTMLElement;
+    /**
+     * Optionally specify the amount of time that should be waited to find the targeted element before throwing an error.
+     * Useful for async DOM loading. Relies on MutationObserver.
+     * WARNING: Implementing multiple references with timeout can result in infinite loading.
+     */
+    timeoutMs?: number;
+}): Promise<DOMNodeReference>;
+export default function createDOMNodeReference(target: string, options?: {
+    /**
+     * Should this call return an array of instantiated references, or just a single?
+     * Defaults to false, returning a single instance.
+     */
+    multiple?: false;
+    /**
+     * Optionally specify the element within which to search for the element targeted by 'target'.
+     * Defaults to 'document.body'.
+     */
+    root?: HTMLElement;
+    /**
+     * Optionally specify the amount of time that should be waited to find the targeted element before throwing an error.
+     * Useful for async DOM loading. Relies on MutationObserver.
+     * WARNING: Implementing multiple references with timeout can result in infinite loading.
+     */
+    timeoutMs?: number;
+}): Promise<DOMNodeReference>;
+export default function createDOMNodeReference(target: Element, options?: {
+    /**
+     * Optionally specify the element within which to search for the element targeted by 'target'.
+     * Defaults to 'document.body'.
+     */
+    root?: HTMLElement;
+    /**
+     * Optionally specify the amount of time that should be waited to find the targeted element before throwing an error.
+     * Useful for async DOM loading. Relies on MutationObserver.
+     * WARNING: Implementing multiple references with timeout can result in infinite loading.
+     */
+    timeoutMs?: number;
+}): Promise<DOMNodeReference>;
+export default function createDOMNodeReference(target: string, options?: {
+    /**
+     * Should this call return an array of instantiated references, or just a single?
+     * Defaults to false, returning a single instance.
+     */
+    multiple?: true;
+    /**
+     * Optionally specify the element within which to search for the element targeted by 'target'.
+     * Defaults to 'document.body'.
+     */
+    root?: HTMLElement;
+    /**
+     * Optionally specify the amount of time that should be waited to find the targeted element before throwing an error.
+     * Useful for async DOM loading. Relies on MutationObserver.
+     * WARNING: Implementing multiple references with timeout can result in infinite loading.
+     */
+    timeoutMs?: number;
+}): Promise<DOMNodeReferenceArray>;
+export declare function validateOptions(options: Partial<CreationOptions>): void;
+export declare function createProxyHandler(): {
+    get: (target: DOMNodeReference, prop: string | symbol) => any;
+};

package/dist/src/core/waitFor.d.ts

@@ -0,0 +1,9 @@
+/// <reference path="../globals.d.ts" />
+/**
+ * Provides an async way to capture DOM elements; for when querySelector cannot capture the target due to async DOM content loading
+ * @param **target** - basic querySelector syntax to select an element
+ * @param **root** - optional parameter to replace document as the root from which to perform the node search
+ * @returns the element(s) targeted by the `querySelector` string
+ */
+export default function waitFor(target: string, root: Element | Document, multiple: false, debounceTime: number): Promise<HTMLElement>;
+export default function waitFor(target: string, root: Element | Document, multiple: true, debounceTime: number): Promise<HTMLElement[]>;

package/dist/{errors.d.ts → src/errors/errors.d.ts}

@@ -1,4 +1,5 @@
-import DOMNodeReference from "./DOMNodeReference.js";
+/// <reference path="../globals.d.ts" />
+import type DOMNodeReference from "../core/DOMNodeReference.d.ts";
 export declare class DOMNodeInitializationError extends Error {
     constructor(instance: DOMNodeReference, error: string);
 }
@@ -8,3 +9,6 @@ export declare class DOMNodeNotFoundError extends Error {
 export declare class ConditionalRenderingError extends Error {
     constructor(instance: DOMNodeReference, error: string);
 }
+export declare class ValidationConfigError extends Error {
+    constructor(node: DOMNodeReference, message: string);
+}

package/dist/src/globals.d.ts

@@ -0,0 +1,152 @@
+/// <reference path="../core/DOMNodeReference.ts"/>
+
+declare type EventCallback = () => any;
+
+declare interface CreationOptions {
+  /**
+   * Should this call return an array of instantiated references, or just a single?
+   * Defaults to false, returning a single instance.
+   */
+  multiple?: (() => boolean) | boolean;
+
+  /**
+   * Optionally specify the element within which to search for the element targeted by 'target'.
+   * Defaults to 'document.body'.
+   */
+  root?: HTMLElement;
+
+  /**
+   * Optionally specify the amount of time that should be waited to find the targeted element before throwing an error.
+   * Useful for async DOM loading. Relies on MutationObserver.
+   * WARNING: Implementing multiple references with timeout can result in infinite loading.
+   */
+  timeoutMs?: number;
+}
+
+declare interface SystemForm extends Object {
+  "@odata.context": string;
+  "@odata.etag": string;
+  "overwritetime@OData.Community.Display.V1.FormattedValue": string;
+  overwritetime: Date;
+  "isdesktopenabled@OData.Community.Display.V1.FormattedValue": string;
+  isdesktopenabled: boolean;
+  "publishedon@OData.Community.Display.V1.FormattedValue": Date;
+  publishedon: Date;
+  "_organizationid_value@OData.Community.Display.V1.FormattedValue": string;
+  "_organizationid_value@Microsoft.Dynamics.CRM.associatednavigationproperty": string;
+  "_organizationid_value@Microsoft.Dynamics.CRM.lookuplogicalname": string;
+  _organizationid_value: string;
+  formxml: string;
+  introducedversion: string;
+  "isairmerged@OData.Community.Display.V1.FormattedValue": string;
+  isairmerged: boolean;
+  "istabletenabled@OData.Community.Display.V1.FormattedValue": string;
+  istabletenabled: boolean;
+  solutionid: string;
+  formidunique: string;
+  "ismanaged@OData.Community.Display.V1.FormattedValue": string;
+  ismanaged: boolean;
+  "isdefault@OData.Community.Display.V1.FormattedValue": string;
+  isdefault: boolean;
+  "objecttypecode@OData.Community.Display.V1.FormattedValue": string;
+  objecttypecode: string;
+  "type@OData.Community.Display.V1.FormattedValue": string;
+  type: number;
+  "componentstate@OData.Community.Display.V1.FormattedValue": string;
+  componentstate: number;
+  "formpresentation@OData.Community.Display.V1.FormattedValue": string;
+  formpresentation: number;
+  "formactivationstate@OData.Community.Display.V1.FormattedValue": string;
+  formactivationstate: number;
+  name: string;
+  "versionnumber@OData.Community.Display.V1.FormattedValue": string;
+  versionnumber: number;
+  formjson: string;
+  description: string;
+  formid: string;
+}
+
+declare interface Form extends Partial<SystemForm> {
+  formxml: string;
+}
+
+declare interface BusinessRule {
+  /**
+   * @param condition A function that returns a boolean to determine
+   * the visibility of the target element. If `condition()` returns true, the element is shown;
+   * otherwise, it is hidden.
+   
+   * @param clearValuesOnHide Should the values in the targeted field be cleared when hidden? Defaults to true
+   */
+  setVisibility?: [
+    condition: (this: DOMNodeReference) => boolean,
+    clearValuesOnHide?: boolean
+  ];
+  /**
+   * @param isRequired Function determining if field is required
+   * @param isValid Function validating field input.
+   */
+  setRequired?: [
+    isRequired: () => boolean,
+    isValid: (this: DOMNodeReference, isRequired: boolean) => boolean
+  ];
+  /**
+   * @param condition A function to determine if the value provided should be applied to this field
+   * @param value The value to set for the HTML element.
+   * for parents of boolean radios, pass true or false as value, or
+   * an expression returning a boolean
+   */
+  setValue?: [
+    condition: (this: DOMNodeReference) => boolean,
+    value: (() => any) | any
+  ];
+  /**
+   * @param condition A function to determine if this field
+   * should be enabled in a form, or disabled. True || 1 = disabled. False || 0 = enabled
+   */
+  setDisabled?: () => boolean;
+}
+
+declare interface CreationOptions {
+  /**
+   * Should this call return an array of instantiated references, or just a single?
+   * Defaults to false, returning a single instance.
+   */
+  multiple?: (() => boolean) | boolean;
+
+  /**
+   * Optionally specify the element within which to search for the element targeted by 'target'.
+   * Defaults to 'document.body'.
+   */
+  root?: HTMLElement;
+
+  /**
+   * Optionally specify the amount of time that should be waited to find the targeted element before throwing an error.
+   * Useful for async DOM loading. Relies on MutationObserver.
+   * WARNING: Implementing multiple references with timeout can result in infinite loading.
+   */
+  timeoutMs?: number;
+}
+
+declare const Page_Validators: any[];
+
+declare interface ElementValue {
+  value: any;
+  checked?: boolean;
+}
+
+declare type RadioType = "truthy" | "falsy";
+
+declare interface BoundEventListener {
+  element: Element;
+  event: keyof HTMLElementEventMap;
+  handler: (e: Event) => unknown;
+}
+
+declare type FormElement =
+  | HTMLInputElement
+  | HTMLSelectElement
+  | HTMLTextAreaElement
+  | HTMLSpanElement
+  | HTMLButtonElement
+  | HTMLFieldSetElement;

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+import API from "./core/API.d.ts";
+import createRef from "./core/createDOMNodeReferences.d.ts";
+import waitFor from "./core/waitFor.d.ts";
+import bindForm from "./core/bindForm.d.ts";
+export { API, bindForm, createRef, waitFor };