url-safe-bitpacking 0.2.1 → 0.3.1

package/dist/parsers/arrayParser.d.ts

@@ -1,4 +1,5 @@
-import { ArrayDataEntry } from '@/types';
-export declare const rawParser: (bitString: string, arrayData: ArrayDataEntry) => [ArrayDataEntry, string];
-export declare const rawStateStringifier: (arrayData: ArrayDataEntry) => string;
+import { ArrayDataEntry } from '../types';
+export declare const rawParser: (arrayData: ArrayDataEntry, bitString: string) => [ArrayDataEntry, string];
+export declare const rawStateStringifier: (state: ArrayDataEntry["state"], minCount: ArrayDataEntry["minCount"], stateBits: ArrayDataEntry["stateBits"]) => string;
 export declare const rawStringifier: (arrayData: ArrayDataEntry) => string;
+export declare const getContentBitsCountForValue: (arrayData: ArrayDataEntry["value"]) => number;

package/dist/parsers/enumArrayParser.d.ts

@@ -1,4 +1,6 @@
 import { EnumArrayData } from '../types/enumArrayData';
 export declare const getBitsCount: (enumArrayData: EnumArrayData, bitString: string) => number;
-export declare const rawParser: (bitString: string, enumArrayData: EnumArrayData) => number[];
+export declare const getContentBitsCountForValue: (value: number[], enumArrayData: EnumArrayData) => number;
+export declare const rawParser: (enumArrayData: EnumArrayData, bitString: string) => [EnumArrayData, string];
+export declare const rawStateStringifier: (value: number[], minCount: EnumArrayData["minCount"], stateBits: EnumArrayData["stateBits"]) => string;
 export declare const rawStringifier: (value: number[], enumArrayData: EnumArrayData) => string;

package/dist/parsers/enumOptionsParser.d.ts

@@ -0,0 +1,5 @@
+import { EnumOptionsDataEntry } from '../types';
+export declare const rawParser: (enumOptionsData: EnumOptionsDataEntry, bitString: string) => [EnumOptionsDataEntry, string];
+export declare const rawStateStringifier: (state: EnumOptionsDataEntry["state"], stateBits: EnumOptionsDataEntry["stateBits"]) => string;
+export declare const rawStringifier: (enumOptionsData: EnumOptionsDataEntry) => string;
+export declare const getContentBitsCountForValue: (enumOptionsValue: EnumOptionsDataEntry["value"]) => number;

package/dist/parsers/index.d.ts

@@ -1 +1,2 @@
 export * from './parsers';
+export * from './parserUtils';

package/dist/parsers/intParser.d.ts

@@ -3,10 +3,8 @@ export declare const getBitsCount: (intData: IntData) => number;
 /**
  * Method that parses a state bitstring into a raw positive int
  * @param stateString - `string` 0 | 1
- * @param bitCount - `number` amount of bits to consider
- * @returns number
+ * @param intData - `IntData` that represents the int data entry to parse
+ * @returns `number` that represents the parsed value
  */
-export declare const rawValueParser: (stateString: string, bitCount: number) => number;
 export declare const rawParser: (stateString: string, intData: IntData) => number;
-export declare const rawIntStringifier: (value: number, bitCount: number) => string;
 export declare const rawStringifier: (value: number, intData: IntData) => string;

package/dist/parsers/objectParser.d.ts

@@ -0,0 +1,4 @@
+import { ObjectDataEntry } from '../types';
+export declare const rawParser: (objectData: ObjectDataEntry, bitString: string) => [ObjectDataEntry, string];
+export declare const getContentBitsCountForValue: (objectValue: ObjectDataEntry["value"]) => number;
+export declare const rawStringifier: (objectData: ObjectDataEntry) => string;

package/dist/parsers/optionalParser.d.ts

@@ -1,4 +1,5 @@
-import { OptionalDataEntry } from '@/types';
-export declare const rawParser: (bitString: string, optionalData: OptionalDataEntry) => [OptionalDataEntry, string];
-export declare const rawStateStringifier: (optionalData: OptionalDataEntry) => string;
+import { OptionalDataEntry } from '../types';
+export declare const rawParser: (optionalData: OptionalDataEntry, bitString: string) => [OptionalDataEntry, string];
+export declare const rawStateStringifier: (state: OptionalDataEntry["state"]) => string;
 export declare const rawStringifier: (optionalData: OptionalDataEntry) => string;
