@es-joy/jsoe 0.4.3 → 0.4.5

package/dist/types.d.ts

@@ -1,5 +1,86 @@
 export function getPropertyValueFromLegend(legend: HTMLLegendElement): string;
 export default Types;
+/**
+ * Utility to retrieve the type out of a type root element.
+ */
+export type GetTypeForRoot = (root: RootElement | null) => string | undefined | null;
+/**
+ * Utility to get the value out of a type root element with a given
+ *   state and path.
+ */
+export type GetValueForRoot = (root: RootElement, stateObj?: StateObject | undefined, currentPath?: string | undefined) => StructuredCloneValue;
+/**
+ * Utility to get the form control (e.g., input element) for a root.
+ */
+export type GetFormControlForRoot = (root: RootElement) => null | HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLButtonElement;
+/**
+ * Utility to get the value for a root using its ancestor and state.
+ */
+export type GetValueFromRootAncestor = (selOrEl: string | Element, stateObj: StateObject) => StructuredCloneValue;
+export type GetFormControlFromRootAncestor = (selOrEl: string | Element) => null | HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLButtonElement;
+export type GetTypesForFormatAndState = (format: string, state?: string | undefined) => AvailableType[] | undefined;
+export type GetOptionForType = (type: AvailableType) => [string, {
+    value: AvailableType;
+    title?: string;
+}];
+export type GetTypeOptionsForFormatAndState = (format: string, parserState?: string | undefined) => [string, {
+    value: AvailableType;
+    title?: string;
+}][];
+export type GetUIForModeAndType = (cfg: {
+    readonly?: boolean;
+    resultType?: "both" | "keys" | "values";
+    typeNamespace?: string;
+    type: AvailableType;
+    topRoot?: RootElement;
+    bringIntoFocus?: boolean | undefined;
+    buildTypeChoices?: import('./typeChoices.js').BuildTypeChoices;
+    format: import('./formats.js').AvailableFormat;
+    schemaContent?: object;
+    schemaState?: GetPossibleSchemasForPathAndType;
+    value: StructuredCloneValue;
+    hasValue: boolean;
+    replaced?: StructuredCloneValue;
+}) => Element;
+export type ValidValuesSet = (cfg: {
+    form: HTMLFormElement;
+    typeNamespace?: string;
+    keySelectClass?: string;
+}) => boolean;
+export type ValidateAllReferences = (cfg: {
+    topRoot: RootElement;
+}) => void;
+export type Validate = (cfg: {
+    type: AvailableType;
+    root: RootElement;
+    topRoot?: RootElement;
+}) => boolean;
+export type SetValue = (cfg: {
+    type: AvailableType;
+    root: RootElement;
+    value: StructuredCloneValue;
+}) => void;
+export type GetValueForString = (s: string, cfg: {
+    format: import('./formats.js').AvailableFormat;
+    state: string;
+    endMatchTypeObjs?: TypeObject[] | undefined;
+    firstRun?: boolean | undefined;
+    rootHolder?: [type: string, parent: {
+        [key: string]: any;
+    }, parentPath: string | number, path: string][] | undefined;
+    parent: {
+        [key: string]: any;
+    };
+    parentPath: string | number;
+}) => [
+    value: StructuredCloneValue,
+    remnant: string,
+    beginOnly: boolean,
+    assign: boolean
+];
+export type CustomValidateAllReferences = (info: {
+    topRoot: HTMLDivElement;
+}) => void;
 export type StructuredCloneValue = import('./formats.js').StructuredCloneValue;
 export type JamilihArray = import('jamilih').JamilihArray;
 export type RootInfo = {
@@ -164,244 +245,388 @@ export type StateObject = {
  * Any other possibilities than `div`?
  */
 export type RootElement = HTMLDivElement;
-declare namespace Types {
-    namespace availableTypes {
-        export { nullType as null };
-        export { trueType as true };
-        export { falseType as false };
-        export { numberType as number };
-        export { bigintType as bigint };
-        export { stringType as string };
-        export { arrayReferenceType as arrayReference };
-        export { objectReferenceType as objectReference };
-        export { arrayType as array };
-        export { objectType as object };
-        export { dateType as date };
-        export const userObject: string[];
-        export { undefinedType as undef };
-        export { SpecialRealNumberSuperType as SpecialRealNumber };
-        export { SpecialNumberSuperType as SpecialNumber };
-        export { regexpType as regexp };
-        export { BooleanObjectType as BooleanObject };
-        export { NumberObjectType as NumberObject };
-        export { StringObjectType as StringObject };
-        export namespace map {
-            const option: string[];
-        }
-        export namespace set {
-            const option_1: string[];
-            export { option_1 as option };
-        }
-        export namespace file {
-            const option_2: string[];
-            export { option_2 as option };
-        }
-        export namespace filelist {
-            const option_3: string[];
-            export { option_3 as option };
-        }
-        export { blobHTMLType as blobHTML };
-        export namespace arraybuffer {
-            const option_4: string[];
-            export { option_4 as option };
-        }
-        export namespace arraybufferview {
-            const option_5: string[];
-            export { option_5 as option };
-        }
-        export namespace dataview {
-            const option_6: string[];
-            export { option_6 as option };
-        }
-        export namespace imagedata {
-            const option_7: string[];
-            export { option_7 as option };
-        }
-        export namespace imagebitmap {
-            const option_8: string[];
-            export { option_8 as option };
-        }
-        export namespace int8array {
-            const option_9: string[];
-            export { option_9 as option };
-        }
-        export namespace uint8array {
-            const option_10: string[];
-            export { option_10 as option };
-        }
-        export namespace uint8clampedarray {
-            const option_11: string[];
-            export { option_11 as option };
-        }
-        export namespace int16array {
-            const option_12: string[];
-            export { option_12 as option };
-        }
-        export namespace uint16array {
-            const option_13: string[];
-            export { option_13 as option };
-        }
-        export namespace int32array {
-            const option_14: string[];
-            export { option_14 as option };
-        }
-        export namespace uint32array {
-            const option_15: string[];
-            export { option_15 as option };
-        }
-        export namespace float32array {
-            const option_16: string[];
-            export { option_16 as option };
-        }
-        export namespace float64array {
-            const option_17: string[];
-            export { option_17 as option };
-        }
-        export namespace IntlCollator {
-            const option_18: string[];
-            export { option_18 as option };
-        }
-        export namespace IntlDateTimeFormat {
-            const option_19: string[];
-            export { option_19 as option };
-        }
-        export namespace IntlNumberFormat {
-            const option_20: string[];
-            export { option_20 as option };
-        }
-        export { sparseUndefinedType as sparseUndefined };
-        export namespace ValidDate {
-            const valid: boolean;
-        }
-        export namespace arrayNonindexKeys {
-            const sparse: boolean;
-        }
-    }
-    /**
-     * Utility to retrieve the type out of a type root element.
-     * @public
-     * @param {?RootElement} root
-     * @returns {string|undefined|null} Why would it not exist?
-     */
-    function getTypeForRoot(root: HTMLDivElement | null): string | null | undefined;
-    /**
-     * @typedef {(
-     *     keypath: string,
-    *     parentPath: string,
-    *     arrayOrObjectPropertyName: string,
-    *     valueType: string
-    *   ) => StateObject} GetPossibleSchemasForPathAndType
-     */
-    /**
-     * @typedef {{
-     *   typeNamespace?: string,
-     *   "readonly"?: boolean,
-     *   format?: import('./formats.js').AvailableFormat,
-     *   error?: Error,
-     *   rootUI?: Element,
-     *   schema?: string,
-     *   schemaContent?: object,
-     *   getPossibleSchemasForPathAndType?: GetPossibleSchemasForPathAndType,
-     *   paths?: {[currentPath: string]: {
-     *     referentPath: string,
-     *     expectArrayReferent: boolean
-     *   }},
-     *   handlingReference?: boolean
-     * }} StateObject
-     */
-    /**
-     * Utility to get the value out of a type root element with a given
-     *   state and path.
-     * @public
-     * @param {RootElement} root
-     * @param {StateObject} stateObj
-     * @param {string} [currentPath]
-     * @returns {StructuredCloneValue}
-     */
-    function getValueForRoot(root: HTMLDivElement, stateObj: StateObject, currentPath?: string | undefined): any;
-    /**
-     * Utility to get the form control (e.g., input element) for a root.
-     * @public
-     * @param {RootElement} root
-     * @returns {null|
-     *   HTMLInputElement|HTMLTextAreaElement|HTMLSelectElement|HTMLButtonElement}
-     */
-    function getFormControlForRoot(root: HTMLDivElement): HTMLInputElement | HTMLButtonElement | HTMLSelectElement | HTMLTextAreaElement | null;
-    /**
-     * Utility to get the value for a root using its ancestor and state.
-     * @public
-     * @param {string|Element} selOrEl
-     * @param {StateObject} stateObj
-     * @returns {StructuredCloneValue}
-     */
-    function getValueFromRootAncestor(selOrEl: string | Element, stateObj: StateObject): any;
-    /**
-     * @public
-     * @param {string|Element} selOrEl
-     * @returns {null|HTMLInputElement|HTMLTextAreaElement|HTMLSelectElement|
-     *   HTMLButtonElement}
-     */
-    function getFormControlFromRootAncestor(selOrEl: string | Element): HTMLInputElement | HTMLButtonElement | HTMLSelectElement | HTMLTextAreaElement | null;
-    /**
-     * @param {string} format
-     * @param {string} [state]
-     * @returns {AvailableType[]|undefined}
-     */
-    function getTypesForFormatAndState(format: string, state?: string | undefined): AvailableType[] | undefined;
-    /**
-     * @public
-     * @param {AvailableType} type
-     * @returns {[string, {value: AvailableType, title?: string}]}
-     */
-    function getOptionForType(type: AvailableType): [string, {
-        value: AvailableType;
-        title?: string | undefined;
-    }];
-    /**
-     * @public
-     * @param {string} format
-     * @param {string} [parserState]
-     * @returns {[string, {value: AvailableType, title?: string}][]}
-     */
-    function getTypeOptionsForFormatAndState(format: string, parserState?: string | undefined): [string, {
-        value: AvailableType;
-        title?: string | undefined;
-    }][];
-    /**
-     * @public
-     * @param {object} cfg
-     * @param {boolean} [cfg.readonly]
-     * @param {"both"|"keys"|"values"} [cfg.resultType]
-     * @param {string} [cfg.typeNamespace]
-     * @param {AvailableType} cfg.type
-     * @param {RootElement} [cfg.topRoot]
-     * @param {boolean|undefined} cfg.bringIntoFocus
-     * @param {import('./typeChoices.js').BuildTypeChoices} [cfg.buildTypeChoices]
-     * @param {import('./formats.js').AvailableFormat} cfg.format
-     * @param {object} [cfg.schemaContent]
-     * @param {GetPossibleSchemasForPathAndType} [cfg.schemaState] Not currently
-     *   in use
-     * @param {StructuredCloneValue} cfg.value
-     * @param {boolean} cfg.hasValue
-     * @param {StructuredCloneValue} [cfg.replaced]
-     * @returns {Element}
-     */
-    function getUIForModeAndType({ readonly, resultType, typeNamespace, type, topRoot, bringIntoFocus, buildTypeChoices, format, schemaContent, schemaState, value, hasValue, replaced }: {
-        readonly?: boolean | undefined;
-        resultType?: "keys" | "values" | "both" | undefined;
-        typeNamespace?: string | undefined;
-        type: AvailableType;
-        topRoot?: HTMLDivElement | undefined;
-        bringIntoFocus: boolean | undefined;
-        buildTypeChoices?: import("./typeChoices.js").BuildTypeChoices | undefined;
-        format: import("./formats.js").AvailableFormat;
-        schemaContent?: object | undefined;
-        schemaState?: GetPossibleSchemasForPathAndType | undefined;
-        value: any;
-        hasValue: boolean;
-        replaced?: any;
-    }): Element;
-    const contexts: {
+/**
+ * Utility to retrieve the type out of a type root element.
+ * @callback GetTypeForRoot
+ * @param {?RootElement} root
+ * @returns {string|undefined|null} Why would it not exist?
+ */
+/**
+ * Utility to get the value out of a type root element with a given
+ *   state and path.
+ * @callback GetValueForRoot
+ * @param {RootElement} root
+ * @param {StateObject} [stateObj]
+ * @param {string} [currentPath]
+ * @returns {StructuredCloneValue}
+ */
+/**
+ * Utility to get the form control (e.g., input element) for a root.
+ * @callback GetFormControlForRoot
+ * @param {RootElement} root
+ * @returns {null|
+ *   HTMLInputElement|HTMLTextAreaElement|HTMLSelectElement|HTMLButtonElement}
+ */
+/**
+ * Utility to get the value for a root using its ancestor and state.
+ * @callback GetValueFromRootAncestor
+ * @param {string|Element} selOrEl
+ * @param {StateObject} stateObj
+ * @returns {StructuredCloneValue}
+ */
+/**
+ * @callback GetFormControlFromRootAncestor
+ * @param {string|Element} selOrEl
+ * @returns {null|HTMLInputElement|HTMLTextAreaElement|HTMLSelectElement|
+ *   HTMLButtonElement}
+ */
+/**
+ * @callback GetTypesForFormatAndState
+ * @param {string} format
+ * @param {string} [state]
+ * @returns {AvailableType[]|undefined}
+ */
+/**
+ * @callback GetOptionForType
+ * @param {AvailableType} type
+ * @returns {[string, {value: AvailableType, title?: string}]}
+ */
+/**
+ * @callback GetTypeOptionsForFormatAndState
+ * @param {string} format
+ * @param {string} [parserState]
+ * @returns {[string, {value: AvailableType, title?: string}][]}
+ */
+/**
+ * @typedef {(cfg: {
+ *   readonly?: boolean,
+ *   resultType?: "both"|"keys"|"values",
+ *   typeNamespace?: string,
+ *   type: AvailableType,
+ *   topRoot?: RootElement,
+ *   bringIntoFocus?: boolean|undefined,
+ *   buildTypeChoices?: import('./typeChoices.js').BuildTypeChoices,
+ *   format: import('./formats.js').AvailableFormat,
+ *   schemaContent?: object
+ *   schemaState?: GetPossibleSchemasForPathAndType,
+ *   value: StructuredCloneValue,
+ *   hasValue: boolean,
+ *   replaced?: StructuredCloneValue,
+ * }) => Element} GetUIForModeAndType
+ */
+/**
+ * @typedef {(cfg: {
+ *   form: HTMLFormElement,
+ *   typeNamespace?: string,
+ *   keySelectClass?: string,
+ * }) => boolean} ValidValuesSet
+ */
+/**
+ * @typedef {(cfg: {
+ *   topRoot: RootElement
+ * }) => void} ValidateAllReferences
+ */
+/**
+ * @typedef {(cfg: {
+ *   type: AvailableType,
+ *   root: RootElement,
+ *   topRoot?: RootElement
+ * }) => boolean} Validate
+ */
+/**
+ * @typedef {(cfg: {
+ *   type: AvailableType,
+ *   root: RootElement,
+ *   value: StructuredCloneValue,
+ * }) => void} SetValue
+ */
+/**
+ * @typedef {(s: string, cfg: {
+ *   format: import('./formats.js').AvailableFormat,
+ *   state: string,
+ *   endMatchTypeObjs?: TypeObject[]
+ *   firstRun?: boolean,
+ *   rootHolder?: [
+ *     type: string,
+ *     parent: {[key: string]: any},
+ *     parentPath: string|number,
+ *     path: string
+ *   ][],
+ *   parent: {[key: string]: any},
+ *   parentPath: string|number
+ * }) => [
+*   value: StructuredCloneValue,
+*   remnant: string,
+*   beginOnly: boolean,
+*   assign: boolean
+* ]} GetValueForString
+*/
+/**
+ * @typedef {(
+ *   info: {topRoot: HTMLDivElement}
+ * ) => void} CustomValidateAllReferences
+ */
+/**
+ * @type {{
+ *   availableTypes: {
+ *     [key in AvailableType]: Partial<TypeObject>|string[]|
+ *       {valid: true}|{sparse: true}
+ *   },
+ *   getTypeForRoot: GetTypeForRoot,
+ *   getValueForRoot: GetValueForRoot,
+ *   getFormControlForRoot: GetFormControlForRoot,
+ *   getValueFromRootAncestor: GetValueFromRootAncestor,
+ *   getFormControlFromRootAncestor: GetFormControlFromRootAncestor,
+ *   getTypesForFormatAndState: GetTypesForFormatAndState,
+ *   getOptionForType: GetOptionForType,
+ *   getTypeOptionsForFormatAndState: GetTypeOptionsForFormatAndState,
+ *   getUIForModeAndType: GetUIForModeAndType,
+ *   contexts: {
+ *     [key: string]: {
+ *       [key: string]: {type: AvailableType, after: AvailableType}[]
+ *     }
+ *   },
+ *   validValuesSet: ValidValuesSet,
+ *   validateAllReferences: ValidateAllReferences,
+ *   validate: Validate,
+ *   setValue: SetValue,
+ *   getValueForString: GetValueForString,
+ *   customValidateAllReferences?: CustomValidateAllReferences
+ * }}
+ */
+declare const Types: {
+    availableTypes: {
+        string: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        number: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        bigint: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        object: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        map: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        set: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        file: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        arraybuffer: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        false: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        date: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        null: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        regexp: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        array: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        true: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        arrayReference: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        objectReference: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        userObject: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        undef: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        SpecialRealNumber: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        SpecialNumber: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        BooleanObject: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        NumberObject: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        StringObject: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        filelist: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        blobHTML: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        arraybufferview: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        dataview: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        imagedata: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        imagebitmap: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        int8array: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        uint8array: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        uint8clampedarray: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        int16array: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        uint16array: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        int32array: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        uint32array: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        float32array: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        float64array: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        IntlCollator: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        IntlDateTimeFormat: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        IntlNumberFormat: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        sparseUndefined: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        ValidDate: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+        arrayNonindexKeys: string[] | Partial<TypeObject> | {
+            valid: true;
+        } | {
+            sparse: true;
+        };
+    };
+    getTypeForRoot: GetTypeForRoot;
+    getValueForRoot: GetValueForRoot;
+    getFormControlForRoot: GetFormControlForRoot;
+    getValueFromRootAncestor: GetValueFromRootAncestor;
+    getFormControlFromRootAncestor: GetFormControlFromRootAncestor;
+    getTypesForFormatAndState: GetTypesForFormatAndState;
+    getOptionForType: GetOptionForType;
+    getTypeOptionsForFormatAndState: GetTypeOptionsForFormatAndState;
+    getUIForModeAndType: GetUIForModeAndType;
+    contexts: {
         [key: string]: {
             [key: string]: {
                 type: AvailableType;
@@ -409,115 +634,11 @@ declare namespace Types {
             }[];
         };
     };
-    /**
-     * @public
-     * @param {object} cfg
-     * @param {HTMLFormElement} cfg.form
-     * @param {string} [cfg.typeNamespace]
-     * @param {string} [cfg.keySelectClass]
-     * @returns {boolean}
-     */
-    function validValuesSet({ form, typeNamespace, keySelectClass }: {
-        form: HTMLFormElement;
-        typeNamespace?: string | undefined;
-        keySelectClass?: string | undefined;
-    }): boolean;
-    /**
-     * Any other possibilities than `div`?
-     * @typedef {HTMLDivElement} RootElement
-     */
-    /**
-     * @public
-     * @param {object} cfg
-     * @param {RootElement} cfg.topRoot
-     * @returns {void}
-     */
-    function validateAllReferences({ topRoot }: {
-        topRoot: HTMLDivElement;
-    }): void;
-    const customValidateAllReferences: ((info: {
-        topRoot: HTMLDivElement;
-    }) => void) | null;
-    /**
-     * @public
-     * @param {object} cfg
-     * @param {AvailableType} cfg.type
-     * @param {RootElement} cfg.root
-     * @param {RootElement} [cfg.topRoot]
-     * @returns {boolean}
-     */
-    function validate({ type, root, topRoot }: {
-        type: AvailableType;
-        root: HTMLDivElement;
-        topRoot?: HTMLDivElement | undefined;
-    }): boolean;
-    /**
-     * @param {object} cfg
-     * @param {AvailableType} cfg.type
-     * @param {RootElement} cfg.root
-     * @param {StructuredCloneValue} cfg.value
-     * @returns {void}
-     */
-    function setValue({ type, root, value }: {
-        type: AvailableType;
-        root: HTMLDivElement;
-        value: any;
-    }): void;
-    /**
-     * @public
-     * @param {string} s
-     * @param {object} cfg
-     * @param {import('./formats.js').AvailableFormat} cfg.format
-     * @param {string} cfg.state
-     * @param {TypeObject[]} [cfg.endMatchTypeObjs=[]]
-     * @param {boolean} [cfg.firstRun=true]
-     * @param {[
-     *   type: string,
-     *   parent: {[key: string]: any},
-     *   parentPath: string|number,
-     *   path: string
-     * ][]} [cfg.rootHolder=[]]
-     * @param {{[key: string]: any}} cfg.parent
-     * @param {string|number} cfg.parentPath
-     * @returns {[
-     *   value: StructuredCloneValue,
-     *   remnant: string,
-     *   beginOnly: boolean,
-     *   assign: boolean
-     * ]}
-     */
-    function getValueForString(s: string, { format, state, endMatchTypeObjs, firstRun, rootHolder, parent, parentPath }: {
-        format: import("./formats.js").AvailableFormat;
-        state: string;
-        endMatchTypeObjs?: TypeObject[] | undefined;
-        firstRun?: boolean | undefined;
-        rootHolder?: [type: string, parent: {
-            [key: string]: any;
-        }, parentPath: string | number, path: string][] | undefined;
-        parent: {
-            [key: string]: any;
-        };
-        parentPath: string | number;
-    }): [value: any, remnant: string, beginOnly: boolean, assign: boolean];
-}
-import nullType from './fundamentalTypes/nullType.js';
-import trueType from './subTypes/trueType.js';
-import falseType from './subTypes/falseType.js';
-import numberType from './fundamentalTypes/numberType.js';
-import bigintType from './fundamentalTypes/bigintType.js';
-import stringType from './fundamentalTypes/stringType.js';
-import arrayReferenceType from './fundamentalTypes/arrayReferenceType.js';
-import objectReferenceType from './fundamentalTypes/objectReferenceType.js';
-import arrayType from './fundamentalTypes/arrayType.js';
-import objectType from './fundamentalTypes/objectType.js';
-import dateType from './fundamentalTypes/dateType.js';
-import undefinedType from './fundamentalTypes/undefinedType.js';
-import SpecialRealNumberSuperType from './superTypes/SpecialRealNumberSuperType.js';
-import SpecialNumberSuperType from './superTypes/SpecialNumberSuperType.js';
-import regexpType from './fundamentalTypes/regexpType.js';
-import BooleanObjectType from './fundamentalTypes/BooleanObjectType.js';
-import NumberObjectType from './fundamentalTypes/NumberObjectType.js';
-import StringObjectType from './fundamentalTypes/StringObjectType.js';
-import blobHTMLType from './subTypes/blobHTMLType.js';
-import sparseUndefinedType from './fundamentalTypes/sparseUndefinedType.js';
+    validValuesSet: ValidValuesSet;
+    validateAllReferences: ValidateAllReferences;
+    validate: Validate;
+    setValue: SetValue;
+    getValueForString: GetValueForString;
+    customValidateAllReferences?: CustomValidateAllReferences | undefined;
+};
 //# sourceMappingURL=types.d.ts.map