/// <reference types="node" />
import { PortableTextBlock } from '@portabletext/types';

interface IResolveServiceOptions {
    optional?: boolean;
}
interface IServiceLocator {
    register<T>(name: string, service: T): void;
    resolve<T>(name: string, options?: IResolveServiceOptions): T;
}

type LocalizedField<T> = {
    [key: string]: T;
};

declare enum LogLevel {
    Debug = "debug",
    Info = "info",
    Warn = "warn",
    Error = "error",
    Fatal = "fatal"
}
declare enum MetaSerializationType {
    None = "none",
    JSON = "json"
}
interface ILoggerProvider {
    debug(loggerName: string, message: string, meta?: any): void;
    info(loggerName: string, message: string, meta?: any): void;
    warn(loggerName: string, message: string, meta?: any): void;
    error(loggerName: string, message: string, meta?: any): void;
    fatal(loggerName: string, message: string, meta?: any): void;
    exception(loggerName: string, message: string, error: Error, meta?: any): void;
}
interface ILogger {
    debug(message: string, meta?: any): void;
    info(message: string, meta?: any): void;
    warn(message: string, meta?: any): void;
    error(message: string, meta?: any): void;
    fatal(message: string, meta?: any): void;
    exception(message: string, error: Error, meta?: any): void;
}

declare const logMemoryUsage: () => void;

declare const processArrayDifferences: <TItem, TInputItem, TId>({ elements, elementIdSelector, desiredItems, desiredItemSelector, }: {
    elements: TItem[];
    elementIdSelector: (item: TItem) => TId;
    desiredItems: TInputItem[];
    desiredItemSelector: (item: TInputItem) => TId;
}) => {
    missingElements: TInputItem[];
    exceedingElements: TItem[];
    correspondingElements: {
        current: TItem;
        desired: TInputItem;
    }[];
};
declare const processArrayItemMove: <TItem>(items: TItem[], input: {
    oldIndex: number;
    newIndex: number;
}) => {
    item: TItem;
    newIndex: number;
    oldIndex: number;
    isMoved: boolean;
}[];

type LoggerInstance = {
    options: LoggerOptions;
    provider: ILoggerProvider;
};
type LoggerOptions = {
    enabled: boolean;
    level: LogLevel;
    loggerName?: string;
    serialization: MetaSerializationType;
    maxMetaLength?: number;
};
declare class Log {
    private static readonly container;
    static configure(instance: LoggerInstance): void;
    static getLogger(loggerName: string): ILogger;
}

declare class ConsoleLogger implements ILoggerProvider {
    debug(loggerName: string, message: string, meta?: any): void;
    info(loggerName: string, message: string, meta?: any): void;
    warn(loggerName: string, message: string, meta?: any): void;
    error(loggerName: string, message: string, meta?: any): void;
    fatal(loggerName: string, message: string, meta?: any): void;
    exception(loggerName: string, message: string, error: Error, meta?: any): void;
}

type StdoutLoggerSettings = {
    includeOpenTelemetryContext?: boolean;
};
declare class StdoutLogger implements ILoggerProvider {
    private readonly logger;
    constructor(settings?: StdoutLoggerSettings);
    debug(loggerName: string, message: string, meta?: any): void;
    info(loggerName: string, message: string, meta?: any): void;
    warn(loggerName: string, message: string, meta?: any): void;
    error(loggerName: string, message: string, meta?: any): void;
    fatal(loggerName: string, message: string, meta?: any): void;
    exception(loggerName: string, message: string, error: Error, meta?: any): void;
}

type AppServiceReference = {
    serviceName: string;
    appName: string;
    roleName: string;
    environmentName: string;
};