+export declare const getContentBitsCountForValue: (optionalData: OptionalDataEntry["value"]) => number;

package/dist/parsers/parserNestedDataUtils.d.ts

@@ -0,0 +1,14 @@
+import { DataEntry } from '../types';
+/**
+ * Helper method to get the bit count for a nested data entry
+ * @param nestedData - `DataEntry[]` that represents the nested data entry
+ * @returns
+ */
+export declare const getContentBitsCountForNestedData: (data: DataEntry[]) => number;
+export declare const nestedDataStringifier: (nestedData: DataEntry[]) => string;
+/**
+ * Method that parses a bitstring for a given nested data descriptor
+ * @param bitstring - `string` of 0 | 1
+ * @param descriptor - `DataEntry[]` that represents the framework applicable to the bitstring
+ */
+export declare const nestedDataBitstringParser: (bitstring: string, descriptor: DataEntry[]) => [DataEntry[], string];

package/dist/parsers/parserUtils.d.ts

@@ -0,0 +1,56 @@
+export declare const base64url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+/**
+ * Method that returns the bits required for a given amount of numners for a specific base
+ * @param count - `number` amount of numbers
+ * @param base - `number` max value of the numbers
+ */
+export declare const getBitsForEnumArrayCountOfBase: (count: number, base: number) => number;
+/**
+ * Method to convert an array of numbers to a bit string
+ * @param input - `number[]` the input array of numbers to convert to a bit string
+ * @param fromBase - `number` that represents the base of the input numbers
+ * @returns `string` that represents the bit string of the input numbers
+ * @returns 0 | 1 bit string
+ */
+export declare const convertArbitraryBaseToBitString: (input: number[], fromBase: number) => string;
+/**
+ * Method to convert a bit string to an array of numbers of a specific base
+ * @param input - `string` that represents the bit string to convert to an array of numbers
+ * @param toBase - `number` that represents the base of the output numbers
+ * @param expectedOutputLength - `number` that represents the expected length of the output array
+ */
+export declare const convertBitStringToArbitraryBase: (input: string, toBase: number, expectedOutputLength: number) => number[];
+/**
+ * Unused method to convert an array of numbers from an arbitrary base to an arbitrary base
+ * @param input - `number[]` the input array of numbers to convert to a bit string
+ * @param fromBase - `number` that represents the base of the input numbers
+ * @param toBase - `number` that represents the base of the output numbers
+ * @param expectedOutputLength - `number` | optional, should be given when you should find a specific amount of output numbers
+ */
+export declare const convertArbitraryBaseToArbitraryBase: (input: number[], fromBase: number, toBase: number, expectedOutputLength?: number) => number[];
+/**
+ * Method that convists a bitstring to a url safe base64 string
+ * @param bits - `string` of 0 | 1
+ * @returns `string` that represents the url safe base64 string
+ */
+export declare const parseBitsToBase64: (bits: string) => string;
+/**
+ * Method that convists a url safe base64 string to a bitstring
+ * @param base64 - `string` that represents the url safe base64 string
+ * @returns `string` of 0 | 1
+ */
+export declare const parseBase64ToBits: (base64: string) => string;
+/**
+ * Method that stringifies a raw positive int
+ * @param value - `number`
+ * @param bitCount - `number` amount of bits to consider
+ * @returns `string` of 0 | 1
+ */
+export declare const rawIntStringifier: (value: number, bitCount: number) => string;
+/**
+ * Method that parses a state bitstring into a raw positive int
+ * @param stateString - `string` 0 | 1
+ * @param bitCount - `number` amount of bits to consider
+ * @returns number
+ */
+export declare const rawValueParser: (stateString: string, bitCount: number) => number;

package/dist/parsers/parsers.d.ts

