url-safe-bitpacking 0.1.15 → 0.2.1

package/dist/parsers/arrayParser.d.ts

@@ -0,0 +1,4 @@
+import { ArrayDataEntry } from '@/types';
+export declare const rawParser: (bitString: string, arrayData: ArrayDataEntry) => [ArrayDataEntry, string];
+export declare const rawStateStringifier: (arrayData: ArrayDataEntry) => string;
+export declare const rawStringifier: (arrayData: ArrayDataEntry) => string;

package/dist/parsers/enumOptionsFactory.d.ts

@@ -0,0 +1,4 @@
+import { EnumOptionsDataEntry } from '@/types';
+export declare const rawParser: (bitString: string, enumOptionsData: EnumOptionsDataEntry) => [EnumOptionsDataEntry, string];
+export declare const rawStateStringifier: (enumOptionsData: EnumOptionsDataEntry) => string;
+export declare const rawStringifier: (enumOptionsData: EnumOptionsDataEntry) => string;

package/dist/parsers/optionalParser.d.ts

@@ -0,0 +1,4 @@
+import { OptionalDataEntry } from '@/types';
+export declare const rawParser: (bitString: string, optionalData: OptionalDataEntry) => [OptionalDataEntry, string];
+export declare const rawStateStringifier: (optionalData: OptionalDataEntry) => string;
+export declare const rawStringifier: (optionalData: OptionalDataEntry) => string;

package/dist/parsers/parsers.d.ts

@@ -1,4 +1,4 @@
-import { DataEntryArray, DataEntry } from '../types/dataEntry';
+import { DataEntry, ComplexDataEntry, NestedData } from '../types/dataEntry';
 /**
  * Method that parses a bitstring into a value
  * @param bitString - `string` of 0 | 1
@@ -28,13 +28,23 @@ export declare const getBitsCount: (mapData: DataEntry, bitString: string) => nu
  */
 export declare const dataEntryBitstringParser: (bitstring: string, dataEntry: DataEntry) => [DataEntry, string];
 /**
- * Method to convert a bitstring into an array of data entries
- * @param bitString bitstring to parse into bits and then data entries
- * @param mapDataArray Data descriptions to map the bits to data entries
- * @returns array of data entries
+ * 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 dataBitsArrayParser: (bitString: string, mapDataArray: DataEntryArray) => DataEntryArray;
+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 dataEntryCorrecting: (dataEntry: DataEntry) => DataEntry;
 export declare const base64url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 /**
@@ -78,9 +88,3 @@ export declare const parseBitsToBase64: (bits: string) => string;
  * @returns `string` of 0 | 1
  */
 export declare const parseBase64ToBits: (base64: string) => string;
-/**
- * Method to convert an array of data entries into a base64 string
- * @param dataArray Data Entries to read to parse into bits and then a base64 string
- * @returns bitstring representation of the data entries
- */
-export declare const dataArrayStringifier: (dataEntryArray: DataEntryArray) => string;

package/dist/stateHandling/index.d.ts

@@ -0,0 +1 @@
+export * from './stateDataObject';

package/dist/stateHandling/stateData.d.ts

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

package/dist/stateHandling/stateDataObject.d.ts

@@ -0,0 +1,15 @@
+import { StateDescriptor, StateObject } from '@/types/stateDataEntry';
+/**
+ * Creates a state object from a state descriptor and updates the state object when the state changes.
+ * @param initialState - the initial state descriptor
+ * @param updateCallback - the callback that gets triggered when the state gets updated
+ * @returns the state object
+ */
+export declare const createStateDataObject: (initialState: StateDescriptor, updateCallback: (currentState: StateObject) => StateObject) => StateObject;
+/**
+ * Creates a state descriptor from a base64 string and a state descriptor
+ * @param base64 - the base64 string
+ * @param descriptor - the state descriptor
+ * @returns the state descriptor
+ */
+export declare const getInitialStateFromBase64: (base64: string, descriptor: StateDescriptor) => StateDescriptor;

package/dist/typeFactory/stateDataTyping.d.ts