type DatadogApiSettings = {
    apiKey: string;
    site: string;
};
type DatadogLoggingSettings = {
    service: AppServiceReference;
    datadog: DatadogApiSettings;
};
declare class DatadogLogger implements ILoggerProvider {
    private readonly logger;
    private readonly serviceMeta;
    constructor(settings: DatadogLoggingSettings);
    private enrichMeta;
    debug(loggerName: string, message: string, meta?: any): void;
    info(loggerName: string, message: string, meta?: any): void;
    warn(loggerName: string, message: string, meta?: any): void;
    error(loggerName: string, message: string, meta?: any): void;
    fatal(loggerName: string, message: string, meta?: any): void;
    exception(loggerName: string, message: string, error: Error, meta?: any): void;
}

type FileLoggerSettings = {
    folder?: string;
};
type FileLoggingSettings = {
    service: AppServiceReference;
    files?: FileLoggerSettings;
};
declare class FileLogger implements ILoggerProvider {
    private readonly logger;
    private readonly serviceMeta;
    constructor(settings: FileLoggingSettings);
    private enrichMeta;
    debug(loggerName: string, message: string, meta?: any): void;
    info(loggerName: string, message: string, meta?: any): void;
    warn(loggerName: string, message: string, meta?: any): void;
    error(loggerName: string, message: string, meta?: any): void;
    fatal(loggerName: string, message: string, meta?: any): void;
    exception(loggerName: string, message: string, error: Error, meta?: any): void;
}

interface ITreeNode<TKey, TValue> {
    id: TKey;
    value: TValue;
    children: ITreeNode<TKey, TValue>[];
}
interface ITree<TKey, TValue> {
    root: ITreeNode<TKey, TValue>[];
}

type RichText = PortableTextBlock[];
type Optional<T> = T | undefined;

declare const range: (start: number, end: number) => number[];
declare const indexes: (startIndex: number, count: number) => number[];
interface Dict<TVal> {
    [key: string]: TVal;
}
declare const toDict: <TVal>(array: TVal[], keySelector: (value: TVal) => string) => Dict<TVal>;
declare const toItemsDict: <TItem, TVal>(array: TItem[], keySelector: (value: TItem) => string, elementSelector: (value: TItem) => TVal) => Dict<TVal>;
declare const toArrayDict: <TVal>(array: TVal[], keySelector: (value: TVal) => string) => Dict<TVal[]>;
declare const toMap: <TKey, TVal>(array: TVal[], key: (val: TVal) => TKey) => Map<TKey, TVal>;
declare const toItemsMap: <TItem, TKey, TVal>(array: TItem[], key: (val: TItem) => TKey, element: (val: TItem) => TVal) => Map<TKey, TVal>;
declare const last: <T>(arr: T[]) => T;
declare const first: <T>(arr: T[]) => T;
type ArrayComparer<T> = (a: T, b: T) => number;
declare const byField: <T>(selector: (value: T) => any) => ArrayComparer<T>;
declare const byFieldDesc: <T>(selector: (value: T) => any) => ArrayComparer<T>;
declare const sort: <T>(array: T[], ...comparers: ArrayComparer<T>[]) => T[];
declare const notUndefined: <T>(x: T | undefined) => x is T;
declare const notNull: <T>(x: T | null) => x is T;
declare const selectMany: <TArr, TVal>(array: TArr[], selector: (value: TArr) => TVal[]) => TVal[];
declare const flatten: <T>(array: T[][]) => T[];
declare const distinct: <T>(values: T[]) => T[];
declare const distinctElements: <T>(values: T[], comparer: (value: T) => any) => T[];
declare const jsonDistinct: <T>(values: T[]) => T[];
declare const iterate: <T>(values: T[], action: (item: T, next?: T | undefined, prev?: T | undefined) => void) => void;
declare const groupBy: <TKey, TValue>(values: TValue[], keySelector: (value: TValue) => TKey) => Map<TKey, TValue[]>;
declare const subArrays: <T>(array1: T[], array2: T[], eqFn: (a: T, b: T) => boolean) => T[];

declare const testInternetConnection: (options?: {
    healthCheckUrls?: string[];
}) => Promise<{
    status: string;
    details?: undefined;
} | {
    status: string;
    details: ({
        status: string;
        message?: undefined;
    } | {
        status: string;
        message: any;
    })[];
}>;