@@ -1,90 +1,24 @@
-import { DataEntry, ComplexDataEntry, NestedData } from '../types/dataEntry';
+import { HasStateBitsDataTypes, SpecifiedDataEntry } from '../enums/dataTypes';
+import { DataEntry, SimpleDataEntry } from '../types/dataEntry';
+export declare const getStateBitsCountForDataEntry: (entry: DataEntry) => number;
+export declare const getStateBitsForDataEntry: (entry: SpecifiedDataEntry<(typeof HasStateBitsDataTypes)[number]>) => string;
 /**
- * Method that parses a bitstring into a value
- * @param bitString - `string` of 0 | 1
- * @param mapData - `DataEntry` that represents the data entry to parse
- * @returns `number` | `boolean` that represents the parsed value
+ * Helper method to get the bit-width for the content of a data entry (based on current value, doesn't do any validation)
+ * @param entry - `DataEntry`
  */
-export declare const valueBitsParser: (bitString: string, mapData: DataEntry) => number | boolean | number[];
-/**
- * Method that parses a bitstring into a data entry
- * @param rawString - `string` of 0 | 1
- * @param mapData - `DataEntry` that represents the data entry to parse
- * @returns `DataEntry` that represents the parsed data entry
- */
-export declare const dataBitsParser: (rawString: string, mapData: DataEntry) => DataEntry;
+export declare const getContentBitsCountForDataEntry: (entry: DataEntry) => number;
+export declare const dataEntryBitstringParser: <T extends DataEntry>(entry: T, bitString: string) => [T, string];
 /**
  * Method that returns the amount of bits required for a given data entry
- * @param mapData - `DataEntry` that represents the data entry to get the bits count for
+ * @param data - `DataEntry` that represents the data entry to get the bits count for
  * @param bitString - `string` 0 | 1
  * @returns `number` that represents the bits count for the given data entry
  */
-export declare const getBitsCount: (mapData: DataEntry, bitString: string) => number;
+export declare const getBitsCount: (mapData: SimpleDataEntry) => number;
 /**
- * Method that parses a bitstring into a data entry and returns the remaining bitstring
- * @param bitstring - `string` of 0 | 1
- * @param dataEntry - `DataEntry` that represents the data entry to parse
- * @returns `[DataEntry, string]` that represents the data entry and the remaining bitstring
+ * Get the bitstring for a given data entry
+ * @param entry
+ * @returns `0 | 1` string that represents the bitstate for the given object
  */
-export declare const dataEntryBitstringParser: (bitstring: string, dataEntry: DataEntry) => [DataEntry, string];
-/**
- * Method that parses a bitstring for a given nested data descriptor
- * @param bitstring - `string` of 0 | 1
- * @param descriptor - `NestedData` that represents the framework applicable to the bitstring
- * @returns `[NestedData, string]` that represents the actual data and the remaining bitstring
- */
-export declare const nestedDataBitstringParser: (bitstring: string, descriptor: NestedData) => [NestedData, string];
-/**
- * Method that parses a bitstring into its data for complex data entries
- * @param bitstring - `string` of 0 | 1
- * @param complexDataEntry - `DataEntry` that represents the data entry to parse
- * @returns `[DataEntry, string]` that represents the data entry and the remaining bitstring
- */
-export declare const complexDataEntryBitstringParser: <T extends ComplexDataEntry>(bitstring: string, complexDataEntry: T) => [T, string];
-export declare const dataBitsStringifier: (data: DataEntry) => string;
-export declare const complexDataStringifier: <T extends ComplexDataEntry>(complexDataEntry: T) => string;
-export declare const complexDataStateStringifier: <T extends ComplexDataEntry>(complexDataEntry: T) => string;
-export declare const nestedDataStringifier: (nestedData: NestedData) => string;
+export declare const dataEntryBitsStringifier: (entry: DataEntry) => string;
 export declare const dataEntryCorrecting: (dataEntry: DataEntry) => DataEntry;
