@es-joy/jsoe 0.3.0 → 0.4.0

package/dist/src/formats.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @param {"indexedDBKey"|"json"|"structuredCloning"} format
+ * @param {StructuredCloneValue} record
+ * @param {import('./types.js').StateObject} stateObj
+ */
+export function getControlsForFormatAndValue(format: "indexedDBKey" | "json" | "structuredCloning", record: StructuredCloneValue, stateObj: import('./types.js').StateObject): Promise<Element>;
+export default Formats;
+declare namespace Formats {
+    namespace availableFormats {
+        export { indexedDBKey };
+        export { json };
+        export { structuredCloning };
+    }
+}
+import * as indexedDBKey from './formats/indexedDBKey.js';
+import * as json from './formats/json.js';
+import * as structuredCloning from './formats/structuredCloning.js';
+//# sourceMappingURL=formats.d.ts.map

package/dist/src/formats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formats.d.ts","sourceRoot":"","sources":["../../src/formats.js"],"names":[],"mappings":"AA2BA;;;;GAIG;AACH,qDAJW,cAAc,GAAC,MAAM,GAAC,mBAAmB,0CAEzC,OAAO,YAAY,EAAE,WAAW,oBAQ1C;;;;;;;;;8BAtC6B,2BAA2B;sBACnC,mBAAmB;mCACN,gCAAgC"}

package/dist/src/fundamentalTypes/BooleanObjectType.d.ts

@@ -0,0 +1,6 @@
+export default BooleanObjectType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const BooleanObjectType: import('../types.js').TypeObject;
+//# sourceMappingURL=BooleanObjectType.d.ts.map

package/dist/src/fundamentalTypes/BooleanObjectType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BooleanObjectType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/BooleanObjectType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,iCAFU,OAAO,aAAa,EAAE,UAAU,CAiDxC"}

package/dist/src/fundamentalTypes/NumberObjectType.d.ts

@@ -0,0 +1,6 @@
+export default NumberObjectType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const NumberObjectType: import('../types.js').TypeObject;
+//# sourceMappingURL=NumberObjectType.d.ts.map

package/dist/src/fundamentalTypes/NumberObjectType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NumberObjectType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/NumberObjectType.js"],"names":[],"mappings":";AAGA;;GAEG;AACH,gCAFU,OAAO,aAAa,EAAE,UAAU,CAkCxC"}

package/dist/src/fundamentalTypes/StringObjectType.d.ts

@@ -0,0 +1,6 @@
+export default StringObjectType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const StringObjectType: import('../types.js').TypeObject;
+//# sourceMappingURL=StringObjectType.d.ts.map

package/dist/src/fundamentalTypes/StringObjectType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringObjectType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/StringObjectType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,gCAFU,OAAO,aAAa,EAAE,UAAU,CA+BxC"}

package/dist/src/fundamentalTypes/arrayReferenceType.d.ts

@@ -0,0 +1,6 @@
+export default arrayReferenceType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const arrayReferenceType: import('../types.js').TypeObject;
+//# sourceMappingURL=arrayReferenceType.d.ts.map

package/dist/src/fundamentalTypes/arrayReferenceType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayReferenceType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/arrayReferenceType.js"],"names":[],"mappings":";AAMA;;GAEG;AACH,kCAFU,OAAO,aAAa,EAAE,UAAU,CAiMxC"}

package/dist/src/fundamentalTypes/arrayType.d.ts

@@ -0,0 +1,6 @@
+export default arrayType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const arrayType: import('../types.js').TypeObject;
+//# sourceMappingURL=arrayType.d.ts.map

package/dist/src/fundamentalTypes/arrayType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/arrayType.js"],"names":[],"mappings":";AASA;;GAEG;AACH,yBAFU,OAAO,aAAa,EAAE,UAAU,CAq3BxC"}

package/dist/src/fundamentalTypes/bigintType.d.ts

@@ -0,0 +1,6 @@
+export default bigintType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const bigintType: import('../types.js').TypeObject;
+//# sourceMappingURL=bigintType.d.ts.map