type TimeUnit = "years" | "months" | "days" | "hours" | "minutes" | "seconds" | "milliseconds";
declare const addTime: (date: Date, offset: {
    value: number;
    unit: TimeUnit;
}) => Date;
declare const subtractTime: (date: Date, offset: {
    value: number;
    unit: TimeUnit;
}) => Date;
declare function floorDateToSecond(date: Date): Date;

declare const csvParse: (data: string | string[] | Buffer, separator?: string) => Record<string, any>[];
interface CsvColumnDefinition<T> {
    name: string;
    value: (item: T) => any;
}
type CsvBuildOptions = {
    delimiter?: string;
};
declare const csvBuild: <T>(data: T[], columns: CsvColumnDefinition<T>[], options?: CsvBuildOptions) => string;

declare const getDirectoryFilePaths: (directoryPath: string, options?: {
    recursive?: boolean;
}) => Promise<string[]>;

declare const joinPath: (...paths: string[]) => string;
declare const splitPath: (filePath: string) => string[];
declare const ensureDirectory: (path: string) => void;
declare const getDirectoryPath: (filePath: string) => string;
declare const createDayPath: (d?: Date, separator?: string) => string;

declare const trimStart: (str: string, value: string) => string;
declare const trimEnd: (str: string, value: string) => string;
declare const trim: (str: string, value: string) => string;
declare const camelToSnakeCase: (str: string) => string;
declare const camelToKebabCase: (str: string) => string;
declare const toCamelCase: (str: string) => string;
declare const toTitleCase: (str: string) => string;
declare const ensureTailingSlash: (value: string) => string;
declare const ensureStartSlash: (value: string) => string;
declare const multipleSplit: (str: string, separators: string[]) => string[];
declare const truncateString: (str: string, maxLength: number, filler?: string) => string;

type ReplaceUndefinedWithNull<T> = T extends undefined ? null : T extends (infer U)[] ? ReplaceUndefinedWithNull<U>[] : T extends object ? {
    [K in keyof T]: ReplaceUndefinedWithNull<T[K]>;
} : T;

declare const removeUndefinedProps: <T extends Record<string, any>>(obj: T, options?: {
    recursive?: boolean;
}) => T;
declare const isNullOrUndefined: (value: any) => boolean;
declare const buildObject: <T>(...props: {
    key: string;
    value: any;
}[]) => T;
declare const mergeDeep: <T>(a: any, b: any) => T;
declare const jsonSerialize: (obj: any, options?: {
    removeNonSerializableObjects?: boolean;
    removeCircularReferences?: boolean;
    stripBinaryData?: boolean;
    maxStringsLength?: number;
    prettify?: boolean;
}) => string;
declare function replaceUndefinedWithNull<T>(obj: T): ReplaceUndefinedWithNull<T>;

declare const encodeUtf8: (value: Uint8Array) => string;
declare const decodeUtf8: (value: string) => Buffer;
declare const encodeBase64: (value: Uint8Array) => string;
declare const decodeBase64: (value: string) => Buffer;

interface StateMachineOptions {
    readonly allowedTags?: Set<string>;
    readonly disallowedTags?: Set<string>;
    readonly tagReplacementText: string;
    readonly encodePlaintextTagDelimiters: boolean;
}
declare function stripTags(text: string, options?: Partial<StateMachineOptions>): string;

declare const maskVariable: (value: string | undefined, unmaskedLength?: number) => string;

declare const pluralize: (word: string) => string;

declare function sleep(ms: number): Promise<unknown>;
declare const mapAsync: <T, R>(array: T[], callback: (value: T, index: number, array: T[]) => Promise<R>) => Promise<R[]>;