-export declare const base64url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-/**
- * Method that returns the bits required for a given amount of numners for a specific base
- * @param count - `number` amount of numbers
- * @param base - `number` max value of the numbers
- */
-export declare const getBitsForEnumArrayCountOfBase: (count: number, base: number) => number;
-/**
- * Method to convert an array of numbers to a bit string
- * @param input - `number[]` the input array of numbers to convert to a bit string
- * @param fromBase - `number` that represents the base of the input numbers
- * @returns `string` that represents the bit string of the input numbers
- * @returns 0 | 1 bit string
- */
-export declare const convertArbitraryBaseToBitString: (input: number[], fromBase: number) => string;
-/**
- * Method to convert a bit string to an array of numbers of a specific base
- * @param input - `string` that represents the bit string to convert to an array of numbers
- * @param toBase - `number` that represents the base of the output numbers
- * @param expectedOutputLength - `number` that represents the expected length of the output array
- */
-export declare const convertBitStringToArbitraryBase: (input: string, toBase: number, expectedOutputLength: number) => number[];
-/**
- * Unused method to convert an array of numbers from an arbitrary base to an arbitrary base
- * @param input - `number[]` the input array of numbers to convert to a bit string
- * @param fromBase - `number` that represents the base of the input numbers
- * @param toBase - `number` that represents the base of the output numbers
- * @param expectedOutputLength - `number` | optional, should be given when you should find a specific amount of output numbers
- */
-export declare const convertArbitraryBaseToArbitraryBase: (input: number[], fromBase: number, toBase: number, expectedOutputLength?: number) => number[];
-/**
- * Method that convists a bitstring to a url safe base64 string
- * @param bits - `string` of 0 | 1
- * @returns `string` that represents the url safe base64 string
- */
-export declare const parseBitsToBase64: (bits: string) => string;
-/**
- * Method that convists a url safe base64 string to a bitstring
- * @param base64 - `string` that represents the url safe base64 string
- * @returns `string` of 0 | 1
- */
-export declare const parseBase64ToBits: (base64: string) => string;

package/dist/stateHandling/index.d.ts

@@ -1 +1,2 @@
-export * from './stateDataObject';
+export * from './stateNode';
+export * from './stateData';

package/dist/stateHandling/stateData.d.ts

@@ -1,3 +1,2 @@
-import { NestedData } from '@/types';
-import { StateDataObject } from '@/types/stateDataEntry';
-export declare const getStateData: (state: NestedData) => StateDataObject;
+import { DataEntry, StateDataObjectValue } from '../types';
+export declare const getStateData: (entry: DataEntry) => StateDataObjectValue;

package/dist/stateHandling/stateNode.d.ts