package/dist/src/fundamentalTypes/bigintType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigintType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/bigintType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,0BAFU,OAAO,aAAa,EAAE,UAAU,CA+CxC"}

package/dist/src/fundamentalTypes/dateType.d.ts

@@ -0,0 +1,6 @@
+export default dateType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const dateType: import('../types.js').TypeObject;
+//# sourceMappingURL=dateType.d.ts.map

package/dist/src/fundamentalTypes/dateType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/dateType.js"],"names":[],"mappings":";AAIA;;GAEG;AACH,wBAFU,OAAO,aAAa,EAAE,UAAU,CAyHxC"}

package/dist/src/fundamentalTypes/nullType.d.ts

@@ -0,0 +1,6 @@
+export default nullType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const nullType: import('../types.js').TypeObject;
+//# sourceMappingURL=nullType.d.ts.map

package/dist/src/fundamentalTypes/nullType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/nullType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,wBAFU,OAAO,aAAa,EAAE,UAAU,CA2BxC"}

package/dist/src/fundamentalTypes/numberType.d.ts

@@ -0,0 +1,6 @@
+export default numberType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const numberType: import('../types.js').TypeObject;
+//# sourceMappingURL=numberType.d.ts.map

package/dist/src/fundamentalTypes/numberType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numberType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/numberType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,0BAFU,OAAO,aAAa,EAAE,UAAU,CAkDxC"}

package/dist/src/fundamentalTypes/objectReferenceType.d.ts

@@ -0,0 +1,6 @@
+export default objectReferenceType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const objectReferenceType: import('../types.js').TypeObject;
+//# sourceMappingURL=objectReferenceType.d.ts.map

package/dist/src/fundamentalTypes/objectReferenceType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectReferenceType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/objectReferenceType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,mCAFU,OAAO,aAAa,EAAE,UAAU,CA6CxC"}

package/dist/src/fundamentalTypes/objectType.d.ts

@@ -0,0 +1,6 @@
+export default objectType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const objectType: import('../types.js').TypeObject;
+//# sourceMappingURL=objectType.d.ts.map

package/dist/src/fundamentalTypes/objectType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/objectType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,0BAFU,OAAO,aAAa,EAAE,UAAU,CAwBxC"}

package/dist/src/fundamentalTypes/regexpType.d.ts

@@ -0,0 +1,6 @@
+export default regexpType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const regexpType: import('../types.js').TypeObject;
+//# sourceMappingURL=regexpType.d.ts.map

package/dist/src/fundamentalTypes/regexpType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regexpType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/regexpType.js"],"names":[],"mappings":";AAIA;;GAEG;AACH,0BAFU,OAAO,aAAa,EAAE,UAAU,CAuFxC"}

package/dist/src/fundamentalTypes/sparseUndefinedType.d.ts

@@ -0,0 +1,6 @@
+export default sparseUndefinedType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const sparseUndefinedType: import('../types.js').TypeObject;
+//# sourceMappingURL=sparseUndefinedType.d.ts.map

package/dist/src/fundamentalTypes/sparseUndefinedType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparseUndefinedType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/sparseUndefinedType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,mCAFU,OAAO,aAAa,EAAE,UAAU,CAqCxC"}

package/dist/src/fundamentalTypes/stringType.d.ts

@@ -0,0 +1,6 @@
+export default stringType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const stringType: import('../types.js').TypeObject;
+//# sourceMappingURL=stringType.d.ts.map

package/dist/src/fundamentalTypes/stringType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/stringType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,0BAFU,OAAO,aAAa,EAAE,UAAU,CAyBxC"}

package/dist/src/fundamentalTypes/undefinedType.d.ts

@@ -0,0 +1,6 @@
+export default undefinedType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const undefinedType: import('../types.js').TypeObject;
+//# sourceMappingURL=undefinedType.d.ts.map

