interface RequiredInterface<T> {
    filePath: string,
    name: string,
    exports: T
}

type RequireAsyncReturn<T> = PlataPromise<RequiredInterface<T>>
type RequireFolderReturn<T> = PlataPromise<RequiredInterface<T>[]>
type RequiredFolder<T> = Awaited<RequireFolderReturn<T>>

type StringKeyOfObject<T extends Object> = Exclude<{
    [name in keyof T]: 
		name extends string ? name
		: name extends number ? `${name}`
		: undefined
}[keyof T], undefined>;

type AnyRecord<T> = {
    [P in string]: T;
}
type LooseAutocomplete<T extends string> = T | (string & {})

type Replace<T, O, U> = T extends O ? Exclude<T, O> | U : T

type PlataEnvDefaults = "prod" | "homolog" | "debug"
type PlataEnv = LooseAutocomplete<PlataEnvDefaults>

type PlataFunctionWrapperReturn<F extends (...a: any) => any, T> = (...a: Parameters<F>) => T

type RemovePlataResult<T> = T extends PlataResult<infer U> ? Exclude<U, PlataError> : T

type RemovePlataResultOnArray<T> =
    T extends [ infer U ] ? [ RemovePlataResult<Awaited<U>> ]
    : T extends [ infer U, ...infer V ] ? [ RemovePlataResult<Awaited<U>>, ...RemovePlataResultOnArray<V> ]
    : []
    //: T extends Promise<infer U>[] ? RemovePlataResult<U>[]
    //: never
    
;

type RemovePlataResultOnPromiseAll<T> =
    RemovePlataResultOnArray<T> 
    // extends [ infer U ] ? RemovePlataResultOnArray<T>
    // : T extends Promise<infer U>[] ? 'RemovePlataResult<U>'
    // : 'never'
;

interface PlataProcess {
    _plata_cache?: Map<() => unknown, unknown>
}

type Prettify<T> = {
    [K in keyof T]: T[K];
} & {};

interface PlataEnvAutoComplete extends NodeJS.ProcessEnv {
    ENV?: PlataEnv
    PORT?: string
    _PLATA_API_ROOT?: string
    _PLATA_API_SSL_KEY?: string
    _PLATA_API_SSL_CERT?: string
    _PLATA_API_SSL_PASS?: string
    _PLATA_API_JSON_SIZE?: string
    _PLATA_WORKER_NAME?: string
    _PLATA_WORKER_TYPE?: 'WORKER' | 'CONTROLLER'
    _PLATA_SQL_CACHETABLE?: string
    _PLATA_SQL_CACHETABLETIME?: string
}

interface PlataRuntime {

}

interface Plata extends PlataRuntime {
}

declare const Plata: Plata

declare const process: NodeJS.Process & PlataProcess

interface EnvConfig {
    env: PlataEnv
}

interface PlataError {
    errorID: string
    msg: string,
    error?: any
}

type MaybePlataError = null | PlataError

type PlataResult<T> = (T & { errorID?: undefined }) | PlataError

type PlataPromise<T> = Promise<PlataResult<T>>

interface PlataRef<T> {
    readonly value: T
    applyTo<T extends object, K extends keyof T = keyof T>(key: K, target: Omit<T, K>): Readonly<T>
}

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

type DictionaryRecord<K extends string | number, T> = {
    [key in K]: T
}

interface PlataEnvConfig {
    env: PlataEnv
}

type DeepWritable<T extends {}> = Prettify<{
    -readonly [K in keyof T]: T[K] extends Dictionary<any> ? 
        T[K] extends Date ? Date 
        : T[K] extends Brand<infer R> ? Brand<R>
        : DeepWritable<T[K]> 
    : T[K]
}>

type ArrayCombine<T extends readonly any[]> = 
    T extends readonly [ infer U extends T[number] ] ? U
    : T extends readonly [ infer U extends T[number], ...infer R] ? U & ArrayCombine<R>
    : never
;

interface Brands {

}

type Brand<K extends keyof Brands> = Brands[K] & { z__brand: K }

interface PType {
    checkType<T>(a: T): unknown
    testType<R, T>(a: T, result: T extends R ? true : false)
}

declare const PType: PType

interface PlataClosable {
    close(): Promise<void> | void
}

type PlataDisposable<T extends PlataClosable> = T & Disposable & AsyncDisposable