@@ -0,0 +1,123 @@
+import { DataType } from '../enums';
+import { ArrayDataEntry, BooleanDataEntry, DataEntry, EnumArrayDataEntry, EnumDataEntry, EnumOptionsDataEntry, FloatDataEntry, IntDataEntry, ObjectDataEntry, OptionalDataEntry, VersionDataEntry, UpdateWithValidationTypes } from '../types';
+export declare class StateNode {
+    protected parent: StateNode | null;
+    protected root: StateNode;
+    type: DataType;
+    name: string;
+    bitstring: string;
+    constructor(entry: DataEntry, parent: StateNode | null);
+    updateUpstream: () => void;
+    getStateBits: () => string;
+    getValueBits: () => string;
+    getBitString: () => string;
+    getBase64String: () => string;
+    /**
+     * Helper method to get a string representation of the parent of this node
+     */
+    getParentString: () => string;
+    getChildren: () => (StateNode | null)[];
+    getDescription: () => string;
+    /**
+     * Helper method to get the (nested) string representaiton of all the children (and grandchildren) of this node
+     */
+    getChildrenStrings: () => string[];
+    toDataEntry: () => DataEntry;
+    /**
+     * Method to get a string representation with the tree-like view of this node and all of its children
+     */
+    toString(): string;
+}
+declare class SimpleStateNodes<T extends UpdateWithValidationTypes> extends StateNode {
+    value: T['value'];
+    descriptor: T;
+    constructor(entry: T, parent: SpecificTypeNode | null);
+    getChildren: () => SpecificTypeNode[];
+    getDescription: () => string;
+    updateValue: (value: T["value"]) => void;
+    toDataEntry: () => T;
+}
+export declare class VersionNode extends SimpleStateNodes<VersionDataEntry> {
+}
+export declare class BooleanNode extends SimpleStateNodes<BooleanDataEntry> {
+}
+export declare class EnumNode extends SimpleStateNodes<EnumDataEntry> {
+}
+export declare class IntNode extends SimpleStateNodes<IntDataEntry> {
+}
+export declare class FloatNode extends SimpleStateNodes<FloatDataEntry> {
+}
+export declare class EnumArrayNode extends SimpleStateNodes<EnumArrayDataEntry> {
+    getStateBits: () => string;
+    getDescription: () => string;
+}
+export declare class OptionalNode extends StateNode {
+    private state;
+    private stateBits;
+    private descriptor;
+    private child;
+    constructor(entry: OptionalDataEntry, parent: SpecificTypeNode | null);
+    getChildren: () => (SpecificTypeNode | null)[];
+    getStateBits: () => string;
+    getValueBits: () => string;
+    updateState: (newState: OptionalDataEntry["state"]) => void;
+    toDataEntry: () => OptionalDataEntry;
+    getDescription: () => string;
+}
+export declare class EnumOptionsNode extends StateNode {
+    private state;
+    private stateBits;
+    private descriptor;
+    private mapping;
+    private child;
+    constructor(entry: EnumOptionsDataEntry, parent: SpecificTypeNode | null);
+    getChildren: () => (SpecificTypeNode | null)[];
+    getStateBits: () => string;
+    getValueBits: () => string;
+    updateState: (newState: EnumOptionsDataEntry["state"]) => void;
+    toDataEntry: () => EnumOptionsDataEntry;
+    getDescription: () => string;
+}
+export declare class ArrayNode extends StateNode {
+    private descriptor;
+    private children;
+    private minCount;
+    private maxCount;
+    private stateBits;
+    private state;
+    constructor(entry: ArrayDataEntry, parent: SpecificTypeNode | null);
+    getChildren: () => SpecificTypeNode[];
+    getStateBits: () => string;
+    getValueBits: () => string;
+    updateState: (newState: ArrayDataEntry["state"]) => void;
+    toDataEntry: () => ArrayDataEntry;
+    getDescription: () => string;
+}
+export declare class ObjectNode extends StateNode {
+    private descriptor;
+    private children;
+    constructor(entry: ObjectDataEntry, parent: SpecificTypeNode | null);
+    getChildren: () => SpecificTypeNode[];
+    getStateBits: () => string;
+    getValueBits: () => string;
+    toDataEntry: () => ObjectDataEntry;
+}
+export type StateNodeTypeMap = {
+    VERSION: VersionNode;
+    BOOLEAN: BooleanNode;
+    ENUM: EnumNode;
+    INT: IntNode;
+    FLOAT: FloatNode;
+    ENUM_ARRAY: EnumArrayNode;
+    OPTIONAL: OptionalNode;
+    ENUM_OPTIONS: EnumOptionsNode;
+    ARRAY: ArrayNode;
+    OBJECT: ObjectNode;
+};
+export type SpecificTypeNode = StateNodeTypeMap[keyof StateNodeTypeMap];
+export declare const NodeFactory: <T extends DataType>(entry: DataEntry & {
+    type: T;
+}, parent: SpecificTypeNode | null) => StateNodeTypeMap[T];
+export declare const GetStateNodeTree: (entries: [VersionDataEntry, ...DataEntry[]], name?: string) => ObjectNode;
+export declare const FromState: (stateDescriptor: [VersionDataEntry, ...DataEntry[]], name: string, base64String: string) => ObjectNode;
+export {};

package/dist/typeFactory/dataEntryTyping.d.ts

@@ -1,6 +1,6 @@
 import { DataEntry } from '../types';
-export declare const getDataEntryTypeString: (d: DataEntry, withLibraryInformation?: boolean, retainValue?: boolean) => string;
+export declare const getDataEntryTypeString: (d: DataEntry) => string;
 export declare const getStateDataContentType: (d: DataEntry) => string;
 export declare const getStateValueContentType: (d: DataEntry) => string;
 export declare const getSafeName: (name: string) => string;
-export declare const getDateEntryTypeNamedString: (d: DataEntry, withLibraryInformation?: boolean) => string;
+export declare const getDateEntryTypeNamedString: (d: DataEntry) => string;

package/dist/types/arrayData.d.ts

@@ -1,10 +1,10 @@
-import { NestedData } from './dataEntry';
+import { DataEntry } from './dataEntry';
 export type ArrayData = {
     type: 'ARRAY';
     minCount: number;
     maxCount: number;
     stateBits: number;
     state: number;
-    descriptor: NestedData;
-    value: NestedData[];
+    descriptor: DataEntry;
+    value: DataEntry[];
 };

package/dist/types/dataEntry.d.ts

