@ondoher/enigma 1.0.9 → 1.0.11

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@ondoher/enigma",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Enigma machine simulator with tools and documentation to help you build your own.",
   "main": "./lib/index.js",
   "types": "./types/index.d.ts",
   "scripts": {
-    "test": "jasmine"
+    "test": "jasmine",
+    "types": "npx tsc -p tsconfig.json"
   },
   "author": "Glenn Anderson",
   "license": "MIT",

package/tsconfig.json

@@ -1,7 +1,5 @@
 {
   "compilerOptions": {
-    "outFile": "./dist/index.d.ts",
-    "module": "AMD",
     "target": "es2020",
     "allowJs": true,           /* Allow JavaScript files to be compiled. */
     "checkJs": true,           /* Report errors in .js files. */

package/types/index.d.ts

@@ -1,899 +1,2 @@
-declare module "enigma/consts" {
-    export const STANDARD_ALPHABET: string;
-}
-declare module "enigma/Encoder" {
-    /**
-     * This is the base class for an encoder. The default implementation of the
-     * encode method is to return the input as the output
-     */
-    export default class Encoder {
-        /**
-         * Constructor for the base encoder
-         *
-         * @param {string} name
-         * @param {ComponentType} type
-         * @param {EncoderSetup} settings
-         */
-        constructor(name: string, type: ComponentType, settings: EncoderSetup);
-        name: string;
-        type: ComponentType;
-        alphabet: string;
-        contactCount: number;
-        /** @type {{[name: string]: Listener}} */
-        listeners: {
-            [name: string]: Listener;
-        };
-        /**
-         * given a connector number, normalize it to be between 0 and 25 inclusive.
-         *
-         * @param {Number} connector the connector being normalized
-         *
-         * @returns {Number} value between 0 and 25
-         */
-        normalize(connector: number): number;
-        /**
-         *
-         * @param {string} letter
-         *
-         * @returns {boolean}
-         */
-        verifyLetter(letter: string): boolean;
-        /**
-         * Call this method to convert a letter to a connector value
-         *
-         * @param {string} letter
-         * @returns {number | undefined}
-         */
-        letterToConnector(letter: string): number | undefined;
-        /**
-         * Call this method to turn a connector to a letter value
-         *
-         * @param {number} connector
-         * @returns {string | undefined}
-         */
-        connectorToLetter(connector: number): string | undefined;
-        /**
-         * Given an alphabetic connection map, convert that into an array of
-         * numbers. The index into the array or string is the input connector, and
-         * the value at that position is the output connector
-         *
-         * @param {String} map connections map.
-         * @returns {Array.<Number>} the numerical map
-         */
-        makeMap(map: string): Array<number>;
-        /**
-         * given an existing connection map from input to out put, create a new map
-         * that has the connections going in the other direction, output to input.
-         *
-         * @param {Array.<Number>} map connection map
-         * @returns {Array.<Number>} the reversed map
-         */
-        makeReverseMap(map: Array<number>): Array<number>;
-        /**
-         * Call this method to convert the input connector number to the output in
-         * the given direction The default encode method just passes the input value
-         * through
-         *
-         * @param {Direction} _direction either right for moving towards the reflector
-         * 	or left if moving back
-         * @param {Number} input the specific connection receiving an input
-         *
-         * @returns {Number} The translated output connector number
-         */
-        encode(_direction: Direction, input: number): number;
-        /**
-         *
-         * @param {number | string} input
-         * @param {Direction} direction
-         */
-        fireInput(input: number | string, direction: Direction): void;
-        /**
-         *
-         * @param {number | string} output
-         * @param {Direction} direction
-         */
-        fireOutput(output: number | string, direction: Direction): void;
-        /**
-         *
-         * @param {number | string} input
-         * @param {number | string} output
-         * @param {Direction} direction
-         */
-        fireTranslate(input: number | string, output: number | string, direction: Direction): void;
-        /**
-         *
-         * @param {number | string} input
-         * @param {number | string} output
-         * @param {Direction} direction
-         */
-        fireEncodeSet(input: number | string, output: number | string, direction: Direction): void;
-        /**
-         * Call this method to add a function to be called when important events
-         * happen to a component. The name can be used to later remove the listener
-         *
-         * @param {string} name - the name of the listener
-         * @param {Listener} cb - the function to be called.
-         */
-        listen(name: string, cb: Listener): void;
-        /**
-         * Call this method to remove a listener
-         *
-         * @param {string} name - the name of the listener
-         */
-        unlisten(name: string): void;
-        /**
-         * Call this method to call any event listeners
-         *
-         * @param {EventName} event - the event being fired
-         * @param {String} name - the name of the component firing the event
-         * @param {EventData} data - the event data
-         */
-        fire(event: EventName, name: string, data: EventData): void;
-    }
-}
-declare module "enigma/EntryDisc" {
-    /**
-     * This is the class for an entry disc. Entry discs are fixed disks of connector
-     * pins.
-     */
-    export default class EntryDisc extends Encoder {
-        /**
-         * Constructor for the entry disc.
-         *
-         * @param {String} name the name of this entry disc
-         * @param {EncoderSetup} settings contains the alphabet being used, and the map
-         * 	between input and output contacts
-         */
-        constructor(name: string, settings: EncoderSetup);
-        rightMap: number[];
-        leftMap: number[];
-    }
-    import Encoder from "enigma/Encoder";
-}
-declare module "enigma/PlugBoard" {
-    /**
-     * This class represents the plugboard. There is only one type of plugboard
-     */
-    export default class PlugBoard extends Encoder {
-        /**
-         * Constructor for the plugboard.
-         *
-         * @param {String} name the name for the plugboard, defaults to 'plugboard'
-         * @param {EncoderSetup} [settings] the settings for the plugboard. Only needed if
-         * 	using an alternate alphabet
-         */
-        constructor(name?: string, settings?: EncoderSetup);
-        map: string;
-        rightMap: any[];
-        leftMap: any[];
-        plugs: string;
-        /**
-         * Call this method to configure the plug board. This will be used to
-         * provide the plug connections
-         *
-         * @param {Plugs} plugs the configuration options for the plug
-         * 	board
-         */
-        configure(plugs?: Plugs): void;
-    }
-    import Encoder from "enigma/Encoder";
-}
-declare module "enigma/Rotor" {
-    /**
-     * Create an instance of this class to construct a Rotor object. The Rotor class
-     * encapsulates many of the peculiar behaviors of the Enigma. All connector
-     * values here are specified in physical space.
-     */
-    export default class Rotor extends Encoder {
-        /**
-         * This is the constructor for the rotor.
-         *
-         * @param {String} name the name of the rotor; under normal circumstances
-         * 	this will be the string 'rotor-' plus the standard name for the rotor,
-            * for example 'rotor-IV'
-         * @param {RotorSetup} settings an object that contains the various options that
-         * define the the rotor and how it is configured.
-         */
-        constructor(name: string, settings: RotorSetup);
-        map: any[];
-        rightMap: number[];
-        leftMap: number[];
-        length: number;
-        ringOffset: number;
-        turnoverLookup: number[];
-        offset: number;
-        fixed: boolean;
-        turnovers: string;
-        _turnovers: Set<number>;
-        /**
-         * Call this method to select the initial rotation of the rotor. This is a
-         * letter offset from the logical 0 connector. The initial rotation will
-         * also take into account the ring setting
-         *
-         * @param {String} connector This is a letter value that corresponds to what
-         * would appear in the rotation window. This value will be adjusted for the
-         * ring setting.
-         */
-        setStartPosition(connector: string): void;
-        /**
-         * Call this method to step the rotor
-         *
-         * @returns {Boolean} true if the next rotor should be stepped
-         */
-        step(): boolean;
-        /**
-         * Call this method to see if the next step on this rotor will lead to
-         * turnover. The Enigma class will call this on the middle rotor to handle
-         * double stepping.
-         *
-         * @returns true if this rotor will turnover on the next step
-         */
-        willTurnover(): boolean;
-        shouldTurnover(): boolean;
-        /**
-         * Call this method to find whether this is a fixed rotor. This is used for
-         * the non stepping rotors--beta and gamma--that are used in the M4
-         * @returns
-         */
-        isFixed(): boolean;
-    }
-    import Encoder from "enigma/Encoder";
-}
-declare module "enigma/Reflector" {
-    /**
-     * Make in instance of this class to construct a reflector
-     */
-    export default class Reflector extends Encoder {
-        /**
-         * constructor for the reflector class.
-         *
-         * @param {String} name the name of the reflector instance
-         * @param {EncoderSetup} settings The definition of the reflector
-         */
-        constructor(name: string, settings: EncoderSetup);
-        map: number[];
-    }
-    import Encoder from "enigma/Encoder";
-}
-declare module "enigma/Inventory" {
-    const _default: Inventory;
-    export default _default;
-    /**
-     * This is the class used to manage the standard inventory of components. An
-     * instance of this class is exported as the default of this module
-     */
-    class Inventory {
-        entryDiscs: {};
-        /** @type {{[name: string]: RouterInventorySpec}}*/
-        rotors: {
-            [name: string]: RouterInventorySpec;
-        };
-        reflectors: {};
-        /**
-         * Call this method to add a new Rotor type to the inventory.
-         *
-         * @param {String} name the name of the rotor being added. This name will be
-         * 	used when specifying the rotors to use for the Enigma configuration.
-         * @param {String} map a string specifying the connector mapping. The index
-         * 	of the string is the logical coordinate of the connector, the character
-         * 	at that index is the output connector. To be exact, it would be the
-         * 	position of that character in the given alphabet. So, in the map '
-         * 	EKMFLGDQVZNTOWYHXUSPAIBRCJ', input connector 0 would map to output
-         * 	connector 4 and input connector 1 would map to output connector 10.
-         * 	Remember that the connectors are numbered starting at 0.
-         * @param {String} turnovers this is a string of characters representing the
-         * 	turnover locations on the disk. These letter would be the value shown in
-         * 	the window to during turnover. In Rotor I this is 'Q' in rotors VI, VII,
-         * 	and VIII there are two turnover locations, 'M' and 'Z'. Pass an empty
-         * 	string if this is a fixed rotor
-         */
-        addRotor(name: string, map: string, turnovers: string): void;
-        /**
-         * Call this method to add a new reflector definition.
-         *
-         * @param {String} name this is the name that will be used to reference this
-         * 	reflector when constructing an Enigma class.
-         * @param {String} map the mapping between connectors. this uses the same
-         * 	format used in the addRotor method
-         */
-        addReflector(name: string, map: string): void;
-        /**
-         * Call this method to add a new entry disc. There was only one used in the
-         * standard military models, but there were other versions that defined it
-         * differently.
-         *
-         * @param {*} name this is the name that will be used to reference this
-         * 	entry disc when constructing an Enigma class.
-         * @param {*} map the mapping between connectors. this uses the same format
-         * 	used in the addRotor method
-         */
-        addEntryDisc(name: any, map: any): void;
-        /**
-         * Call this method to get the setup for a defined rotor.
-         *
-         * @param {String} name the name of the rotor as it was added to the
-         * 	inventory.
-         *
-         * @returns {Object} the rotor definition
-         * @property {String} map the connection map for the rotor
-         * @property {String} turnovers the locations where turnovers happen
-         */
-        getRotor(name: string): any;
-        /**
-         * Call this method to get the setup for a defined reflector.
-         *
-         * @param {String} name the name of the reflector as it was added to the
-         * 	inventory.
-         * @returns {Object} the reflector definition
-         * @property {String} the connection map for the reflector
-         */
-        getReflector(name: string): any;
-        /**
-         * Call this method to get the setup for a defined entry disc.
-         *
-         * @param {String} name the name of the entry disc as it was added to the
-         * 	inventory.
-         * @returns {Object} the entry disc definition
-         * @property {String} the connection map for the entry disc
-         */
-        getEntryDisc(name: string): any;
-        /**
-         * Call this method to get the names of all the rotors in the inventory
-         *
-         * @param {boolean} [fixed] - if specified it returns only the names of
-         * routers filtered on if they are fixed or not, otherwise it returns all
-         *
-         * @returns {string[]} the names of the rotors
-         */
-        getRotorNames(fixed?: boolean): string[];
-    }
-}
-declare module "enigma/Enigma" {
-    /**
-     * Construct this class to get a new instance of the Enigma. Many of the
-     * parameters to the constructor and the config method reference the names of
-     * standard Enigma parts. These are retrieved from the Inventory instance
-     */
-    export default class Enigma extends Encoder {
-        /**
-         * The constructor for the Enigma. This represents the unconfigurable
-         * settings of the device.
-         *
-         * @param {string} name
-         * @param {EnigmaSetup} settings
-         */
-        constructor(name: string, settings: EnigmaSetup);
-        plugboard: PlugBoard;
-        entryDisc: EntryDisc;
-        reflector: Reflector;
-        length: number;
-        /** @type {Rotor[]} */
-        _rotors: Rotor[];
-        /** @type {{[rotor: number]: boolean}} */
-        pending: {
-            [rotor: number]: boolean;
-        };
-        /** @type {Encoder[]} */
-        encoders: Encoder[];
-        /**@type {SimplifiedConfiguration & {reflector: string}} */
-        _configuration: SimplifiedConfiguration & {
-            reflector: string;
-        };
-        /**
-         * the configured rotors
-         *
-         * @return {Rotor[]}
-         */
-        get rotors(): Rotor[];
-        /**
-         * @returns {SimplifiedConfiguration & {reflector: string}}
-         */
-        get configuration(): SimplifiedConfiguration & {
-            reflector: string;
-        };
-        /**
-         * Configure the Enigma for encoding.
-         *
-         * @param {EnigmaConfiguration} settings - the configuration of the Enigma.
-         * These settings represent the aspects of the Enigma that can can change for daily
-         * configuration.
-         */
-        configure(settings: EnigmaConfiguration): void;
-        /**
-         * Call this method to "step" the rotors one time. This method will manage the
-         * stepping between all rotors
-         */
-        step(): void;
-        /**
-         * Call this method to set the starting rotation for the messages to encrypt
-         *
-         * @param {number[]|string} setup - length of the string or the array
-         * 	should match the number of rotors and are given left to right. If start
-         * 	is a string then the letters of the string specify the start value seen
-         * 	in the window for the corresponding rotor. If it is an array then each
-         * 	number will be the one-based rotation.
-         */
-        setStart(setup: number[] | string): void;
-        /**
-         * Call this method to simulate a keypress on the Enigma. This will output
-         * the encoded letter
-         *
-         * @param {String} letter the key pressed
-         * @returns {String | undefined} the encoded letter
-         */
-        keyPress(letter: string): string | undefined;
-        /**
-         * Call this shortcut method to encode a whole string
-         *
-         * @param {String} start the starting position for the rotors
-         * @param {String} text the text to encode
-         *
-         * @returns {String} the encoded string.
-         */
-        translate(start: string, text: string): string;
-    }
-    import Encoder from "enigma/Encoder";
-    import PlugBoard from "enigma/PlugBoard";
-    import EntryDisc from "enigma/EntryDisc";
-    import Reflector from "enigma/Reflector";
-    import Rotor from "enigma/Rotor";
-}
-declare module "enigma/standardInventory" {
-    export namespace entryDiscDefinitions {
-        let _default: string;
-        export { _default as default };
-    }
-    export namespace rotorDefinitions {
-        namespace I {
-            let map: string;
-            let turnovers: string;
-        }
-        namespace II {
-            let map_1: string;
-            export { map_1 as map };
-            let turnovers_1: string;
-            export { turnovers_1 as turnovers };
-        }
-        namespace III {
-            let map_2: string;
-            export { map_2 as map };
-            let turnovers_2: string;
-            export { turnovers_2 as turnovers };
-        }
-        namespace IV {
-            let map_3: string;
-            export { map_3 as map };
-            let turnovers_3: string;
-            export { turnovers_3 as turnovers };
-        }
-        namespace V {
-            let map_4: string;
-            export { map_4 as map };
-            let turnovers_4: string;
-            export { turnovers_4 as turnovers };
-        }
-        namespace VI {
-            let map_5: string;
-            export { map_5 as map };
-            let turnovers_5: string;
-            export { turnovers_5 as turnovers };
-        }
-        namespace VII {
-            let map_6: string;
-            export { map_6 as map };
-            let turnovers_6: string;
-            export { turnovers_6 as turnovers };
-        }
-        namespace VIII {
-            let map_7: string;
-            export { map_7 as map };
-            let turnovers_7: string;
-            export { turnovers_7 as turnovers };
-        }
-        namespace Beta {
-            let map_8: string;
-            export { map_8 as map };
-            let turnovers_8: string;
-            export { turnovers_8 as turnovers };
-        }
-        namespace Gamma {
-            let map_9: string;
-            export { map_9 as map };
-            let turnovers_9: string;
-            export { turnovers_9 as turnovers };
-        }
-    }
-    export const reflectorDefinitions: {
-        A: string;
-        B: string;
-        C: string;
-        'Thin-B': string;
-        'Thin-C': string;
-    };
-}
-declare module "enigma/index" {
-    export { default as Enigma } from "./Enigma.js";
-    export { default as EntryDisc } from "./EntryDisc.js";
-    export { default as inventory } from "./Inventory.js";
-    export { default as PlugBoard } from "./PlugBoard.js";
-    export { default as Reflector } from "./Rotor.js";
-}
-declare module "generator/hamlet" {
-    export default sentences;
-    const sentences: string[];
-}
-declare module "utils/Random" {
-    const _default: Random;
-    export default _default;
-    /**
-     * This class implements a pseudorandom number generator that can be given a
-     * seed to produce a consistent sequence of numbers. This algorithm is
-     * inappropriate for real cryptographic purposes, but allows the production of
-     * output that can be consistently reproduced.
-     *
-     * This algorithm was stolen from the product Delphi.
-     */
-    class Random {
-        randSeed: number;
-        /**
-         * Call this method to set the seed value for the randomizer. The initial value
-         * will be the current time in milliseconds.
-         *
-         * @param {Number} value for the seed,
-         */
-        randomize(value: number): void;
-        /**
-         * Call this method to get a random number. If passed a value, the return
-         * will be an integer between 0 and that number - 1. without it will be a
-         * decimal value between 0 and < 1.
-         *
-         * @param {Number} [limit] if passed the upper boundary of the integer - 1
-         *
-         * @returns {Number} the randomized value as either an integer or a decimal
-         *     value depending on how it was called.
-         */
-        random(limit?: number): number;
-        /**
-         * Generate a random number using a bell curve. The curve is created using
-         * the analogy of dice. For example, a random number built with two six
-         * sided dice will have the peak of the curve at 7 with 2 and 12 being at
-         * the bottom.
-         *
-         * @param {number} dice - how many random numbers to pick
-         * @param {number} faces - the range, from 1 - faces, of the number
-         * @param {boolean} [zeroBased] - if true, the random range for each die will be from 0 - faces-1
-         *
-         * @return {number} the random number
-         */
-        randomCurve(dice: number, faces: number, zeroBased?: boolean): number;
-        /**
-         * call this method to pick a random number from an array and remove it
-         *
-         * @template T
-         * @param {T[]} list the array of items to choose from
-         *
-         * @returns {T} the chosen item
-         */
-        pickOne<T>(list: T[]): T;
-        /**
-         * Call this method to pick two items from a given list. The items are
-         * removed from the array. If the array is less than two items then it
-         * will return either an empty array or an array with one element.
-         *
-         * @template T
-         *
-         * @param {T[]} list the array of items to choose
-         * @returns {T[]} the two chosen items
-         */
-        pickPair<T>(list: T[]): T[];
-        /**
-         * Call this method to choose a given number of items from a list. The items
-         * are removed.
-         *
-         * @template T
-         *
-         * @param {Number} count the number of items to pick
-         * @param {T[]} list the list of items to choose from
-         *
-         * @returns {T[]} the chosen items
-         */
-        pick<T>(count: number, list: T[]): T[];
-        /**
-         * Call this method to randomly pick a set of item pairs. The items
-         * will be removed from the list.
-         *
-         * @template T
-         * @param {Number} count the number of pairs to pick
-         * @param {T[]} list the list of items to choose from
-         *,
-         * @returns {T[][]}} the item pairs chosen. Each pair is an array of
-         * 	two items from the list
-         */
-        pickPairs<T>(count: number, list: T[]): T[][];
-        /**
-         * Call this method to chose a random item from a list. The item is not
-         * removed.
-         *
-         * @template T
-         *
-         * @param {T[]} list the list of items to choose from
-         * @returns {T} the chosen item
-         */
-        chooseOne<T>(list: T[]): T;
-        /**
-         * Call this method to pick a pair of items from the given list. The items
-         * are guaranteed to be unique.
-         *
-         * @template T
-         *
-         * @param {T[]} list - the list of items
-         * @returns {T[]}
-         */
-        choosePair<T>(list: T[]): T[];
-        /**
-         * Call this method to return a random list of contiguous items from the
-         * given list. The items are not removed.
-         *
-         * @template T
-         * @param {number} count
-         * @param {T[]} list
-         *
-         * return {T[]}
-         */
-        chooseRange<T>(count: number, list: T[]): string;
-        /**
-         * Call this method to randomly pick a subset of items from a list. The
-         * items are not removed.
-         *
-         * @template T
-         *
-         * @param {Number} count the number of items to choose
-         * @param {T[]} list the list of items to choose from
-         *
-         * @returns {T[]} the list of items chosen
-         */
-        choose<T>(count: number, list: T[]): T[];
-    }
-}
-declare module "generator/Generator" {
-    /**
-     * Use this class to generate random enigma configurations and messages. The
-     * methods in this class all the use the `Random` object, which can be seeded to
-     * produce a reproducible output
-     */
-    export default class Generator {
-        /**
-         * Call this method to turn a string into valid characters for encryption,
-         * which is just the letters A-Z.
-         *
-         * @param {String} text the original text
-         * @returns {String} the text that has been normalized to what the Enigma
-         * 	can process
-         */
-        cleanMessage(text: string): string;
-        /**
-         * Call this method to break a string into groups of five letters with a
-         * space between them.
-         *
-         * @param {string} text - the original text
-         * @param {number} [size] - the size of the text groups, defaults to 5
-         *
-         * @returns {string} the segmented string
-         */
-        groupText(text: string, size?: number): string;
-        /**
-         * Call this method to generate the given number of sentences. The sentences
-         * are pulled from the text of Hamlet.
-         *
-         * @param {Number} count the number of sentences
-         * @returns {String} the sentences separated by a ' ';
-         */
-        generateSentences(count: number): string;
-        /**
-         * Call this method to get the possible setup and configuration options for
-         * the given model
-         *
-         * @param {Model} model
-         *
-         * @returns {ModelOptions}
-         */
-        getModelOptions(model: Model): ModelOptions;
-        /**
-         * Call this method to generate a random Enigma configuration
-         *
-         * @param {GeneratorSetup} [setup] options for settings
-    
-         * @returns {SimplifiedConfiguration} the Enigma settings.
-         */
-        generateEnigmaConfiguration(setup?: GeneratorSetup): SimplifiedConfiguration;
-        /**
-         *
-         * @param {string[]} [reflectors] if given, specifies and alternate list of
-         * reflectors. Defaults to ['A', 'B', 'C'];
-         */
-        createRandomEnigma(model?: string, reflectors?: string[]): Enigma;
-        /**
-         * Call this method to generate a random message text encoded with the given
-         * Enigma. The random text will be a few sentences from Hamlet.
-         *
-         * @param {Enigma} enigma
-         *
-         * @returns {GeneratedMessage} details of the generated text
-         */
-        generateMessage(enigma: Enigma): GeneratedMessage;
-    }
-    import Enigma from "enigma/Enigma";
-}
-declare module "generator/CodeBook" {
-    /**
-     * Use this class to generate Enigma key sheets and messages using it. The
-     * procedures used were derived from the information at
-     * [Enigma Message Procedures](https://www.ciphermachinesandcryptology.com/en/enigmaproc.htm)
-     */
-    export default class CodeBook {
-        /**
-         * Constructor for the `CodeBook` class.
-         * @param {Enigma} enigma - all encryption will be done using this configured Enigma
-         */
-        constructor(enigma: Enigma);
-        enigma: Enigma;
-        indicators: {};
-        generator: Generator;
-        /**
-         * Call this method to provide a new configuration to the enigma
-         *
-         * @param {SimplifiedConfiguration} config
-         */
-        configure(config: SimplifiedConfiguration): void;
-        reset(): void;
-        /**
-         * Call this method to create a three letter string as an identifier for a
-         * a day in a key sheet
-         *
-         * @returns {String} the string
-         */
-        makeIndicator(): string;
-        /**
-         * Call this method to create a single days configuration for a key sheet.
-         * This an Enigma configuration plus the other metadata.
-         *
-         * @param {number} day the day of the month
-         *
-         * @returns {KeySheetLine} One line of a key sheet
-         */
-        generateDay(day: number): KeySheetLine;
-        /**
-         * Call this method to construct a key sheet for the given number of days
-         *
-         * @param {Number} days the number of days on the key sheet
-         * @returns {KeySheetLine[]} the array of day objects
-         */
-        generateKeySheet(days: number): KeySheetLine[];
-        /**
-         * Call this method to process one sub-message from a longer message. This is
-         * part of code to generate a message as the Enigma would have been used.
-         *
-         * @param {string[]} indicators the three letter code that can be sent to
-         * 	reference the configuration of the Enigma. These will be used to cross
-         * reference the message to the machine configuration on the key sheet
-         * @param {String} text the cleaned up string to be encoded
-         *
-         * @returns {MessagePart} the encoded message segment
-         */
-        encodeOnePart(indicators: string[], text: string): MessagePart;
-        /**
-         * Call this method to generate a full message based on the data in a key
-         * sheet. The message constructed reflects an actual message as the Enigma
-         * was really used. An individual message cannot be more than 250
-         * characters, so longer messages are broken into multiple parts, each one
-         * encoded with a unique key
-         *
-         * @param {KeySheetLine[]} sheet a key sheet generated using generateKeySheet
-         * @param {number} [dayIdx] - if provided, specifies the day of the month for the message
-         * @param {string} [text] - if provided, this is the text of the message to generate
-         * @returns {KeyBookMessage} a list of encoded sub messages
-         */
-        generateMessage(sheet: KeySheetLine[], dayIdx?: number, text?: string): KeyBookMessage;
-        /**
-         * Call this method to generate a given number of messages based on a
-         * generated key sheet
-         *
-         * @param {Object} sheet  the generated key sheet
-         * @param {Number} count - the number of messages to generate
-         *
-         * @returns {Array} the list of generated messages
-         */
-        generateMessages(sheet: any, count: number): any[];
-    }
-    import Enigma from "enigma/Enigma";
-    import Generator from "generator/Generator";
-}
-declare module "generator/index" {
-    export { default as Generator } from "./Generator.js";
-    export { default as CodeBook } from "./CodeBook.js";
-    export { default as Random } from "../utils/Random.js";
-}
-declare module "index" {
-    export * from "enigma/index";
-    export * from "generator/index";
-}
-declare module "enigma/tests/EnigmaData" {
-    export namespace enigmaData {
-        let sampleFieldMessages: ({
-            source: string;
-            model: string;
-            setup: {
-                reflector: string;
-                rotors: string[];
-                ringSettings: number[];
-                plugs: string;
-            };
-            message: {
-                key: string;
-                encoded: string;
-                decoded: string;
-            };
-        } | {
-            source: string;
-            model: string;
-            setup: {
-                reflector: string;
-                rotors: string[];
-                ringSettings: string;
-                plugs: string;
-            };
-            message: {
-                key: string;
-                encoded: string;
-                decoded: string;
-            };
-        })[];
-        let sampleVerifiedMessages: {
-            verified: string[];
-            model: string;
-            setup: {
-                rotors: string[];
-                plugs: string;
-                ringSettings: number[];
-                reflector: string;
-            };
-            message: {
-                key: string;
-                encoded: string;
-                decoded: string;
-            };
-        }[];
-    }
-}
-declare module "enigma/tests/EnigmaSpec" {
-    export {};
-}
-declare module "enigma/tests/PlugBoardData" {
-    export namespace plugBoardData {
-        let alphabet: string;
-        let plugSettings: string;
-    }
-}
-declare module "enigma/tests/PlugBoardSpec" {
-    export {};
-}
-declare module "enigma/tests/RotorData" {
-    export namespace rotorData {
-        namespace createData {
-            let alphabet: string;
-            let map: string;
-            let reverseMap: number[];
-            let turnovers: string;
-            let turnoversMap: number[];
-        }
-        namespace I {
-            let map_1: string;
-            export { map_1 as map };
-            let turnovers_1: string;
-            export { turnovers_1 as turnovers };
-        }
-    }
-}
-declare module "enigma/tests/RotorSpec" {
-    export {};
-}
+export * from "./generator/index.d.ts";
+export * from "./enigma/index.d.ts";