package/dist/src/fundamentalTypes/undefinedType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"undefinedType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/undefinedType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,6BAFU,OAAO,aAAa,EAAE,UAAU,CA+BxC"}

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export { default as Types } from "./types.js";
+export { buildTypeChoices as typeChoices } from "./typeChoices.js";
+export { default as Formats, getControlsForFormatAndValue } from "./formats.js";
+export { formatAndTypeChoices, getFormatAndSchemaChoices } from "./formatAndTypeChoices.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":""}

package/dist/src/subTypes/blobHTMLType.d.ts

@@ -0,0 +1,26 @@
+export default blobHTMLType;
+declare namespace blobHTMLType {
+    const option: string[];
+    const stringRegex: RegExp;
+    function valueMatch(v: any): boolean;
+    const superType: string;
+    function toValue(s: any): {
+        value: Blob;
+    };
+    function getInput({ root }: {
+        root: any;
+    }): Element | null;
+    function getValue(): Blob;
+    function loadBlob(value: any): Promise<any>;
+    function setValue({ value }: {
+        value: any;
+    }): Promise<void>;
+    function viewUI({ value }: {
+        value: any;
+    }): import("../../vendor/jamilih/dist/jml-es.js").JamilihReturn[];
+    function editUI({ typeNamespace, value }: {
+        typeNamespace: any;
+        value: any;
+    }): import("../../vendor/jamilih/dist/jml-es.js").JamilihReturn[];
+}
+//# sourceMappingURL=blobHTMLType.d.ts.map

package/dist/src/subTypes/blobHTMLType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobHTMLType.d.ts","sourceRoot":"","sources":["../../../src/subTypes/blobHTMLType.js"],"names":[],"mappings":";;;;IAWc,qCAA6B;;IAEzC;;MA4BC;IAED;;uBAEC;IACD,0BAKC;IACD,4CAgBC;IACD;;sBAIC;IACD;;sEAgCC;IACD;;;sEAiDC"}

package/dist/src/subTypes/falseType.d.ts

@@ -0,0 +1,6 @@
+export default falseType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const falseType: import('../types.js').TypeObject;
+//# sourceMappingURL=falseType.d.ts.map

package/dist/src/subTypes/falseType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"falseType.d.ts","sourceRoot":"","sources":["../../../src/subTypes/falseType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,yBAFU,OAAO,aAAa,EAAE,UAAU,CAoCxC"}

package/dist/src/subTypes/trueType.d.ts

@@ -0,0 +1,6 @@
+export default trueType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const trueType: import('../types.js').TypeObject;
+//# sourceMappingURL=trueType.d.ts.map

package/dist/src/subTypes/trueType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trueType.d.ts","sourceRoot":"","sources":["../../../src/subTypes/trueType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,wBAFU,OAAO,aAAa,EAAE,UAAU,CAoCxC"}

package/dist/src/superTypes/SpecialNumberSuperType.d.ts

@@ -0,0 +1,11 @@
+export default SpecialNumberSuperType;
+export type SuperTypeObject = TypeObject;
+/**
+ * @typedef {TypeObject} SuperTypeObject
+ * @property {string[]} childTypes
+ */
+/**
+ * @type {SuperTypeObject}
+ */
+declare const SpecialNumberSuperType: TypeObject;
+//# sourceMappingURL=SpecialNumberSuperType.d.ts.map

package/dist/src/superTypes/SpecialNumberSuperType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpecialNumberSuperType.d.ts","sourceRoot":"","sources":["../../../src/superTypes/SpecialNumberSuperType.js"],"names":[],"mappings":";;AAEA;;;GAGG;AAEH;;GAEG;AACH,iDAwDE"}

package/dist/src/superTypes/SpecialRealNumberSuperType.d.ts

@@ -0,0 +1,6 @@
+export default SpecialRealNumberSuperType;
+/**
+ * @type {SuperTypeObject}
+ */
+declare const SpecialRealNumberSuperType: SuperTypeObject;
+//# sourceMappingURL=SpecialRealNumberSuperType.d.ts.map