@@ -7,27 +7,27 @@ import { EnumArrayData } from './enumArrayData.ts';
 import { OptionalData } from './optionalData.ts';
 import { EnumOptionsData } from './enumOptionsData.ts';
 import { ArrayData } from './arrayData.ts';
+import { ObjectData } from './objectData.ts';
+import { ConstantBitWidthDataTypes, VariableBitWidthDataTypes } from '@/enums/dataTypes.ts';
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 };
 type DataDescription = {
     name: string;
-    internalName?: number[];
-    index?: number;
 };
 /**
  * Boolean object
  *
  * Boolean objects are a simple `true` or `false`, 1 or 0 - one bitwidth object.
  */
-export type BooleanDataEntry = Prettify<BooleanData & DataDescription>;
+export type BooleanDataEntry = BooleanData & DataDescription;
 /**
  * Enum object
  *
  * An enum object is a continious range of integer values, starting at 0 upto its max.
  * The maximum acceptable value for the max is `255` (8 bits)
  */
-export type EnumDataEntry = Prettify<EnumData & DataDescription>;
+export type EnumDataEntry = EnumData & DataDescription;
 /**
  * Int object
  *
@@ -35,7 +35,7 @@ export type EnumDataEntry = Prettify<EnumData & DataDescription>;
  * The maximum and minimum value can be any integar values represntabled as a double yet,
  * the maximum acceptable delta between min and max is `4095` (12 bits).
  */
-export type IntDataEntry = Prettify<IntData & DataDescription>;
+export type IntDataEntry = IntData & DataDescription;
 /**
  * Float object
  *
@@ -45,7 +45,7 @@ export type IntDataEntry = Prettify<IntData & DataDescription>;
  * The significand defines the amount of bits that are used to store the numeric value of the number and is derived from the `min` and `max` values in relationship to the precision.
  * Maximum value for the significand is `20` bits, which allows for a maximum of 1048576 possible values.
  */
-export type FloatDataEntry = Prettify<FloatData & DataDescription>;
+export type FloatDataEntry = FloatData & DataDescription;
 /**
  * Version object
  *
@@ -55,7 +55,7 @@ export type FloatDataEntry = Prettify<FloatData & DataDescription>;
  * Acceptable bitwidths are: `4 | 6 | 8 | 10`, giving a total of respectively 16, 64, 256 and 1024 possible versions
  * Choose wisely, as it is not possible to increase this value later on (that would require the inclusion of an additional version object)
  */
-export type VersionDataEntry = Prettify<VersionData & DataDescription>;
+export type VersionDataEntry = VersionData & DataDescription;
 /**
  * Enum Array object
  *
@@ -68,13 +68,43 @@ export type VersionDataEntry = Prettify<VersionData & DataDescription>;
  *
  * Note: the partical maximum benefit of using this versus using a `ArrayEntryDataType` with only enums is only about 22% for base_5
  */