@@ -1,9 +1 @@
-import { ArrayEntryDataType, DoubleLevelContentType, EnumEntryDataType, NestedContentType, OptionalEntryDataType, SingleLevelContentType, VersionContentDefinition } from '../types';
-export declare const getVersionContentTypeFile: (versionContent: VersionContentDefinition) => string;
-export declare const getStateDataTypeForSingleLevelContentTypeArray: (slcta: SingleLevelContentType[]) => string;
-export declare const getStateDataTypeForSingleLevelContentType: (slct: SingleLevelContentType) => string;
-export declare const getStateDataTypeNestedContentType: (ncdt: NestedContentType, attributeName: string) => string;
-export declare const getStateDataTypeForDoubleLevelContentType: (dncdt: DoubleLevelContentType, attributeName: string) => string;
-export declare const getStateDataTypeForOptionalEntryDataType: (oedt: OptionalEntryDataType, attributeName: string) => string;
-export declare const getStateDataTypeForEnumEntryDataType: (eedt: EnumEntryDataType, attributeName: string) => string;
-export declare const getStateDataTypeForArrayEntryDataType: (aedt: ArrayEntryDataType, attributeName: string) => string;
+export {};

package/dist/types/arrayData.d.ts

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

package/dist/types/booleanData.d.ts

@@ -1,5 +1,4 @@
-import { DataType } from '../enums/dataTypes';
 export type BooleanData = {
-    type: DataType.BOOLEAN;
+    type: 'BOOLEAN';
     value: boolean;
 };

package/dist/types/dataEntry.d.ts

@@ -4,13 +4,16 @@ import { FloatData } from './floatData';
 import { IntData } from './intData';
 import { VersionData } from './versionData';
 import { EnumArrayData } from './enumArrayData.ts';
+import { OptionalData } from './optionalData.ts';
+import { EnumOptionsData } from './enumOptionsData.ts';
+import { ArrayData } from './arrayData.ts';
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 };
 type DataDescription = {
     name: string;
-    internalName?: string;
-    index: number;
+    internalName?: number[];
+    index?: number;
 };
 /**
  * Boolean object
@@ -67,7 +70,11 @@ export type VersionDataEntry = Prettify<VersionData & DataDescription>;
  */
 export type EnumArrayDataEntry = Prettify<EnumArrayData & DataDescription>;
 export type DataEntry = BooleanDataEntry | IntDataEntry | EnumDataEntry | FloatDataEntry | VersionDataEntry | EnumArrayDataEntry;
-export type ProtectedAttributeNames = Prettify<keyof BooleanDataEntry | keyof IntDataEntry | keyof EnumDataEntry | keyof FloatDataEntry | keyof VersionDataEntry | keyof EnumArrayDataEntry>;
-export declare const PROTECTED_ATTRIBUTE_NAMES: readonly ["type", "value", "name", "internalName", "index", "min", "max", "bits", "precision", "significand", "minCount", "maxCount"];
-export type DataEntryArray = DataEntry[];
+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 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

@@ -1,4 +1,4 @@
-import { DataType } from '../enums/dataTypes';
+import { EnumMappingType } from './enumData';
 /**
  * Enum Array object
  *
@@ -12,10 +12,10 @@ import { DataType } from '../enums/dataTypes';
  * Note: the partical maximum benefit of using this versus using a `ArrayEntryDataType` with only enums is only about 22% for base_5
  */
 export type EnumArrayData = {
-    type: DataType.ENUM_ARRAY;
+    type: 'ENUM_ARRAY';
     minCount: number;
     maxCount: number;
     value: number[];
-    min: number;
     max: number;
+    mapping: EnumMappingType;
 };

package/dist/types/enumData.d.ts

@@ -1,5 +1,6 @@
-import { DataType } from '../enums/dataTypes';
 export declare const EnumMaxBits = 8;