package/dist/src/superTypes/SpecialRealNumberSuperType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpecialRealNumberSuperType.d.ts","sourceRoot":"","sources":["../../../src/superTypes/SpecialRealNumberSuperType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,0DAgDE"}

package/dist/src/typeChoices.d.ts

@@ -0,0 +1,30 @@
+/**
+ * An arbitrary Structured Clone, JSON, etc. value.
+ * @typedef {any} StructuredCloneValue
+ */
+/**
+ * @callback BuildTypeChoices
+ * @param {object} cfg
+ * @param {string} cfg.format
+ * @param {string} cfg.typeNamespace
+ * @param {StructuredCloneValue} cfg.value
+ * @param {boolean} [cfg.setValue=false]
+ * @param {string} cfg.state
+ * @param {string} cfg.keySelectClass
+ * @param {boolean} cfg.requireObject
+ * @param {boolean} cfg.objectHasValue
+ * @param {RootElement} cfg.topRoot Always a `div` element?
+ * @param {string} cfg.schema Schema name
+ * @param {string} cfg.schemaContent Schema contents
+ * @returns {[select: Element, typeContainer: Element]}
+ */
+/**
+ * @type {BuildTypeChoices}
+ */
+export const buildTypeChoices: BuildTypeChoices;
+/**
+ * An arbitrary Structured Clone, JSON, etc. value.
+ */
+export type StructuredCloneValue = any;
+export type BuildTypeChoices = (cfg: object, format: string, typeNamespace: string, value: StructuredCloneValue, setValue?: boolean | undefined, state: string, keySelectClass: string, requireObject: boolean, objectHasValue: boolean, topRoot: RootElement, schema: string, schemaContent: string) => [select: Element, typeContainer: Element];
+//# sourceMappingURL=typeChoices.d.ts.map

package/dist/src/typeChoices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeChoices.d.ts","sourceRoot":"","sources":["../../src/typeChoices.js"],"names":[],"mappings":"AAOA;;;GAGG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH;;GAEG;AACH,+BAFU,gBAAgB,CA0NxB;;;;mCA/OW,GAAG;qCAKL,MAAM,UACN,MAAM,iBACN,MAAM,SACN,oBAAoB,yCAEpB,MAAM,kBACN,MAAM,iBACN,OAAO,kBACP,OAAO,gCAEP,MAAM,iBACN,MAAM,KACJ,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC"}

package/dist/src/types.d.ts