type TreeNodeBuilder<TKey, TRecord, TTreeNode extends ITreeNode<TKey, TRecord>> = {
    idSelector: (record: TRecord) => TKey;
    parentIdSelector: (record: TRecord) => TKey | undefined;
    additionalPropsBuilder?: (record: TRecord, ancestors: TRecord[], children: TRecord[]) => Promise<Omit<TTreeNode, "id" | "children" | "value">>;
};
declare const buildTree: <TKey, TRecord, TTreeNode extends ITreeNode<TKey, TRecord>, TTree extends ITree<TKey, TRecord>>(data: TRecord[], nodeBuilder: TreeNodeBuilder<TKey, TRecord, TTreeNode>) => Promise<TTree>;

declare const mapOrThrow: <T>({ mapper, throw: throwFn, }: {
    mapper: () => T | undefined;
    throw: () => void;
}) => T;

declare const newUuid: () => string;
declare const generateHash: (length: number) => string;

declare function serializeQueryString(obj: {
    [key: string]: any;
}): string;
declare const joinUrl: (base: string, path: string) => string;
declare const buildUrl: (path: string, query: {
    [key: string]: any;
}) => string;
declare function deserializeQueryString(queryString: string): {
    [key: string]: any;
};
declare const getQueryParameter: (name: string, location?: Location) => any;
declare const updateQueryParameters: (queryString: string, params: {
    [key: string]: any;
}) => string;

interface ExcelColumnDefinition<T> {
    value: (row: T) => any;
    header: string;
    headerSize?: number;
}
type ExcelSheetDefinition<T> = {
    sheetName: string;
    data: T[];
    columns: ExcelColumnDefinition<T>[];
};
declare const excelBuild: <T>(...sheets: ExcelSheetDefinition<T>[]) => ArrayBuffer;
declare const parseExcelRaw: (file: string | ArrayBuffer) => {
    name: string;
    data: any[][];
}[];
declare enum ExcelKeyTransform {
    Lower = "lower",
    Upper = "upper"
}
type ParsedExcelSheet = ReturnType<typeof parseExcelRaw>[number];
type ExcelParseOptions = {
    keysTransform?: ExcelKeyTransform;
    sheetIndex?: number;
    dateColumns?: string[];
    sheetFilter?: (sheet: ParsedExcelSheet) => boolean;
};
declare const excelParse: (file: string | ArrayBuffer, options?: ExcelParseOptions) => any;

export { AppServiceReference, ConsoleLogger, CsvBuildOptions, CsvColumnDefinition, DatadogLogger, Dict, ExcelColumnDefinition, ExcelKeyTransform, ExcelParseOptions, ExcelSheetDefinition, FileLogger, ILogger, ILoggerProvider, IResolveServiceOptions, IServiceLocator, ITree, ITreeNode, LocalizedField, Log, LogLevel, MetaSerializationType, Optional, RichText, StdoutLogger, TimeUnit, TreeNodeBuilder, addTime, buildObject, buildTree, buildUrl, byField, byFieldDesc, camelToKebabCase, camelToSnakeCase, createDayPath, csvBuild, csvParse, decodeBase64, decodeUtf8, deserializeQueryString, distinct, distinctElements, encodeBase64, encodeUtf8, ensureDirectory, ensureStartSlash, ensureTailingSlash, excelBuild, excelParse, first, flatten, floorDateToSecond, generateHash, getDirectoryFilePaths, getDirectoryPath, getQueryParameter, groupBy, indexes, isNullOrUndefined, iterate, joinPath, joinUrl, jsonDistinct, jsonSerialize, last, logMemoryUsage, mapAsync, mapOrThrow, maskVariable, mergeDeep, multipleSplit, newUuid, notNull, notUndefined, pluralize, processArrayDifferences, processArrayItemMove, range, removeUndefinedProps, replaceUndefinedWithNull, selectMany, serializeQueryString, sleep, sort, splitPath, stripTags, subArrays, subtractTime, testInternetConnection, toArrayDict, toCamelCase, toDict, toItemsDict, toItemsMap, toMap, toTitleCase, trim, trimEnd, trimStart, truncateString, updateQueryParameters };