+export type EnumMappingType = (string | number | object)[];
+export type EnumOptionsType = string | number | EnumMappingType;
 /**
  * Enum object
  *
@@ -7,8 +8,9 @@ export declare const EnumMaxBits = 8;
  * The maximum acceptable value for the max is `255` (8 bits)
  */
 export type EnumData = {
-    type: DataType.ENUM;
+    type: 'ENUM';
     value: number;
     max: number;
     bits: number;
+    mapping: EnumMappingType;
 };

package/dist/types/enumOptionsData.d.ts

@@ -0,0 +1,8 @@
+import { NestedData } from './dataEntry';
+export type EnumOptionsData = {
+    type: 'ENUM_OPTIONS';
+    stateBits: number;
+    state: number;
+    descriptor: NestedData[];
+    value: NestedData;
+};

package/dist/types/floatData.d.ts

@@ -1,4 +1,3 @@
-import { DataType } from '../enums/dataTypes';
 export type PrecisionRangeType = -3 | -2 | -1 | 0 | 1 | 2 | 3;
 export declare const SignificandMaxBits = 20;
 /**
@@ -11,7 +10,7 @@ export declare const SignificandMaxBits = 20;
  * Maximum value for the significand is `20` bits, which allows for a maximum of 1048576 possible values.
  */
 export type FloatData = {
-    type: DataType.FLOAT;
+    type: 'FLOAT';
     value: number;
     min: number;
     max: number;

package/dist/types/index.d.ts

@@ -1,9 +1,11 @@
-export * from './arrayDefinitions';
-export * from './booleanData';
-export * from './dataEntry';
+export * from './stateDataEntry';
+export * from './enumOptionsData';
+export * from './optionalData';
+export * from './arrayData';
+export * from './enumArrayData';
 export * from './enumData';
 export * from './floatData';
 export * from './intData';
-export * from './semanticMapping';
-export * from './stateValueModel';
 export * from './versionData';
+export * from './booleanData';
+export * from './dataEntry';

package/dist/types/intData.d.ts

@@ -1,4 +1,3 @@
-import { DataType } from '../enums/dataTypes';
 export declare const IntegerMaxBits = 12;
 /**
  * Int object
@@ -8,7 +7,7 @@ export declare const IntegerMaxBits = 12;
  * the maximum acceptable delta between min and max is `4095` (12 bits).
  */
 export type IntData = {
-    type: DataType.INT;
+    type: 'INT';
     value: number;
     min: number;
     max: number;

package/dist/types/optionalData.d.ts

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

package/dist/types/stateDataEntry.d.ts

@@ -0,0 +1,16 @@
+import { ComplexDataEntry, DataEntry, NestedData, VersionDataEntry } from './dataEntry';
+export type StateDataEntry<T extends DataEntry | ComplexDataEntry> = T & {
+    bitstring: string;
+    updateValue: (newEntry: T) => void;
+};
+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[];
+};
+export type StateObject = {
+    state: State;
+    bitstring: string;
+    base64: string;
+    data: StateDataObject;
+};

package/dist/types/versionData.d.ts

@@ -1,8 +1,7 @@
-import { DataType } from '../enums/dataTypes';
 export type VersionRangeType = 4 | 6 | 8 | 10;
 export declare const VersionRange: VersionRangeType[];
 export type VersionData = {
-    type: DataType.VERSION;
+    type: 'VERSION';
     value: number;
     bits: VersionRangeType;
 };

package/dist/update/arrayUpdate.d.ts

@@ -0,0 +1,2 @@
+import { ArrayDataEntry } from '@/types';
+export declare const updateComplexValue: (original: ArrayDataEntry, update: ArrayDataEntry) => ArrayDataEntry;

package/dist/update/enumOptionsUpdate.d.ts

@@ -0,0 +1,2 @@
+import { EnumOptionsDataEntry } from '@/types';
+export declare const updateComplexValue: (original: EnumOptionsDataEntry, update: EnumOptionsDataEntry) => EnumOptionsDataEntry;

package/dist/update/nestedDataMatching.d.ts

@@ -0,0 +1,2 @@
+import { NestedData } from '@/types';
+export declare const updateNestedData: (original: NestedData | undefined, descriptor: NestedData) => NestedData;

package/dist/update/optionalUpdate.d.ts

@@ -0,0 +1,2 @@
+import { OptionalDataEntry } from '@/types';
+export declare const updateComplexValue: (original: OptionalDataEntry, update: OptionalDataEntry) => OptionalDataEntry;

package/dist/update/updateValues.d.ts

@@ -1,4 +1,4 @@
-import { DataEntry } from '../types/dataEntry';
+import { DataEntry, ComplexDataEntry } from '../types/dataEntry';
 /**
  * Method to update the value of a data entry
  * @param original - the original data entry
@@ -6,3 +6,10 @@ import { DataEntry } from '../types/dataEntry';
  * @returns the updated data entry
  */
 export declare const updateValue: (original: DataEntry, update: DataEntry) => DataEntry;
+/**
+ * Method to update the value of a data entry
+ * @param original - the original data entry
+ * @param update - the update data entry
+ * @returns the updated data entry
+ */
+export declare const updateComplexValue: (original: ComplexDataEntry, update: ComplexDataEntry) => ComplexDataEntry;

package/package.json

@@ -6,7 +6,7 @@
     "dist/*"
   ],
   "type": "module",
