clientnode 3.0.834 → 3.0.838

package/type.d.ts

@@ -1,11 +1,12 @@
 /// <reference types="node" />
-import { Stats } from 'fs';
+import { Dirent as DirectoryEntry, Stats as FileStats } from 'fs';
 import Tools from './index';
 import { DefinedSymbol, ThrowSymbol, UndefinedSymbol } from './testHelper';
-export declare type AnyFunction = (...parameters: Array<any>) => any;
+export declare type AnyFunction = (..._parameters: Array<any>) => any;
 export declare type FirstParameter<FunctionType extends AnyFunction> = Parameters<FunctionType>[0];
 export declare type SecondParameter<FunctionType extends AnyFunction> = Parameters<FunctionType>[1];
-export declare type ParametersExceptFirst<FunctionType> = FunctionType extends (parameter: any, ...additionalParameters: infer AdditionalParameters) => any ? AdditionalParameters : [
+export declare type ThirdParameter<FunctionType extends AnyFunction> = Parameters<FunctionType>[2];
+export declare type ParametersExceptFirst<FunctionType> = FunctionType extends (_parameter: any, ..._additionalParameters: infer AdditionalParameters) => any ? AdditionalParameters : [
 ];
 export declare type FunctionTestTuple<FunctionType extends AnyFunction> = [
     ReturnType<FunctionType>,
@@ -15,43 +16,41 @@ export declare type FunctionTestPromiseTuple<FunctionType extends AnyFunction> =
     ThenParameter<ReturnType<FunctionType>>,
     ...Parameters<FunctionType>
 ];
-export declare type FunctionTestPromiseRejectionTuple<FunctionType extends AnyFunction> = [
-    Error,
-    ...Parameters<FunctionType>
-];
-export declare type BaseSelector<T = unknown, E = unknown> = number | string | ((target: T) => E);
+export declare type FunctionTestPromiseRejectionTuple<FunctionType extends AnyFunction> = [Error, ...Parameters<FunctionType>];
+export declare type BaseSelector<T = unknown, E = unknown> = number | string | ((_target: T) => E);
 export declare type Selector<T = unknown, E = unknown> = Array<BaseSelector<T, E>> | BaseSelector<T, E>;
 export declare type TestSymbol = typeof DefinedSymbol | typeof ThrowSymbol | typeof UndefinedSymbol;
 export declare type ThenParameter<Type> = Type extends PromiseLike<infer U> ? U : Type;
 export declare type ThenParameterRecursive<Type> = Type extends PromiseLike<infer U> ? ThenParameterRecursive<U> : Type;
 export declare type ValueOf<Type> = Type[keyof Type];
 export declare type RecursiveNonNullable<Type> = {
-    [Property in keyof Type]: Type[Property] extends (infer OtherType)[] ? RecursiveNonNullable<OtherType>[] : Type[Property] extends Function ? NonNullable<Type[Property]> : Type[Property] extends object ? RecursiveNonNullable<Type[Property]> : NonNullable<Type[Property]>;
+    [Property in keyof Type]: Type[Property] extends (infer OtherType)[] ? RecursiveNonNullable<OtherType>[] : Type[Property] extends AnyFunction ? NonNullable<Type[Property]> : Type[Property] extends Mapping<unknown> ? RecursiveNonNullable<Type[Property]> : NonNullable<Type[Property]>;
 };
 export declare type RecursivePartial<Type> = Partial<Type> | {
-    [Property in keyof Type]?: Type[Property] extends (infer OtherType)[] ? RecursivePartial<OtherType>[] : Type[Property] extends Function ? Partial<Type[Property]> : Type[Property] extends object ? RecursivePartial<Type[Property]> : Partial<Type[Property]>;
+    [Property in keyof Type]?: Type[Property] extends (infer OtherType)[] ? RecursivePartial<OtherType>[] : Type[Property] extends AnyFunction ? Partial<Type[Property]> : Type[Property] extends Mapping<unknown> ? RecursivePartial<Type[Property]> : Partial<Type[Property]>;
 };
+export declare type ImportFunction = (_id: string) => Promise<ReturnType<typeof require>>;
 export declare type HTMLItem = Comment | Document | HTMLElement | Text;
 export declare type Primitive = boolean | null | number | string | undefined;
 export declare type PlainObject<Type = Primitive> = {
     [key: string]: Array<PlainObject<Type> | Type> | PlainObject<Type> | Type;
 };
 export interface ProxyHandler<T = unknown> {
-    deleteProperty: (target: T, key: any) => boolean;
-    get: (target: T, key: string) => unknown;
-    has: (target: T, key: string) => boolean;
-    set: (target: T, key: string, value: unknown) => boolean;
+    deleteProperty: (_target: T, _key: string | symbol) => boolean;
+    get: (_target: T, _key: string | symbol) => unknown;
+    has: (_target: T, _key: string | symbol) => boolean;
+    set: (_target: T, _key: string | symbol, _value: unknown) => boolean;
 }
 export declare type ProxyType<T = unknown> = T & {
     __revoke__?: AnyFunction;
     __target__: T;
 };
-export declare type GenericFunction = (...parameter: Array<unknown>) => unknown;
-export declare type SynchronousProcedureFunction = (...parameter: Array<unknown>) => void;
-export declare type AsynchronousProcedureFunction = (...parameter: Array<unknown>) => Promise<void>;
+export declare type GenericFunction = (..._parameters: Array<unknown>) => unknown;
+export declare type SynchronousProcedureFunction = (..._parameters: Array<unknown>) => void;
+export declare type AsynchronousProcedureFunction = (..._parameters: Array<unknown>) => Promise<void>;
 export declare type ProcedureFunction = AsynchronousProcedureFunction | SynchronousProcedureFunction;
-export declare type GetterFunction = (keyOrValue: any, key: any, target: any) => any;
-export declare type SetterFunction = (key: any, value: any, target: any) => any;
+export declare type GetterFunction = (_keyOrValue: unknown, _key: string | symbol, _target: unknown) => unknown;
+export declare type SetterFunction = (_key: string | symbol, _value: unknown, _target: unknown) => unknown;
 export interface CheckReachabilityOptions {
     expectedIntermediateStatusCodes: Array<number> | number;
     options: RequestInit;
@@ -65,25 +64,23 @@ export interface CompareOptions {
     deep: number;
     exceptionPrefixes: Array<string>;
     ignoreFunctions: boolean;
-    properties: Array<any> | null;
+    properties: Array<string> | null;
     returnReasonIfNotEqual: boolean;
 }
 export declare type Encoding = 'ascii' | 'base64' | 'binary' | 'hex' | 'latin1' | 'ucs2' | 'ucs-2' | 'utf8' | 'utf16le' | 'utf-8';
 export interface File {
     directoryPath: string;
+    directoryEntry: DirectoryEntry | null;
     error: Error | null;
     name: string;
     path: string;
-    stats: Stats | null;
+    stats: FileStats | null;
 }
 export interface ProcessError extends Error {
     parameters: Array<unknown>;
     returnCode: number;
 }
 export declare type QueryParameters = Array<Array<string> | string> & Mapping<Array<string> | string>;
-export interface Scope<TElement = HTMLElement> extends Iterable<TElement> {
-    Tools: ToolsFunction<TElement>;
-}
 export interface TimeoutPromise extends Promise<boolean> {
     clear: () => void;
     timeoutID: NodeJS.Timeout;
@@ -104,7 +101,7 @@ export declare type Evaluateable = {
     __execute__: string;
 };
 export declare type RecursiveEvaluateable<Type> = Evaluateable | {
-    [Property in keyof Type]: Evaluateable | (Type[Property] extends (infer OtherType)[] ? RecursiveEvaluateable<OtherType>[] : Type[Property] extends object ? RecursiveEvaluateable<Type[Property]> : Evaluateable | Type[Property]);
+    [Property in keyof Type]: (Evaluateable | (Type[Property] extends (infer OtherType)[] ? RecursiveEvaluateable<OtherType>[] : Type[Property] extends Mapping<unknown> ? RecursiveEvaluateable<Type[Property]> : Evaluateable | Type[Property]));
 };
 export interface PaginateOptions {
     boundaryCount: number;
@@ -133,36 +130,36 @@ export interface Position extends Offset {
     bottom: number;
     right: number;
 }
-export declare type ProcessHandler = (returnCode: any, ...parameter: Array<any>) => void;
+export declare type ProcessHandler = (_returnCode: unknown, ..._parameters: Array<unknown>) => void;
 export interface ProcessCloseReason {
     parameters: Array<unknown>;
     reason: unknown;
 }
-export declare type ProcessCloseCallback = (reason: ProcessCloseReason) => void;
-export declare type ProcessErrorCallback = (reason: ProcessError) => void;
+export declare type ProcessCloseCallback = (_reason: ProcessCloseReason) => void;
+export declare type ProcessErrorCallback = (_reason: ProcessError) => void;
 export declare type RelativePosition = 'above' | 'below' | 'in' | 'left' | 'right';
-export declare type TemplateFunction = (...parameter: Array<any>) => any;
-export interface CompilationResult {
+export declare type TemplateFunction<Type = string> = (..._parameters: Array<unknown>) => Type;
+export interface CompilationResult<Type = string> {
     error: null | string;
     originalScopeNames: Array<string>;
     scopeNameMapping: Mapping<string>;
     scopeNames: Array<string>;
-    templateFunction: TemplateFunction;
+    templateFunction: TemplateFunction<Type>;
 }
-export interface EvaluationResult {
+export interface EvaluationResult<Type = string> {
     compileError: null | string;
     error: null | string;
-    result: any;
+    result: Type;
     runtimeError: null | string;
 }
-export declare type LockCallbackFunction<Type = string> = (description: string) => Promise<Type> | Type;
+export declare type LockCallbackFunction<Type = string> = (_description: string) => Promise<Type> | Type;
 export declare type DomNodes<Type = string> = Mapping<Type> & {
     hideJavaScriptEnabled: Type;
     parent?: Type;
     showJavaScriptEnabled: Type;
     window?: Type;
 };
-export declare type $DomNode<TElement = HTMLElement> = JQuery<TElement>;
+export declare type $DomNode<TElement = HTMLElement> = $T<TElement>;
 export declare type $DomNodes = DomNodes<$DomNode>;
 export interface Options<Type = string> {
     domNodes: DomNodes<Type>;
@@ -170,31 +167,36 @@ export interface Options<Type = string> {
     logging: boolean;
     name: string;
 }
-export declare type $Function = JQueryStatic & StaticScope;
+export declare type $TStatic = JQueryStatic;
+export declare type $T<TElement = HTMLElement> = JQuery<TElement>;
 export interface $Global extends Window {
     Babel?: {
-        transform: (code: string, configuration: PlainObject) => {
+        transform: (_code: string, _configuration: PlainObject) => {
             code: string;
         };
     };
     console: Console;
     dataLayer: Array<PlainObject>;
-    $: $Function;
+    $: $TStatic;
 }
 export interface ToolsFunction<TElement = HTMLElement, LockType = string> {
-    (...parameter: Array<any>): any | Tools<TElement, LockType>;
+    (..._parameters: Array<unknown>): any | Tools<TElement, LockType>;
     class: typeof Tools;
 }
 export interface StaticScope {
-    (parameter: any, ...additionalArguments: Array<any>): any;
     document?: Document;
     global: $Global;
     location?: Location;
     Tools: ToolsFunction;
 }
 declare global {
-    interface JQuery<TElement = HTMLElement> extends Scope<TElement> {
+    interface JQuery<TElement = HTMLElement> {
+        Tools: ToolsFunction<TElement>;
     }
-    interface JQueryStatic extends StaticScope {
+    interface JQueryStatic {
+        document?: Document;
+        global: $Global;
+        location?: Location;
+        Tools: ToolsFunction;
     }
 }