-export type EnumArrayDataEntry = Prettify<EnumArrayData & DataDescription>;
-export type DataEntry = BooleanDataEntry | IntDataEntry | EnumDataEntry | FloatDataEntry | VersionDataEntry | EnumArrayDataEntry;
-export type OptionalDataEntry = Prettify<OptionalData & DataDescription>;
-export type EnumOptionsDataEntry = Prettify<EnumOptionsData & DataDescription>;
-export type ArrayDataEntry = Prettify<ArrayData & DataDescription>;
-export type ComplexDataEntry = OptionalDataEntry | EnumOptionsDataEntry | ArrayDataEntry;
-export type NestedData = (DataEntry | ComplexDataEntry)[];
-export type ProtectedAttributeNames = Prettify<keyof BooleanDataEntry | keyof IntDataEntry | keyof EnumDataEntry | keyof FloatDataEntry | keyof VersionDataEntry | keyof EnumArrayDataEntry | keyof OptionalDataEntry | keyof EnumOptionsDataEntry | keyof ArrayDataEntry>;
+export type EnumArrayDataEntry = EnumArrayData & DataDescription;
+/**
+ * Object Wrapper Object
+ *
+ * contains a static set of NestedData, for which its structure always maps 1:1 to its descriptor
+ */
+export type ObjectDataEntry = ObjectData & DataDescription;
+/**
+ * Optional Wrapper Object
+ *
+ * has two optional states, `true` or `false` and a matching descriptor (either `[null, DataEntry]` or `[DataEntry, null]`) corresponding to the state
+ */
+export type OptionalDataEntry = OptionalData & DataDescription;
+/**
+ * Enum Options Wrapper Object
+ *
+ *
+ * similar to the optional wrapper, but using a `number` to offer many different states
+ * the maxAmount of states is derived from the descriptor length
+ * descriptor entries can be any `DataEntry` or `null`
+ */
+export type EnumOptionsDataEntry = EnumOptionsData & DataDescription;
+export type ArrayDataEntry = ArrayData & DataDescription;
+/**
+ * Union Type of all the defined data types
+ */
+export type DataEntry = BooleanDataEntry | IntDataEntry | EnumDataEntry | FloatDataEntry | VersionDataEntry | EnumArrayDataEntry | ObjectDataEntry | OptionalDataEntry | EnumOptionsDataEntry | ArrayDataEntry;
+/**
+ * Union Type of all the data entries that have a bitwidth that are guaranteed to have only one level of complexity
+ * These are much easier to parse (both from and to bitstring )
+ */
+export type SimpleDataEntry = DataEntry & {
+    type: (typeof ConstantBitWidthDataTypes)[number];
+};
+export type VariableBitWidthDataEntry = DataEntry & {
+    type: (typeof VariableBitWidthDataTypes)[number];
+};
+export type ProtectedAttributeNames = keyof BooleanDataEntry | keyof IntDataEntry | keyof EnumDataEntry | keyof FloatDataEntry | keyof VersionDataEntry | keyof EnumArrayDataEntry | keyof OptionalDataEntry | keyof EnumOptionsDataEntry | keyof ArrayDataEntry;
 export declare const PROTECTED_ATTRIBUTE_NAMES: readonly ["type", "value", "name", "internalName", "index", "min", "max", "bits", "precision", "significand", "minCount", "maxCount", "state", "stateBits", "descriptor", "mapping"];
 export {};

package/dist/types/enumArrayData.d.ts

@@ -18,4 +18,6 @@ export type EnumArrayData = {
     value: number[];
     max: number;
     mapping: EnumMappingType;
+    stateBits: number;
+    state?: 0;
 };

package/dist/types/enumData.d.ts

@@ -1,5 +1,5 @@
 export declare const EnumMaxBits = 8;