-  "version": "0.1.15",
+  "version": "0.2.1",
   "author": "Jonas Ward",
   "description": "Library for creating web safe base64 objects with custom bith widths and dynamic values.",
   "scripts": {

package/dist/objectmap/index.d.ts

@@ -1,4 +0,0 @@
-export * from './stateDataModel';
-export * from './userMethods';
-export * from './userMethods';
-export * from './stateValueHelperMethods';

package/dist/objectmap/stateDataModel.d.ts

@@ -1,33 +0,0 @@
-import { DataEntry, DataEntryArray, NestedContentType, SingleLevelContentType, DoubleLevelContentType, ArrayEntryDataType, EnumEntryDataType, OptionalEntryDataType, DataEntryParsingReturnType, DerivativeStateDataType, InternalStateDataGenerationMethod, StateDataGenerationMethod, StateDataType } from '../types';
-/**
- * Helper method for finding an existing data entry in case there was a previous object
- * @param dataEntry - new DataEntry
- * @param dataEntryArray - existing DataEntryArray
- */
-export declare const findExistingDataEntry: (dataEntry: DataEntry, dataEntryArray: DataEntryArray) => DataEntry | undefined;
-export declare const readDataEntry: (dataEntry: DataEntry, bitString: string) => DataEntryParsingReturnType;
-export declare const updateDataEntry: (dataEntry: DataEntry, existingData: DataEntryArray) => DataEntryParsingReturnType;
-/**
- * Method that extracts the data for a data entry from the given data
- * @param dataEntry - `DataEntry` object that represents the data entry to extract the data for
- * @param prefix - `string` that represents the prefix of the data internam name of the `DataEntry` object
- * @param additionalData - `DataEntryArray` or `string` that represents the additional data to extract the data from, if not provided, the default value will be returned
- * @returns `[DataEntryArray | string | undefined, [string, DataEntry]]` tuple that represents the updated additional data and the extracted data entry
- */
-export declare const internalGetDataEntry: (dataEntry: DataEntry, prefix: string, additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, DataEntry]];
-export declare const getStateFromOptionalEntryDataType: (oedt: OptionalEntryDataType, prefix: string, attributeName: string) => InternalStateDataGenerationMethod;
-export declare const getStateFromEnumEntryDataType: (eedt: EnumEntryDataType, prefix: string, attributeName: string) => (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, StateDataType]];
-/**
- * Helper method to get the method to parse, initiliaze, or update the state data for an array entry data type
- * @param aedt - `ArrayEntryDataType` object that represents the array entry data type
- * @param prefix - `string` that represents the prefix of the data internam name of the `DataEntry` object
- * @param attributeName - `string` that represents the name of the attribute to extract the data from
- * @returns `InternalStateDataGenerationMethod` object that represents the method to parse, initiliaze, or update the state data for an array entry data type
- */
-export declare const getStateFromArrayEntryDataType: (aedt: ArrayEntryDataType, prefix: string, attributeName: string) => (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, DerivativeStateDataType]];
-export declare const getStateDataFromDoubleLevelContentType: (dct: DoubleLevelContentType, prefix: string, attributeName: string) => InternalStateDataGenerationMethod;
-export declare const getStateDateFromSingleLevelContentTypeArray: (slcta: SingleLevelContentType[], prefix: string, attributeName: string) => (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, StateDataType]];
-export declare const getStateDataFromNestedContentType: (nct: NestedContentType, prefix: string, attributeName: string) => InternalStateDataGenerationMethod;
-export declare const getStateDataFromSingleLevelContentType: (slct: SingleLevelContentType, prefix: string) => InternalStateDataGenerationMethod;
-export declare const getGenerationMethodForSingleLevelContentTypeArray: (slct: SingleLevelContentType[]) => StateDataGenerationMethod;
-export declare const testOnlyResetCurrentDataEntryIndex: () => number;