@@ -0,0 +1,333 @@
+export function getPropertyValueFromLegend(legend: HTMLLegendElement): string;
+export default Types;
+export type TypeObject = {
+    /**
+     * Creates the option
+     * HTML. May set an option `title` or `value`
+     */
+    option: import('jamilih').JamilihArray;
+    /**
+     * Private context variable. Whether or not
+     * it is an array. Do not use in other types.
+     */
+    array?: boolean | undefined;
+    /**
+     * Used for string parsing.
+     */
+    regexEndings?: string[] | undefined;
+    /**
+     * Used for string parsing. If not
+     * present, use `stringRegexBegin` and `stringRegexEnd`
+     */
+    stringRegex?: RegExp | undefined;
+    /**
+     * Used for string parsing. If not
+     * present, use `stringRegex`
+     */
+    stringRegexBegin?: RegExp | undefined;
+    /**
+     * Used for string parsing. If not
+     * present, use `stringRegex`
+     */
+    stringRegexEnd?: RegExp | undefined;
+    /**
+     * Function to
+     * check whether this subtype matches
+     */
+    valueMatch?: ((ArbitraryValue: any) => boolean) | undefined;
+    /**
+     * The greater fundamental type to which
+     * the type belongs
+     */
+    superType?: string | undefined;
+    /**
+     * Converts from
+     * string to value. May use `stringRegex` to find components.
+     */
+    toValue: (s: string) => ArbitraryValue;
+    /**
+     * Gets the value for the type
+     */
+    getValue: (info: {
+        root?: HTMLDivElement;
+    }) => ArbitraryValue;
+    /**
+     * Should set
+     * the value of the form's `getInput` element
+     */
+    setValue?: ((info: {
+        root?: HTMLDivElement;
+    }) => void) | undefined;
+    viewUI: (info: {
+        value?: ArbitraryValue;
+        typeNamespace?: string;
+        type?: string;
+        topRoot?: HTMLDivElement;
+        resultType?: "keys" | "values" | "both";
+        format?: string;
+    }) => JamilihArray;
+    editUI: (info: {
+        value?: ArbitraryValue;
+        typeNamespace?: string;
+    }) => JamilihArray;
+    /**
+     * Gets the
+     * form control (with `value`)
+     */
+    getInput: (info: {
+        root: HTMLDivElement;
+    }) => HTMLInputElement | HTMLTextareaElement | HTMLSelectElement;
+    /**
+     * Gets the reference. For array and object
+     * references types only
+     */
+    resolveReference?: ((path: string, value: ArbitraryValue) => ArbitraryValue) | undefined;
+    /**
+     * Message will be used if validity is false.
+     */
+    validate?: ((info: {
+        root: HTMLDivElement;
+        topRoot?: HTMLDivElement;
+    }) => {
+        message: string;
+        valid: boolean;
+    }) | undefined;
+    /**
+     * For
+     * validation of array and object references only.
+     */
+    validateAll?: ((info: {
+        topRoot: HTMLDivElement;
+    }) => void) | undefined;
+    /**
+     * The type after which it should be placed and its
+     * context types
+     */
+    stateDependent?: {
+        structuredCloning: {
+            after: string;
+            contexts: string[];
+        };
+    } | undefined;
+};
+export type GetPossibleSchemasForPathAndType = (keypath: string, parentPath: string, arrayOrObjectPropertyName: string, valueType: string) => StateObject;
+export type StateObject = {
+    typeNamespace: string;
+    "readonly": boolean;
+    format: string;
+    error: Error;
+    rootUI: Element;
+    schemaContent: string;
+    getPossibleSchemasForPathAndType: GetPossibleSchemasForPathAndType;
+};
+/**
+ * Any other possibilities than `div`?
+ */
+export type RootElement = HTMLDivElement;
+declare namespace Types {
+    namespace availableTypes {
+        namespace ValidDate {
+            const valid: boolean;
+        }
+        namespace arrayNonindexKeys {
+            const sparse: boolean;
+        }
+    }
+    /**
+     * Utility to retrieve the type out of a type root element.
+     * @public
+     * @param {?RootElement} root
+     * @returns {string|undefined} Why would it not exist?
+     */
+    function getTypeForRoot(root: HTMLDivElement | null): string | undefined;
+    /**
+     * @typedef {(
+     *     keypath: string,
+    *     parentPath: string,
+    *     arrayOrObjectPropertyName: string,
+    *     valueType: string
+    *   ) => StateObject} GetPossibleSchemasForPathAndType
+     */
+    /**
+     * @typedef {{
+     *   typeNamespace: string,
+     *   "readonly": boolean,
+     *   format: string,
+     *   error: Error,
+     *   rootUI: Element,
+     *   schemaContent: string,
+     *   getPossibleSchemasForPathAndType: GetPossibleSchemasForPathAndType
+     * }} 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): StructuredCloneValue;
+    /**
+     * Utility to get the form control (e.g., input element) for a root.
+     * @public
+     * @param {RootElement} root
+     * @returns {null|HTMLInputElement}
+     */
+    function getFormControlForRoot(root: HTMLDivElement): HTMLInputElement | 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): StructuredCloneValue;
+    /**
+     * @public
+     * @param {string|Element} selOrEl
+     * @returns {null|HTMLInputElement}
+     */
+    function getFormControlFromRootAncestor(selOrEl: string | Element): HTMLInputElement | null;
+    /**
+     * @param {string} format
+     * @param {string} state
+     * @returns {string[]}
+     */
+    function getTypesForFormatAndState(format: string, state: string): string[];
+    /**
+     * @public
+     * @param {string} type
+     * @returns {JamilihArray}
+     */
+    function getOptionForType(type: string): JamilihArray;
+    /**
+     * @public
+     * @param {string} format
+     * @param {string} parserState
+     * @returns {JamilihArray[]}
+     */
+    function getTypeOptionsForFormatAndState(format: string, parserState: string): JamilihArray[];
+    /**
+     * @public
+     * @param {object} cfg
+     * @param {boolean} cfg."readonly"
+     * @param {"both"|"keys"|"values"} cfg.resultType
+     * @param {string} cfg.typeNamespace
+     * @param {string} cfg.type
+     * @param {RootElement} cfg.topRoot
+     * @param {boolean} cfg.bringIntoFocus
+     * @param {BuildTypeChoices} cfg.buildTypeChoices
+     * @param {string} cfg.format
+     * @param {string} cfg.schemaContent
+     * @param {GetPossibleSchemasForPathAndType} cfg.schemaState Not currently
+     *   in use
+     * @param {StructuredCloneValue} cfg.value
+     * @param {boolean} cfg.hasValue
+     * @returns {Element}
+     */
+    function getUIForModeAndType({ readonly, resultType, typeNamespace, type, topRoot, bringIntoFocus, buildTypeChoices, format, schemaContent, schemaState, value, hasValue }: {
+        "": boolean;
+        resultType: "keys" | "values" | "both";
+        typeNamespace: string;
+        type: string;
+        topRoot: HTMLDivElement;
+        bringIntoFocus: boolean;
+        buildTypeChoices: BuildTypeChoices;
+        format: string;
+        schemaContent: string;
+        schemaState: GetPossibleSchemasForPathAndType;
+        value: StructuredCloneValue;
+        hasValue: boolean;
+    }): Element;
+    const contexts: {};
+    /**
+     * @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;
+        keySelectClass: string;
+    }): 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;
+    /**
+     * @public
+     * @param {object} cfg
+     * @param {string} cfg.type
+     * @param {RootElement} cfg.root
+     * @param {RootElement} cfg.topRoot
+     * @returns {boolean}
+     */
+    function validate({ type, root, topRoot }: {
+        type: string;
+        root: HTMLDivElement;
+        topRoot: HTMLDivElement;
+    }): boolean;
+    /**
+     * @param {object} cfg
+     * @param {string} cfg.type
+     * @param {RootElement} cfg.root
+     * @param {StructuredCloneValue} cfg.value
+     * @returns {void}
+     */
+    function setValue({ type, root, value }: {
+        type: string;
+        root: HTMLDivElement;
+        value: StructuredCloneValue;
+    }): void;
+    /**
+     * @public
+     * @param {string} s
+     * @param {object} cfg
+     * @param {string} cfg.format
+     * @param {string} cfg.state
+     * @param {TypeObject[]} [cfg.endMatchTypeObjs=[]]
+     * @param {boolean} [cfg.firstRun=true]
+     * @param {
+     *   [
+     *     type: string,
+     *     parent: array|object,
+     *     parentPath: string,
+     *     path: string
+     *   ]
+     * } [cfg.rootHolder=[]]
+     * @param {ArbitraryArray|ArbitraryObject} cfg.parent
+     * @param {string} cfg.parentPath
+     * @returns {{
+     *   value: ArbitraryValue,
+     *   remnant: string,
+     *   beginOnly: boolean,
+     *   assign: boolean
+     * }}
+     */
+    function getValueForString(s: string, { format, state, endMatchTypeObjs, firstRun, rootHolder, parent, parentPath }: {
+        format: string;
+        state: string;
+        endMatchTypeObjs?: TypeObject[] | undefined;
+        firstRun?: boolean | undefined;
+    }): {
+        value: ArbitraryValue;
+        remnant: string;
+        beginOnly: boolean;
+        assign: boolean;
+    };
+}
+//# sourceMappingURL=types.d.ts.map