-export type EnumMappingType = (string | number | object)[];
+export type EnumMappingType = (string | number)[];
 export type EnumOptionsType = string | number | EnumMappingType;
 /**
  * Enum object

package/dist/types/enumOptionsData.d.ts

@@ -1,8 +1,10 @@
-import { NestedData } from './dataEntry';
+import { DataEntry } from './dataEntry';
+import { EnumMappingType } from './enumData';
 export type EnumOptionsData = {
     type: 'ENUM_OPTIONS';
     stateBits: number;
     state: number;
-    descriptor: NestedData[];
-    value: NestedData;
+    descriptor: (DataEntry | null)[];
+    mapping: EnumMappingType;
+    value: DataEntry | null;
 };

package/dist/types/index.d.ts

@@ -1,4 +1,3 @@
-export * from './stateDataEntry';
 export * from './enumOptionsData';
 export * from './optionalData';
 export * from './arrayData';
@@ -9,3 +8,6 @@ export * from './intData';
 export * from './versionData';
 export * from './booleanData';
 export * from './dataEntry';
+export * from './objectData';
+export * from './updateType';
+export * from './stateData';

package/dist/types/objectData.d.ts

@@ -0,0 +1,8 @@
+import { DataEntry } from './dataEntry';
+export type ObjectData = {
+    type: 'OBJECT';
+    stateBits: 0;
+    state?: 0;
+    value: DataEntry[];
+    descriptor: DataEntry[];
+};

package/dist/types/optionalData.d.ts

@@ -1,7 +1,8 @@
-import { NestedData } from './dataEntry';
+import { DataEntry } from './dataEntry';
 export type OptionalData = {
     type: 'OPTIONAL';
     state: boolean;
-    descriptor: [NestedData, null] | [null, NestedData];
-    value: NestedData | null;
+    descriptor: [DataEntry, null] | [null, DataEntry];
+    value: DataEntry | null;
+    stateBits: 1;
 };

package/dist/types/stateData.d.ts

@@ -0,0 +1,4 @@
+export type StateDataObjectValue = object | string | number | number[] | boolean | null | StateDataObject;
+export type StateDataObject = {
+    [key: string]: StateDataObjectValue;
+};

package/dist/types/stateDataEntry.d.ts

@@ -1,12 +1,16 @@
-import { ComplexDataEntry, DataEntry, NestedData, VersionDataEntry } from './dataEntry';
-export type StateDataEntry<T extends DataEntry | ComplexDataEntry> = T & {
+import { DataEntry, ObjectDataEntry, VersionDataEntry } from './dataEntry';
+import { UpdateWithStateEntries } from './updateType';
+export type StateDataEntry<T extends DataEntry> = T & {
     bitstring: string;
-    updateValue: (newEntry: T) => void;
+    updateValue: (value: T['value'], state?: UpdateWithStateEntries['state'], withCallBack?: boolean) => StateDataEntry<T>;
+};
+export type State = [StateDataEntry<VersionDataEntry>, ...StateDataEntry<DataEntry>[]];
+export type StateDataValue = string | boolean | number | object | null;
+export type StateObjectDataEntry = ObjectDataEntry & {
+    descriptor: [VersionDataEntry, ...DataEntry[]];
 };
-export type State = [StateDataEntry<VersionDataEntry>, ...StateDataEntry<DataEntry | ComplexDataEntry>[]];
-export type StateDescriptor = [VersionDataEntry, ...NestedData];
 export type StateDataObject = {
-    [key: string]: object | string | boolean | number | (string | number | object)[] | null | StateDataObject | StateDataObject[];
+    [key: string]: StateDataValue;
 };
 export type StateObject = {
     state: State;

package/dist/types/updateType.d.ts

@@ -0,0 +1,16 @@
+import { DataEntry } from './dataEntry';
+export declare const ComplexDataTypes: readonly ["ENUM_OPTIONS", "OPTIONAL", "ARRAY"];
+export declare const SimpleDataTypes: readonly ["BOOLEAN", "INT", "ENUM", "FLOAT", "VERSION", "ENUM_ARRAY", "OBJECT"];
+export declare const NestedUpdateTypes: readonly ["ENUM_OPTIONS", "OPTIONAL", "ARRAY", "OBJECT"];
+export declare const SimpleUpdateTypes: readonly ["BOOLEAN", "INT", "ENUM", "FLOAT", "VERSION", "ENUM_ARRAY"];
+export type UpdateWithValidationTypes = DataEntry & {
+    type: (typeof SimpleUpdateTypes)[number];
+};
+export type UpdateWithValuesEntries = DataEntry & {
+    type: (typeof SimpleDataTypes)[number];
+};
+export type UpdateWithStateEntries = DataEntry & {
+    type: (typeof ComplexDataTypes)[number];
+};
+export type UpdateValue<T extends UpdateWithValuesEntries> = (entry: T, value: T['value']) => T;
+export type UpdateState<T extends UpdateWithStateEntries> = (entry: T, state: T['state']) => T;

package/dist/update/arrayUpdate.d.ts

@@ -1,2 +1,4 @@
-import { ArrayDataEntry } from '@/types';
-export declare const updateComplexValue: (original: ArrayDataEntry, update: ArrayDataEntry) => ArrayDataEntry;
+import { ArrayDataEntry } from '../types';
+import { UpdateState } from '../types/updateType';
+export declare const constrainState: (state: ArrayDataEntry["state"], minCount: ArrayDataEntry["minCount"], maxCount: ArrayDataEntry["maxCount"]) => ArrayDataEntry["state"];
+export declare const updateState: UpdateState<ArrayDataEntry>;

package/dist/update/booleanUpdate.d.ts

@@ -1,2 +1,3 @@
-import { BooleanDataEntry } from '../types/dataEntry';
-export declare const updateValue: (original: BooleanDataEntry, update: BooleanDataEntry) => BooleanDataEntry;
+import { BooleanDataEntry } from '../types/';
+export declare const constrainValue: <T extends BooleanDataEntry>(original: T, update: T["value"]) => T["value"];
+export declare const updateValue: <T extends BooleanDataEntry>(original: T, update: T["value"]) => T;