package/dist/objectmap/stateValueHelperMethods.d.ts

@@ -1,13 +0,0 @@
-import { DataEntryArray, NestedContentType, SingleLevelContentType } from '../types';
-import { StateDataType, StateValueType } from '../types/stateValueModel';
-export declare const getStateValue: (stateValue: StateDataType) => StateValueType;
-export declare const getDataEntryArray: (stateValue: StateDataType) => DataEntryArray;
-export declare const getBase64String: (stateValue: StateDataType) => string;
-export declare const isSingleLevelContentType: (data: NestedContentType) => boolean;
-export declare const isDoubleLevelContentType: (data: NestedContentType) => boolean;
-export declare const singleLevelContentTypeIsDataEntry: (data: SingleLevelContentType) => boolean;
-export declare const singleLevelContentTypeIsNestedContentDataType: (data: SingleLevelContentType) => boolean;
-export declare const doubleLevelContentTypeIsEnumEntryDataType: (data: NestedContentType) => boolean;
-export declare const doubleLevelContentTypeIsOptionalEntryDataType: (data: NestedContentType) => boolean;
-export declare const doubleLevelContentTypeIsArrayDefinitionType: (data: NestedContentType) => boolean;
-export declare const isDataEntry: (v: any) => boolean;

package/dist/objectmap/userMethods.d.ts

@@ -1,12 +0,0 @@
-import { EnumSemantics, VersionHandler, VersionContentDefinition } from '../types';
-/**
- * Method to create version definition objects
- * @param {VersionArrayDefinitionType[]} versionContent  - version definition array
- * @param {number} maximumExpectedVersions - maximum expected versions to define
- * @param {number} defaultVersion - number - optional, default it is the first,
- * @param {EnumSemantics[] | EnumSemantics} enumSemanticsMapping - optional - UI semantics mapping for enums. If not given, values will be numbers
- * @param {undefined | Record<string, string> | Record<string, string>[]} attributeSemanticsMapping - optional - UI semantics mapping, if nothing given no semantics will be mapped
- * @param {number[]} exposedVersions?: number[] - optional - UI semantics, masks which objects to show and hide
- * @returns ParsersForVersionObject
- */
-export declare const createParserObject: (versionContent: VersionContentDefinition, maximumExpectedVersions: number, defaultVersion?: number, enumSemanticsMapping?: EnumSemantics | EnumSemantics[], attributeSemanticsMapping?: Record<string, string> | Record<string, string>[], exposedVersions?: number[]) => VersionHandler;

package/dist/types/arrayDefinitions.d.ts

