@bitblit/ratchet-common 4.0.353-alpha → 4.0.355-alpha

package/lib/types.d.ts

@@ -0,0 +1,980 @@
+import { DurationLike } from 'luxon';
+
+interface Point2d {
+    x: number;
+    y: number;
+}
+
+interface Line2d {
+    p1: Point2d;
+    p2: Point2d;
+}
+
+interface Plane2d {
+    height: number;
+    width: number;
+    rightToLeft?: boolean;
+    topToBottom?: boolean;
+}
+
+interface PolyLine2d {
+    pts: Point2d[];
+}
+
+declare class Ratchet2d {
+    private constructor();
+    static translateToOriginVector(points: Point2d[]): Point2d;
+    static minimalContainingPlane(points: Point2d[]): Plane2d;
+    static scaleVector(src: Plane2d, dst: Plane2d): Point2d;
+    static samePoint(p1: Point2d, p2: Point2d): boolean;
+    static atLeastOneDimensionShared(p1: Point2d, p2: Point2d): boolean;
+    static validPlane(plane: Plane2d): boolean;
+    static validLine(line: Line2d): boolean;
+    static validLines(lines: Line2d[]): boolean;
+    static validPolyLine(pline: PolyLine2d): boolean;
+    static polyLineToLines(pline: PolyLine2d): Line2d[];
+    static lastPointOnPolyLine(polyLine: PolyLine2d): Point2d;
+    static lineToPolyLine(line: Line2d): PolyLine2d;
+    static linesToPolyLines(lines: Line2d[]): PolyLine2d[];
+    static validPoint(pt: Point2d): boolean;
+    static validPoints(pt: Point2d[]): boolean;
+    static planeContainsPoint(pt: Point2d, plane: Plane2d): boolean;
+    static planeContainsPoints(pt: Point2d[], plane: Plane2d): boolean;
+    static linesToPoints(lines: Line2d[]): Point2d[];
+    static pointsToLines(points: Point2d[]): Line2d[];
+    static rotateRightAboutOrigin90Degrees(points: Point2d[], times?: number): Point2d[];
+    static planeContainsLines(lines: Line2d[], plane: Plane2d): boolean;
+    static planeContainsPolyLine(pline: PolyLine2d, plane: Plane2d): boolean;
+    static planeContainsLine(line: Line2d, plane: Plane2d): boolean;
+    static xToY(points: Point2d[]): Point2d[];
+    static translate(points: Point2d[], xlate: Point2d): Point2d[];
+    static mirrorPointsOnPlane(points: Point2d[], src: Plane2d, mirrorX: boolean, mirrorY: boolean): Point2d[];
+    static transformPointsToNewPlane(points: Point2d[], src: Plane2d, dst: Plane2d): Point2d[];
+    static transformPointToNewPlane(point: Point2d, src: Plane2d, dst: Plane2d): Point2d;
+    static transformLines(lines: Line2d[], src: Plane2d, dst: Plane2d): Line2d[];
+    static fitCurve(curveDef: Point2d[], inputX: number): number;
+}
+
+interface BuildInformation {
+    version?: string;
+    hash?: string;
+    branch?: string;
+    tag?: string;
+    timeBuiltISO?: string;
+    notes?: string;
+}
+
+declare class RatchetInfo {
+    private constructor();
+    static buildInformation(): BuildInformation;
+}
+
+interface HistogramEntry<T> {
+    item: T;
+    count: number;
+}
+
+declare class Histogram<T> {
+    private entries;
+    update(val: T, addValue?: number): void;
+    sort(): void;
+    sortKeys(): void;
+    reverse(): void;
+    getEntries(): HistogramEntry<T>[];
+    getTotalCount(): number;
+    countForValue(val: T): number;
+    percentForValue(val: T): number;
+}
+
+interface JwtTokenBase {
+    iss?: string;
+    sub?: string;
+    aud?: string;
+    exp?: number;
+    nbf?: number;
+    iat?: number;
+    jti?: string;
+}
+
+interface CommonJwtToken<T> extends JwtTokenBase {
+    user: T;
+    proxy: T;
+    roles: string[];
+}
+
+declare const enum ExpiredJwtHandling {
+    RETURN_NULL = 0,
+    THROW_EXCEPTION = 1,
+    ADD_FLAG = 2
+}
+
+declare const LoggerLevelName: {
+    readonly error: "error";
+    readonly warn: "warn";
+    readonly info: "info";
+    readonly verbose: "verbose";
+    readonly debug: "debug";
+    readonly silly: "silly";
+};
+type LoggerLevelName = (typeof LoggerLevelName)[keyof typeof LoggerLevelName];
+
+interface JwtRatchetLike {
+    get encryptionKeyPromise(): Promise<string | string[]>;
+    get decryptKeysPromise(): Promise<string[]>;
+    get jtiGenerator(): () => string;
+    get decryptOnlyKeyUseLogLevel(): LoggerLevelName;
+    get parseFailureLogLevel(): LoggerLevelName;
+    decodeToken<T extends JwtTokenBase>(payloadString: string, expiredHandling?: ExpiredJwtHandling): Promise<T>;
+    encryptionKeyArray(): Promise<string[]>;
+    selectRandomEncryptionKey(): Promise<string>;
+    createTokenString(payload: any, expirationSeconds?: number, overrideEncryptionKey?: string): Promise<string>;
+    refreshJWTString(tokenString: string, allowExpired?: boolean, expirationSeconds?: number): Promise<string>;
+}
+
+declare class JwtRatchet implements JwtRatchetLike {
+    private _encryptionKeyPromise;
+    private _decryptKeysPromise?;
+    private _jtiGenerator;
+    private _decryptOnlyKeyUseLogLevel;
+    private _parseFailureLogLevel;
+    private static readonly EXPIRED_FLAG_NAME;
+    constructor(_encryptionKeyPromise: Promise<string | string[]>, _decryptKeysPromise?: Promise<string[]>, _jtiGenerator?: () => string, _decryptOnlyKeyUseLogLevel?: LoggerLevelName, _parseFailureLogLevel?: LoggerLevelName);
+    get encryptionKeyPromise(): Promise<string | string[]>;
+    get decryptKeysPromise(): Promise<string[]>;
+    get jtiGenerator(): () => string;
+    get decryptOnlyKeyUseLogLevel(): LoggerLevelName;
+    get parseFailureLogLevel(): LoggerLevelName;
+    static hasExpiredFlag(ob: any): boolean;
+    static invalidSafeDecode<T>(payloadString: string, decryptKey: string, logLevel?: LoggerLevelName): Promise<T>;
+    static secondsRemainingUntilExpiration(payloadString: string): Promise<number>;
+    static msRemainingUntilExpiration(payloadString: string): Promise<number>;
+    decodeToken<T extends JwtTokenBase>(payloadString: string, expiredHandling?: ExpiredJwtHandling): Promise<T>;
+    encryptionKeyArray(): Promise<string[]>;
+    selectRandomEncryptionKey(): Promise<string>;
+    createTokenString(payload: any, expirationSeconds?: number, overrideEncryptionKey?: string): Promise<string>;
+    refreshJWTString(tokenString: string, allowExpired?: boolean, expirationSeconds?: number): Promise<string>;
+    static decodeTokenNoVerify<T extends JwtTokenBase>(token: string): T;
+    static removeJwtFields(ob: any): void;
+    static removeExpiredFlag(ob: any): void;
+}
+
+declare class ArrayRatchet {
+    static wrapElementsInArray(input: any[]): any[][];
+    static compareTwoArrays<T>(ar1: T[], ar2: T[], fn: ComparisonFunction<T>): MatchReport<T>;
+    static extractSubarrayFromSortedByNumberField<T>(input: T[], fieldDotPath: string, minInclusive: number, maxExclusive: number): T[];
+    static findSplit(input: any[], fieldDotPath: string, target: number): number;
+}
+interface ComparisonFunction<T> {
+    (t1: T, t2: T): number;
+}
+interface MatchReport<T> {
+    matching: T[];
+    setOneOnly: T[];
+    setTwoOnly: T[];
+}
+
+declare class Base64Ratchet {
+    static safeObjectToBase64JSON(input: any): any;
+    static safeBase64JSONParse(input: string): any;
+    static generateBase64VersionOfBlob(blob: Blob): Promise<string>;
+    static generateBase64VersionOfString(input: string): string;
+    static generateBase64VersionOfUint8Array(input: Uint8Array): string;
+    static base64StringToUint8Array(b64encoded: string): Uint8Array;
+    static base64StringToString(input: string, encoding?: string): string;
+    private static BASE64_ABC;
+    private static BASE64_CODES;
+    static getBase64Code(charCode: number): number;
+    static uint8ArrayToBase64UrlString(bytes: Uint8Array): string;
+    static uint8ArrayToBase64String(bytes: Uint8Array): string;
+    static base64StringToBytes(str: string): Uint8Array;
+    static base64UrlStringToBytes(str: string): Uint8Array;
+    static encodeStringToBase64String(str: string, encoder?: TextEncoder): string;
+    static encodeStringToBase64UrlString(str: string, encoder?: TextEncoder): string;
+    static decodeBase64StringToString(str: string, decoder?: TextDecoder): string;
+    static decodeBase64UrlStringToString(str: string, decoder?: TextDecoder): string;
+}
+
+declare class BooleanRatchet {
+    static allTrue(vals: boolean[], emptyArraysReturn?: boolean): boolean;
+    static anyTrue(vals: boolean[], emptyArraysReturn?: boolean): boolean;
+    static parseBool(val: any): boolean;
+    static intToBool(val: any): boolean;
+    static boolToInt(val: any): number;
+}
+
+interface LastSuccessProvider {
+    lastSuccess(): number;
+}
+
+declare class CompositeLastSuccessProvider implements LastSuccessProvider {
+    private sources;
+    private mostRecent;
+    constructor(src: LastSuccessProvider[], mostRecentSrc?: boolean);
+    lastSuccess(): number;
+}
+
+declare class DateRatchet {
+    static COMMON_US_DATE_FORMAT: string;
+    static DEFAULT_DATE_FORMAT: string;
+    static FULL_DATE_FORMAT: string;
+    static PACIFIC_TIME_ZONE: string;
+    static UTC_TIME_ZONE: string;
+    static formatFullDate(input: Date): string;
+    static formatDefaultDateOnly(input: Date): string;
+    static parseDefaultDate(input: string): Date;
+    static parseCommonUsDate(input: string): Date;
+}
+
+declare class DurationRatchet {
+    static formatMsDuration(ms: number, includeMS?: boolean): string;
+    static colonFormatMsDuration(ms: number, includeMS?: boolean): string;
+    static daysBetween(d1: Date, d2: Date): number;
+    static createSteps(startEpochMS: number, endEpochMS: number, timezone: string, outputFormat: string, stepUnit: DurationLike): string[];
+}
+
+declare class EnumRatchet {
+    static listEnumKeys(enumeration: any): string[];
+    static keyToEnum<T>(enumeration: any, val: string, caseSensitive?: boolean): T;
+    static parseCsvToEnumArray<T>(enumeration: any, input: string): T[];
+}
+
+declare class ErrorRatchet {
+    static safeStringifyErr(err: any, log?: boolean): string;
+    static asErr(input: any): Error;
+    static fErr(format: string, ...input: any[]): Error;
+    static throwFormattedErr(format: string, ...input: any[]): Error;
+}
+
+declare class EsmRatchet {
+    static fetchDirName(root: string): string;
+    static fetchFileName(root: string): string;
+}
+
+declare class ExpiringObject<T> {
+    private _config;
+    private _cacheObject;
+    private _lastUpdatedEpochMS;
+    private _timeRemainingMS;
+    constructor(inputConfig?: ExpiringObjectConfig<T>);
+    private defaultConfig;
+    private defaultTimeRemainingMS;
+    update(newValue: T, doNotUpdateClock?: boolean): void;
+    fetchCacheObjectTimeRemainingMS(): Promise<number>;
+    fetch(): Promise<T>;
+}
+declare class ExpiringObjectConfig<T> {
+    timeToLiveMS?: number;
+    generator?: () => Promise<T>;
+    initialValue?: T;
+    logLevel?: LoggerLevelName;
+    overrideTimeRemainingMS?: (lastUpdatedEpochMS: number) => Promise<number>;
+}
+
+declare class GeolocationRatchet {
+    private constructor();
+    static distanceBetweenLocations(lat1: number, lon1: number, lat2: number, lon2: number, unit?: string): number;
+    static distanceBetweenRatchetGeoLocations(loc1: RatchetGeoLocation, loc2: RatchetGeoLocation, unit?: string): number;
+    static degreeOfLatLngInMiles(latitudeInDecimalDegress?: number): number;
+    static milesInDegLatLng(miles: number, latitudeInDecimalDegress?: number): number;
+    static centerOfBounds(bounds: RatchetLocationBounds): RatchetGeoLocation;
+    private static calculateSplits;
+    static clusterGeoBounds(inputVal: RatchetLocationBounds[], latSlices?: number, lngSlices?: number): RatchetLocationBounds[];
+    static canonicalizeBounds(inp: RatchetLocationBounds, allowCrossover?: boolean): RatchetLocationBounds;
+    static combineBounds(inp: RatchetLocationBounds[]): RatchetLocationBounds;
+    static roundLocation(r: RatchetGeoLocation, roundDigits: number): RatchetGeoLocation;
+    static locationToBounds(loc: RatchetGeoLocation, radiusMiles: number): RatchetLocationBounds;
+    static sameLocation(loc1: RatchetGeoLocation, loc2: RatchetGeoLocation): boolean;
+    static pointInBounds(pt: RatchetGeoLocation, bound: RatchetLocationBounds): boolean;
+    static pointInAnyBound(pt: RatchetGeoLocation, inBounds: RatchetLocationBounds[], minPointsBeforeMapping?: number): boolean;
+    static pointInRatchetLocationBoundsMap(pt: RatchetGeoLocation, mp: RatchetLocationBoundsMap): boolean;
+    static findRatchetLocationBoundsMapEntry(pt: RatchetGeoLocation, mp: RatchetLocationBoundsMap): RatchetLocationBoundsMapEntry;
+    static buildRatchetLocationBoundsMap(inBounds: RatchetLocationBounds[]): RatchetLocationBoundsMap;
+}
+interface RatchetGeoLocation {
+    lat: number;
+    lng: number;
+}
+interface RatchetLocationBounds {
+    origin: RatchetGeoLocation;
+    extent: RatchetGeoLocation;
+}
+interface RatchetLocationBoundsMap {
+    latOffset: number;
+    lngOffset: number;
+    maxLat: number;
+    maxLng: number;
+    mapping: RatchetLocationBoundsMapEntry[][];
+}
+interface RatchetLocationBoundsMapEntry {
+    lat: number;
+    lng: number;
+    bounds: RatchetLocationBounds[];
+}
+
+declare class GlobalRatchet {
+    private constructor();
+    static fetchGlobalRecord(returnNullOnNone?: boolean): Record<string, any>;
+    static fetchGlobalVar(envVar: string): string;
+    static setGlobalVar(envVar: string, value: string): void;
+}
+
+declare class KeyValue<T> {
+    key: string;
+    value: T;
+}
+
+declare class MapRatchet {
+    static expandNestedKeysToObjects<T>(src: any, separator?: string): T;
+    static mapByUniqueProperty<T, R>(input: T[], propName: string): Map<R, T>;
+    static groupByProperty<T, R>(input: T[], propName: string): Map<R, T[]>;
+    static findValue(toSearch: any, path: string[]): any;
+    static findValueDotPath(toSearch: any, dotPath: string): any;
+    static simpleDeepCompare(object1: any, object2: any): boolean;
+    static toKeyValueList(value: Record<string, any>): KeyValue<any>[];
+    static fromKeyValueList<T>(list: KeyValue<T>[]): Record<string, T>;
+    static cleanup<T>(obj: T, stripZero?: boolean, stripNull?: boolean, stripUndefined?: boolean, stripEmptyString?: boolean): T;
+    static extractValueFromMapIgnoreCase(src: any, key: string): any;
+    static safeCallFunction(ob: any, fnName: string): boolean;
+    static caseInsensitiveAccess<T>(ob: any, keyName: string): T;
+}
+
+declare class No {
+    static op(...args: any[]): void;
+}
+
+declare class NumberRatchet {
+    private static MAX_LEADING_ZEROS_FORMAT_LENGTH;
+    static readonly DEFAULT_SAFE_NUMBER_OPTIONS: SafeNumberOptions;
+    static toFixedDecimalNumber(input: number | string, placesAfterPoint: number): number;
+    static leadingZeros(val: any, size: number): string;
+    static between(inTest: number, inP1: number, inP2: number): boolean;
+    static safeNumber(input: any, ifNotNumber?: number, useDefaultForNullAndUndefined?: boolean): number;
+    static safeNumberOpt(input: any, optionPart?: Partial<SafeNumberOptions>): number;
+    static numberCSVToList(inputCSV: string): number[];
+    static fitToWindow(val: number, b1: number, b2: number): number;
+    static groupNumbersIntoContiguousRanges(inputData: number[], minRangeSize?: number): SinglesAndRanges;
+    static distributeItemsEvenly(items: number, buckets: number): number[];
+    static createRange(minInclusive: number, maxExclusive: number, step?: number): number[];
+}
+interface SinglesAndRanges {
+    singles: number[];
+    ranges: NumberRange[];
+}
+interface NumberRange {
+    min: number;
+    max: number;
+}
+interface SafeNumberOptions {
+    ifNotNumber: number;
+    returnValueForNull: number;
+    returnValueForUndefined: number;
+    preParseCharacterMapping: Record<string, string>;
+}
+
+interface ParsedUrl {
+    href: string;
+    protocol: string;
+    host: string;
+    hostname: string;
+    port: string;
+    pathname: string;
+    search: string;
+    hash: string;
+}
+
+declare class TimeoutToken {
+    private title;
+    private timeoutMS;
+    private __timeoutTokenFlagField;
+    constructor(title: string, timeoutMS: number);
+    writeToLog(logLevel?: LoggerLevelName): void;
+    static isTimeoutToken(value: any): boolean;
+}
+
+declare class PromiseRatchet {
+    static resolveOnEvent<T>(evtSrc: any, okEvtNames: string[], errEvtNames?: string[], rval?: T): Promise<T>;
+    static timeout<T>(srcPromise: Promise<T>, title: string, timeoutMS: number): Promise<T | TimeoutToken>;
+    static createTimeoutPromise(title: string, timeoutMS: number): Promise<TimeoutToken>;
+    static wait(time: number): Promise<void>;
+    static dumpResult(result: any, autoDebug?: boolean): void;
+    static dumpError(err: any, autoDebug?: boolean): void;
+    static logErrorAndReturnNull(err: any, autoDebug?: boolean): void;
+    static runPromiseAndDump<T>(promise: Promise<T>): void;
+    static waitFor(testFunction: (n: number) => any, expectedValue: any, intervalMS: number, maxCycles: number, label?: string, count?: number): Promise<boolean>;
+    static runBoundedParallel<T>(promiseFn: Function, params: any[][], context: any, maxConcurrent?: number, logLevel?: LoggerLevelName): Promise<T[]>;
+    static runBoundedParallelSingleParam<T>(promiseFn: Function, params: any[], context: any, maxConcurrent?: number, logLevel?: LoggerLevelName): Promise<T[]>;
+    static asyncForEachSerial(array: any[], callback: Function): Promise<void>;
+    static asyncForEachParallel(array: any[], callback: Function): Promise<void>;
+    private constructor();
+}
+
+declare class RequireRatchet {
+    static isNullOrUndefined(ob: any): boolean;
+    static notNullOrUndefined(ob: any, name?: string): void;
+    static notNullUndefinedOrOnlyWhitespaceString(ob: string, name?: string): void;
+    static notNullUndefinedOrEmptyArray(ob: any[], name?: string): void;
+    static equal(ob1: any, ob2: any, message?: string): void;
+    static true(ob: boolean, message?: string): void;
+    static noNullOrUndefinedValuesInArray(arr: any[], expectedLength?: number, customMsg?: string): void;
+    static noNullOrUndefinedValuesInRestArgs(expectedLength: number, ...restArgs: any[]): void;
+    static constructorArgumentsMatchLengthAndAreNonNull(): void;
+}
+
+declare class SortRatchet {
+    private constructor();
+    static sortNullToTop<T>(a: T, b: T, bothNonNullSort: (c: T, d: T) => number): number;
+    static sortNullToBottom<T>(a: T, b: T, bothNonNullSort: (c: T, d: T) => number): number;
+    static nullSafeSort<T>(a: T, b: T, nullsOnTop: boolean, bothNonNullSort: (c: T, d: T) => number): number;
+    static sortNumericStringsAsNumbers(a: string | number, b: string | number, sortNonNumbersToTop?: boolean): number;
+}
+
+declare class StopWatch {
+    get createTime(): number;
+    private starts;
+    private ends;
+    private _createTime;
+    private _label;
+    private _labelIncludedInOutput;
+    constructor();
+    withLabel(val: string): StopWatch;
+    withLabelIncludedInOutput(val: boolean): StopWatch;
+    get label(): string;
+    set label(value: string);
+    get labelIncludedInOutput(): boolean;
+    set labelIncludedInOutput(value: boolean);
+    start(name: string): number;
+    stop(name: string): number;
+    reset(name: string): void;
+    hasTimer(name: string): boolean;
+    log(name?: string, shortForm?: boolean, logLevel?: LoggerLevelName): void;
+    logExpected(pctComplete: number, name?: string, shortForm?: boolean, logLevel?: LoggerLevelName): void;
+    timerNames(): string[];
+    dumpAll(separator?: string, shortForm?: boolean): string;
+    dump(name?: string, shortForm?: boolean): string;
+    dumpExpected(pctComplete: number, name?: string, shortForm?: boolean): string;
+    expectedRemainingMS(pctComplete: number, name?: string): number;
+    elapsedMS(name?: string): number;
+}
+
+declare class StringRatchet {
+    static readonly RFC_3986_RESERVED: string[];
+    static readonly DIGITS: string;
+    static readonly HEXITS: string;
+    static readonly UPPER_CASE_LATIN: string;
+    static readonly LOWER_CASE_LATIN: string;
+    static readonly CASE_INSENSITIVE_LATIN: string;
+    static stringIsInGivenAlphabet(input: string, alphabet: string): boolean;
+    static stringToUint8Array(val: string): Uint8Array;
+    static uint8ArrayToString(val: Uint8Array): string;
+    static attemptJsonParse(val: string): any;
+    static canParseAsJson(val: string): boolean;
+    static allUnique(input: string): boolean;
+    static allPermutationsOfLength(len: number, alphabet: string): string[];
+    static breakIntoBlocks(input: string, blockSize: number, separator: string): string;
+    static createShortUid(blockSize?: number, uniquesPerSecond?: number, radix?: number): string;
+    static createType4Guid(): string;
+    static createRandomHexString(len?: number): string;
+    static canonicalize(value: string): string;
+    static formatBytes(bytes: number, decimals?: number): string;
+    static safeString(input: any): string;
+    static stringContainsOnlyNumbers(input: string): boolean;
+    static stringContainsOnlyAlphanumeric(input: string): boolean;
+    static stringContainsOnlyHex(input: string): boolean;
+    static stringContainsOnly(inVal: string, validCharsIn: string): boolean;
+    static obscure(input: string, prefixLength?: number, suffixLength?: number): string;
+    static leadingZeros(inVal: any, size: number): string;
+    static trimToEmpty(input: string): string;
+    static trimToNull(input: string): string;
+    static trimAllStringPropertiesToNullInPlace<T>(input: T): T;
+    static trimAllStringPropertiesToEmptyInPlace<T>(input: T): T;
+    private static trimAllStringPropertiesInPlace;
+    static stripNonNumeric(input: string): string;
+    static csvSafe(input: any): string;
+    static stripNonAscii(value: string): string;
+    static replaceAll(value: string, src: string, dst: string): string;
+}
+
+declare class TimeZoneRatchet {
+    private timezoneIanaName;
+    static PACIFIC: TimeZoneRatchet;
+    constructor(timezoneIanaName: string);
+    get ianaName(): string;
+    currentHour(): number;
+    private toEpochSeconds;
+    startOfTodayEpochSeconds(): number;
+    startOfMatchingDayEpochSeconds(inputTS: number): number;
+    startOfMatchingDayEpochMS(inputTS: number): number;
+    startOfCurrentHourEpochSeconds(): number;
+    startOfCurrentMinuteEpochSeconds(): number;
+    startOfCurrentSecondEpochSeconds(): number;
+    startOfTodayEpochMS(): number;
+    dailySlotCount(slotWidthMs: number): number;
+    currentTimeSlotIdx(slotWidthMs: number): number;
+    matchingTimeSlotIdx(timestamp: number, slotWidthMs: number): number;
+    startOfCurrentSlotEpochMS(slotWidthMs: number): number;
+    startOfMatchingSlotEpochMS(timestamp: number, slotWidthMs: number): number;
+}
+
+declare class Uint8ArrayRatchet {
+    private constructor();
+    static mergeArrays(myArrays: Uint8Array[]): Uint8Array;
+    static deepEqual(arr1: Uint8Array, arr2: Uint8Array): boolean;
+}
+
+declare class WebStreamRatchet {
+    private constructor();
+    static webReadableStreamToUint8Array(stream: ReadableStream): Promise<Uint8Array>;
+    static webReadableStreamToString(stream: ReadableStream): Promise<string>;
+    static stringToWebReadableStream(input: string): ReadableStream;
+}
+
+interface LogMessage {
+    lvl: LoggerLevelName;
+    timestamp: number;
+    messageSource: string;
+    subsVars?: any[];
+    params?: Record<string, string | number | boolean>;
+}
+
+declare const LogMessageFormatType: {
+    readonly ClassicSingleLine: "ClassicSingleLine";
+    readonly StructuredJson: "StructuredJson";
+    readonly None: "None";
+};
+type LogMessageFormatType = (typeof LogMessageFormatType)[keyof typeof LogMessageFormatType];
+
+interface LogMessageProcessor {
+    label?(): string;
+    process(msg: LogMessage): LogMessage;
+}
+
+declare const LoggerOutputFunction: {
+    Console: string;
+    ConsoleNoDebug: string;
+    StdOut: string;
+};
+type LoggerOutputFunction = (typeof LoggerOutputFunction)[keyof typeof LoggerOutputFunction];
+
+interface LoggerOptions {
+    initialLevel?: LoggerLevelName;
+    formatType?: LogMessageFormatType;
+    trace?: string;
+    globalVars?: Record<string, string | number | boolean>;
+    outputFunction?: LoggerOutputFunction;
+    ringBufferSize?: number;
+    preProcessors?: LogMessageProcessor[];
+}
+
+interface LoggerMeta {
+    options: LoggerOptions;
+    loggerInstanceName: string;
+    loggerInstanceId: string;
+}
+
+interface LogMessageFormatter {
+    formatMessage(msg: LogMessage, meta: LoggerMeta): string;
+}
+
+declare class ClassicSingleLineLogMessageFormatter implements LogMessageFormatter {
+    formatMessage(msg: LogMessage, meta: LoggerMeta): string;
+}
+
+declare class LogMessageBuilder {
+    private wrapped;
+    constructor(lvl: LoggerLevelName, messageSource?: string);
+    clone(): LogMessageBuilder;
+    level(lvl: LoggerLevelName): LogMessageBuilder;
+    timestamp(val: number): LogMessageBuilder;
+    messageSource(val: string): LogMessageBuilder;
+    subVars(val: any[]): LogMessageBuilder;
+    params(val: Record<string, string | number | boolean>): LogMessageBuilder;
+    p(name: string, value: string | number | boolean): LogMessageBuilder;
+    toMessage(): LogMessage;
+}
+
+interface LogSnapshot {
+    logMessagesTruncated: number;
+    messages: LogMessage[];
+}
+
+declare class LoggerRingBuffer {
+    private _lastLogMessage;
+    private _buffer;
+    private _bufferIdx;
+    private _lastSnapshotIdx;
+    private _bufferSize;
+    constructor(size: number);
+    get currentIndex(): number;
+    get lastSnapshotIdx(): number;
+    set bufferSize(newSize: number);
+    getMessages(inStartFrom?: number, clear?: boolean, reverseSort?: boolean): LogMessage[];
+    takeSnapshot(): LogSnapshot;
+    getLastLogMessage(): LogMessage;
+    private clearRingBuffer;
+    addToRingBuffer(newMsg: LogMessage): void;
+}
+
+declare class LoggerInstance {
+    private loggerInstanceName;
+    private _guid;
+    private _loggerMeta;
+    private _ringBuffer;
+    private _formatter;
+    private _level;
+    private _handlerFunctionMap;
+    private _options;
+    constructor(loggerInstanceName: string, inOptions: LoggerOptions);
+    addPreProcessor(proc: LogMessageProcessor): LogMessageProcessor[];
+    get ringBuffer(): LoggerRingBuffer;
+    dumpConfigurationIntoLog(): void;
+    dumpOptionsIntoLog(): void;
+    get guid(): number;
+    changeRingBufferSize(newSize: number): void;
+    updateTracePrefix(newValue: string): void;
+    get options(): LoggerOptions;
+    set options(newOpts: LoggerOptions);
+    get level(): LoggerLevelName;
+    set level(newLevel: LoggerLevelName);
+    consoleLogPassThru(level: LoggerLevelName, ...input: any[]): void;
+    createLogMessage(level: LoggerLevelName, params: Record<string, string>, format: string, ...input: any[]): LogMessage;
+    formatMessage(msg: LogMessage): string;
+    formatMessages(msgs: LogMessage[]): string[];
+    recordMessageBuilder(msgBuild: LogMessageBuilder): string;
+    recordMessage(inMsg: LogMessage): string;
+    error(format: string, ...input: any[]): string;
+    errorP(...input: any[]): void;
+    warn(format: string, ...input: any[]): string;
+    warnP(...input: any[]): void;
+    info(format: string, ...input: any[]): string;
+    infoP(...input: any[]): void;
+    verbose(format: string, ...input: any[]): string;
+    verboseP(...input: any[]): void;
+    debug(format: string, ...input: any[]): string;
+    debugP(...input: any[]): void;
+    silly(format: string, ...input: any[]): string;
+    sillyP(...input: any[]): void;
+    logByLevel(level: LoggerLevelName, format: string, ...input: any[]): void;
+    importMessages(msgs: LogMessage[], prefixIn?: string, addTimestamp?: boolean): void;
+}
+
+declare class LoggerUtil {
+    private static LOG_LEVELS_IN_ORDER;
+    static handlerFunctionMap(outputFn?: LoggerOutputFunction): Map<LoggerLevelName, (...any: any[]) => void>;
+    static defaultHandlerFunction(): (...any: any[]) => void;
+    static levelIsEnabled(targetLevel: LoggerLevelName, currentEnabled: LoggerLevelName): boolean;
+}
+
+declare class Logger {
+    private static LOGGER_INSTANCE_MAP_GLOBAL_KEY;
+    private static GLOBAL_PROVIDER;
+    private static DEFAULT_OPTIONS;
+    static applyDefaultsToOptions(input?: LoggerOptions): LoggerOptions;
+    private static loggerInstances;
+    static changeDefaultOptions(input: LoggerOptions, retroactive?: boolean): void;
+    static getLogger(loggerName?: string, inOptions?: LoggerOptions): LoggerInstance;
+    static recordMessageBuilder(msgBuild: LogMessageBuilder): string;
+    static recordMessage(msg: LogMessage): string;
+    static formatMessages(msgs: LogMessage[]): string[];
+    static updateTracePrefix(newValue: string): void;
+    static changeRingBufferSize(newValue: number): void;
+    static getRingBuffer(): LoggerRingBuffer;
+    static dumpConfigurationIntoLog(): void;
+    static dumpOptionsIntoLog(): void;
+    static getLevel(): LoggerLevelName;
+    static setLevel(newLevel: LoggerLevelName): void;
+    static getOptions(): LoggerOptions;
+    static getMessages(inStartFrom?: number, clear?: boolean, reverseSort?: boolean): LogMessage[];
+    static consoleLogPassThru(level: LoggerLevelName, ...input: any[]): void;
+    static error(format: string, ...input: any[]): string;
+    static errorP(...input: any[]): void;
+    static warn(format: string, ...input: any[]): string;
+    static warnP(...input: any[]): void;
+    static info(format: string, ...input: any[]): string;
+    static infoP(...input: any[]): void;
+    static verbose(format: string, ...input: any[]): string;
+    static verboseP(...input: any[]): void;
+    static debug(format: string, ...input: any[]): string;
+    static debugP(...input: any[]): void;
+    static silly(format: string, ...input: any[]): string;
+    static sillyP(...input: any[]): void;
+    static takeSnapshot(): LogSnapshot;
+    static logByLevel(level: LoggerLevelName, format: string, ...input: any[]): void;
+    static importMessages(msgs: LogMessage[], prefixIn?: string, addTimestamp?: boolean): void;
+    static getLastLogMessage(): LogMessage;
+}
+
+declare class NoneLogMessageFormatter implements LogMessageFormatter {
+    formatMessage(msg: LogMessage, meta: LoggerMeta): string;
+}
+
+declare class StructuredJsonLogMessageFormatter implements LogMessageFormatter {
+    formatMessage(msg: LogMessage, meta: LoggerMeta): string;
+}
+
+interface ArchiveEmailResult<R> {
+    raw: R;
+    error: string;
+    meta: Record<string, any>;
+}
+
+interface EmailAttachment {
+    filename?: string;
+    contentType?: string;
+    base64Data?: string;
+}
+
+interface ReadyToSendEmail {
+    destinationAddresses?: Array<string>;
+    bccAddresses?: Array<string>;
+    attachments?: Array<EmailAttachment>;
+    fromAddress?: string;
+    txtMessage?: string;
+    htmlMessage?: string;
+    subject?: string;
+    fromName?: string;
+    doNotAutoBcc?: boolean;
+    doNotArchive?: boolean;
+}
+
+interface ResolvedReadyToSendEmail extends ReadyToSendEmail {
+    srcDestinationAddresses?: string[];
+    srcBccAddresses?: string[];
+}
+
+interface MailSendingProvider<T, R> {
+    sendEmail(mail: ResolvedReadyToSendEmail): Promise<T>;
+    archiveEmail?(mail: ResolvedReadyToSendEmail, rawSendResult: T): Promise<R>;
+}
+
+interface RatchetTemplateRenderer {
+    renderTemplate(templateName: string, context: any, layoutName?: string, partialNames?: string[]): Promise<string>;
+    renderTemplateDirect(templateValue: string, context: any, layoutName?: string): Promise<string>;
+}
+
+interface MailerConfig<T, R> {
+    provider: MailSendingProvider<T, R>;
+    defaultSendingAddress?: string;
+    autoBccAddresses?: string[];
+    templateRenderer?: RatchetTemplateRenderer;
+    allowedDestinationEmails?: RegExp[];
+    maxMessageBodySizeInBytes?: number;
+    maxAttachmentSizeInBase64Bytes?: number;
+}
+
+interface SendEmailResult<T, R> {
+    request: ReadyToSendEmail;
+    resolved: ResolvedReadyToSendEmail;
+    success: boolean;
+    rawResult: T;
+    error: string;
+    meta: Record<string, any>;
+    archiveResults: ArchiveEmailResult<R>;
+}
+
+interface MailerLike<T, R> {
+    fillEmailBody(rts: ReadyToSendEmail, context: any, htmlTemplateName: string, txtTemplateName?: string, layoutName?: string, partialNames?: string[]): Promise<ReadyToSendEmail>;
+    fillEmailBodyAndSend(rts: ReadyToSendEmail, context: any, htmlTemplateName: string, txtTemplateName?: string, layoutName?: string, partialNames?: string[]): Promise<SendEmailResult<T, R>>;
+    filterEmailsToValid(emails: string[]): string[];
+    applyLimitsToBodySizesIfAnyInPlace(rts: ResolvedReadyToSendEmail): void;
+    applyLimitsToAttachmentSizesIfAnyInPlace(rts: ResolvedReadyToSendEmail): void;
+    sendEmail(inRts: ReadyToSendEmail): Promise<SendEmailResult<T, R>>;
+}
+
+declare class MailerUtil {
+    static readonly EMAIL: RegExp;
+    constructor();
+    static convertResolvedReadyToSendEmailToRaw(rts: ResolvedReadyToSendEmail): string;
+    static validEmail(email: string): boolean;
+}
+
+declare class Mailer<T, R> implements MailerLike<T, R> {
+    private config;
+    constructor(config: MailerConfig<T, R>);
+    fillEmailBody(rts: ReadyToSendEmail, context: any, htmlTemplateName: string, txtTemplateName?: string, layoutName?: string, partialNames?: string[]): Promise<ReadyToSendEmail>;
+    fillEmailBodyAndSend(rts: ReadyToSendEmail, context: any, htmlTemplateName: string, txtTemplateName?: string, layoutName?: string, partialNames?: string[]): Promise<SendEmailResult<T, R>>;
+    filterEmailsToValid(emails: string[]): string[];
+    private archiveEmailIfConfigured;
+    applyLimitsToBodySizesIfAnyInPlace(rts: ResolvedReadyToSendEmail): void;
+    applyLimitsToAttachmentSizesIfAnyInPlace(rts: ResolvedReadyToSendEmail): void;
+    sendEmail(inRts: ReadyToSendEmail): Promise<SendEmailResult<T, R>>;
+    resolveReadyToSendEmail(inRts: ReadyToSendEmail): Promise<ResolvedReadyToSendEmail>;
+}
+
+declare class TestMailSendingProvider implements MailSendingProvider<string, string> {
+    failEmails: string[];
+    constructor(failEmails?: string[]);
+    sendEmail(mail: ResolvedReadyToSendEmail): Promise<string>;
+    archiveEmail(mail: ResolvedReadyToSendEmail): Promise<string>;
+}
+
+interface LocalIpProvider {
+    currentLocalIpAddress(): string;
+}
+
+declare class BrowserLocalIpProvider implements LocalIpProvider {
+    private currentIp;
+    constructor();
+    ready(): boolean;
+    currentLocalIpAddress(): string;
+}
+
+declare class FixedLocalIpProvider implements LocalIpProvider {
+    private fixed;
+    constructor(fixed: string);
+    currentLocalIpAddress(): string;
+}
+
+declare class NetworkRatchet {
+    private static LOCAL_IP;
+    static findLocalIp(useCache?: boolean): Promise<string>;
+    static parseUrl(href: string): ParsedUrl;
+    private static updateLocalIP;
+    private static grepSDP;
+    private static updateAddressList;
+}
+
+declare class RestfulApiHttpError<T = void> extends Error {
+    private static readonly RATCHET_RESTFUL_API_HTTP_ERROR_FLAG_KEY;
+    private _httpStatusCode;
+    private _errors;
+    private _detailErrorCode;
+    private _endUserErrors;
+    private _details;
+    private _requestId;
+    private _wrappedError;
+    constructor(...errors: string[]);
+    static combineErrorStringsWithDefault(errors: string[], defMessage?: string): string;
+    setFormattedErrorMessage(format: string, ...input: any[]): void;
+    withFormattedErrorMessage(format: string, ...input: any[]): RestfulApiHttpError<T>;
+    withHttpStatusCode(httpStatusCode: number): RestfulApiHttpError<T>;
+    withErrors(errors: string[]): RestfulApiHttpError<T>;
+    withDetailErrorCode(detailErrorCode: number): RestfulApiHttpError<T>;
+    withEndUserErrors(endUserErrors: string[]): RestfulApiHttpError<T>;
+    withDetails(details: T): RestfulApiHttpError<T>;
+    withRequestId(requestId: string): RestfulApiHttpError<T>;
+    withWrappedError(err: Error): RestfulApiHttpError<T>;
+    isWrappedError(): boolean;
+    static wrapError<T = void>(err: Error): RestfulApiHttpError<T>;
+    static objectIsRestfulApiHttpError(obj: any): boolean;
+    get httpStatusCode(): number;
+    get errors(): string[];
+    get detailErrorCode(): number;
+    get endUserErrors(): string[];
+    get details(): T;
+    get requestId(): string;
+    get wrappedError(): Error;
+    set httpStatusCode(value: number);
+    set errors(value: string[]);
+    set detailErrorCode(value: number);
+    set endUserErrors(value: string[]);
+    set details(value: T);
+    set requestId(value: string);
+    set wrappedError(value: Error);
+    static errorIsX0x(errIn: Error, xClass: number): boolean;
+    static errorIs40x(err: Error): boolean;
+    static errorIs50x(err: Error): boolean;
+}
+
+declare class GoogleRecaptchaRatchet {
+    private static readonly GOOGLE_VERIFY_URL;
+    static verifyRecaptchaToken(keySecret: string, token: string, fetchFn?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>): Promise<boolean>;
+}
+
+declare class TwilioRatchet {
+    private accountSid;
+    private authToken;
+    private outBoundNumber;
+    static readonly TWILLIO_BASE_API_URL: string;
+    constructor(accountSid: string, authToken: string, outBoundNumber: string);
+    static sendMessageDirect(accountSid: string, authToken: string, outBoundNumber: string, recipientPhoneNumbers: string[], message: string): Promise<any[]>;
+    static generateTwilioBasicAuth(sid: string, authToken: string): string;
+    sendMessage(recipientPhoneNumbers: string[], message: string): Promise<any[]>;
+    static isValidE164Number(num: string): boolean;
+}
+
+declare class TwilioVerifyRatchet {
+    private accountSid;
+    private authToken;
+    private serviceSid;
+    static readonly TWILLIO_BASE_VERIFY_URL: string;
+    constructor(accountSid: string, authToken: string, serviceSid: string);
+    sendVerificationTokenUsingTwilioVerify(recipientPhoneNumber: string): Promise<string>;
+    simpleCheckVerificationTokenUsingTwilioVerify(recipientPhoneNumber: string, code: string): Promise<boolean>;
+    checkVerificationTokenUsingTwilioVerify(recipientPhoneNumber: string, code: string): Promise<TwilioVerifyCheckResponse>;
+}
+interface TwilioVerifyCheckResponse {
+    status: string;
+    payee: string;
+    date_updated: string;
+    account_sid: string;
+    to: string;
+    amount: string;
+    valid: boolean;
+    sid: string;
+    date_created: string;
+    service_sid: string;
+    channel: string;
+}
+
+interface TransformRule {
+    transform(value: any, isKey: boolean, context: any): any;
+}
+
+declare class BuiltInTransforms {
+    static keysOnly(rule: TransformRule): TransformRule;
+    static valuesOnly(rule: TransformRule): TransformRule;
+    static stringReplaceTransform(input: string, output: string): TransformRule;
+    static stripStringTransform(input: string): TransformRule;
+    static retainAll(input: string[]): TransformRule;
+    static removeAll(input: string[]): TransformRule;
+    static snakeToCamelCase(): TransformRule;
+    static stringToNumber(): TransformRule;
+    static camelToSnakeCase(): TransformRule;
+    static concatenateToNewField(newFieldName: string, oldFieldNamesInOrder: string[], abortIfFieldMissing?: boolean): TransformRule;
+    static numberToBool(fieldNames: string[]): TransformRule;
+    static boolToNumber(fieldNames: string[]): TransformRule;
+    static makeDuplicateField(oldName: string, newName: string): TransformRule;
+    static addField(name: string, valueToAdd: string): TransformRule;
+    static reformatDateFields(fieldNames: string[], oldFormat: string, newFormat: string): TransformRule;
+}
+
+declare class TransformRatchet {
+    static transform(toTransform: any, rules?: TransformRule[]): any;
+    private static transformGeneric;
+    private static applyTransformToObject;
+    private static applyTransformToPrimitive;
+}
+
+declare const TransactionFinalState: {
+    Success: string;
+    RolledBack: string;
+    RollbackFailed: string;
+};
+type TransactionFinalState = (typeof TransactionFinalState)[keyof typeof TransactionFinalState];
+
+interface TransactionResult<T> {
+    finalContext: T;
+    finalState: TransactionFinalState;
+    error?: any;
+    rollbackError?: any;
+    errorStep?: number;
+    rollbackErrorStep?: number;
+}
+
+interface TransactionConfiguration<T> {
+    stepLogLevel?: LoggerLevelName;
+    executeAfterRollback?(result: TransactionResult<T>): Promise<void>;
+    executeAfterRollbackFailure?(result: TransactionResult<T>): Promise<void>;
+}
+
+interface TransactionStep<T> {
+    execute(context: T, stepNumber?: number): Promise<void>;
+    rollback?(context: T, stepNumber?: number): Promise<void>;
+    name?: string;
+}
+
+declare class TransactionRatchet {
+    static execute<T>(steps: TransactionStep<T>[], initialContext: T, inConfiguration?: TransactionConfiguration<T>): Promise<TransactionResult<T>>;
+}
+
+export { type ArchiveEmailResult, ArrayRatchet, Base64Ratchet, BooleanRatchet, BrowserLocalIpProvider, type BuildInformation, BuiltInTransforms, ClassicSingleLineLogMessageFormatter, type CommonJwtToken, type ComparisonFunction, CompositeLastSuccessProvider, DateRatchet, DurationRatchet, type EmailAttachment, EnumRatchet, ErrorRatchet, EsmRatchet, ExpiredJwtHandling, ExpiringObject, ExpiringObjectConfig, FixedLocalIpProvider, GeolocationRatchet, GlobalRatchet, GoogleRecaptchaRatchet, Histogram, type HistogramEntry, JwtRatchet, type JwtRatchetLike, type JwtTokenBase, KeyValue, type LastSuccessProvider, type Line2d, type LocalIpProvider, type LogMessage, LogMessageBuilder, LogMessageFormatType, type LogMessageFormatter, type LogMessageProcessor, type LogSnapshot, Logger, LoggerInstance, LoggerLevelName, type LoggerMeta, type LoggerOptions, LoggerOutputFunction, LoggerRingBuffer, LoggerUtil, type MailSendingProvider, Mailer, type MailerConfig, type MailerLike, MailerUtil, MapRatchet, type MatchReport, NetworkRatchet, No, NoneLogMessageFormatter, type NumberRange, NumberRatchet, type ParsedUrl, type Plane2d, type Point2d, type PolyLine2d, PromiseRatchet, Ratchet2d, type RatchetGeoLocation, RatchetInfo, type RatchetLocationBounds, type RatchetLocationBoundsMap, type RatchetLocationBoundsMapEntry, type RatchetTemplateRenderer, type ReadyToSendEmail, RequireRatchet, type ResolvedReadyToSendEmail, RestfulApiHttpError, type SafeNumberOptions, type SendEmailResult, type SinglesAndRanges, SortRatchet, StopWatch, StringRatchet, StructuredJsonLogMessageFormatter, TestMailSendingProvider, TimeZoneRatchet, TimeoutToken, type TransactionConfiguration, TransactionFinalState, TransactionRatchet, type TransactionResult, type TransactionStep, TransformRatchet, type TransformRule, TwilioRatchet, type TwilioVerifyCheckResponse, TwilioVerifyRatchet, Uint8ArrayRatchet, WebStreamRatchet };