@@ -1,58 +0,0 @@
-import { DataEntry } from './dataEntry';
-/**
- * Nested Content Type
- * content type that does nothing more than provide a name to an entry so that the data can be read from a key-value pair object
- */
-export type NestedContentDataType = [string, NestedContentType];
-/**
- * Single Level Content Type
- * data that can be behind a string in an object definition
- */
-export type SingleLevelContentType = DataEntry | NestedContentDataType;
-/**
- * Content Type Union
- */
-export type NestedContentType = SingleLevelContentType[] | DoubleLevelContentType;
-/**
- * Double Level Content Type
- * is a data model array definition for which the first entry describes relevant data for the datamodel content type, but data model definition in of itself
- *
- * this additional state data is represented in the object model with a boolean for the OptionalEntryDataType, an Enum for the EnumEntryDataType and an array for the ArrayEntryDataType+++++++++
- */
-export type DoubleLevelContentType = OptionalEntryDataType | EnumEntryDataType | ArrayEntryDataType;
-/**
- * Non Empty Valid Entry Array Type
- * is a data model array definition that is not empty
- */
-export type NonEmptyValidEntryArrayType = [SingleLevelContentType, ...SingleLevelContentType[]];
-/**
- * Optional Entry
- * An optional entry is where the user can choose between two data model options
- *
- * the first value of the array is whether the user by default chooses the first option or the second option
- *
- * the two options should always be present!
- */
-export type OptionalEntryDataType = [boolean, NonEmptyValidEntryArrayType, []] | [boolean, [], NonEmptyValidEntryArrayType];
-/**
- * Enum Entry
- * An enum defintion is where the user is offered a list of optional data models to choose from
- *
- * the first value of the arrea the default option available
- * all the other values are the option definitions
- *
- * the first value can't be bigger than the amount of options defined
- * there should be at least two options given!
- */
-export type EnumEntryDataType = [number, NonEmptyValidEntryArrayType, NonEmptyValidEntryArrayType, ...SingleLevelContentType[][]];
-/**
- * Array Entry
- * An array definition is where the user is offered a list data models
- *
- * the first value of the array is the min and max count of the array
- * the second value is the data model that is expected
- *
- * the delta of min and max count can't be less than 1 (and larger than 1024)
- */
-export type ArrayEntryDataType = [[number, number], NonEmptyValidEntryArrayType];
-export declare const PREFIX_SEPERATOR_DELIMETER = "_";

package/dist/types/semanticMapping.d.ts

@@ -1,6 +0,0 @@
-export type EnumSemantics = {
-    [dataEntryName: string]: {
-        value: number;
-        label: string;
-    }[];
-};

package/dist/types/stateValueModel.d.ts

@@ -1,33 +0,0 @@
-import { SingleLevelContentType } from './arrayDefinitions';
-import { DataEntry, DataEntryArray } from './dataEntry';
-import { EnumSemantics } from './semanticMapping';
-export type StateDataType = {
-    [attribute: string]: DataEntry | StateDataType | DerivativeStateDataType;
-};
-export type DerivativeStateDataType = {
-    s: DataEntry;
-    v: StateDataType | StateDataType[];
-};
-export type StateValueType = {
-    [attribute: string]: boolean | number | number[] | string | StateValueType | DerivativeStateValueType;
-};
-export type DerivativeStateValueType = {
-    s: boolean | number | string | number[];
-    v: StateValueType | StateValueType[];
-};
-export type StateDataGenerationMethod = (additionalData?: DataEntryArray | string) => StateDataType;
-export type DataEntryParsingReturnType = [DataEntryArray | string | undefined, [string, DataEntry]];
-export type InternalStateDataGenerationMethod = (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, DataEntry | StateDataType | DerivativeStateDataType]];
-export type ExposedParserStateDataMethod = (additionalData?: StateDataType | DataEntryArray | string) => StateDataType;
-export type UpdateStateDataMethod = (state: StateDataType, entryToUpdate: DataEntry | DataEntry[]) => StateDataType;
-export type StringifyStateDataMethod = (data: StateDataType | DataEntryArray) => string;
-export type VersionContentDefinition = SingleLevelContentType[][];
-export type VersionHandler = {
-    versionBitCount: number;
-    exposedVersions?: number[];
-    enumSemanticsMapping?: EnumSemantics | EnumSemantics[];
-    attributeSemanticsMapping?: Record<string, string> | Record<string, string>[];
-    parser: ExposedParserStateDataMethod;
-    updater: UpdateStateDataMethod;
-    stringify: StringifyStateDataMethod;
-};