@typescript-eslint/utils 6.0.0-alpha.99 → 6.0.1-alpha.0

package/README.md

@@ -5,6 +5,8 @@
 [![NPM Version](https://img.shields.io/npm/v/@typescript-eslint/utils.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/utils)
 [![NPM Downloads](https://img.shields.io/npm/dm/@typescript-eslint/utils.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/utils)
 
-👉 See **https://typescript-eslint.io/architecture/utils** for documentation on this package.
+👉 See **https://typescript-eslint.io/packages/utils** for documentation on this package.
 
 > See https://typescript-eslint.io for general documentation on typescript-eslint, the tooling that allows you to run ESLint and Prettier on TypeScript code.
+
+<!-- Local path for docs: docs/packages/Utils.mdx -->

package/{_ts4.2 → _ts4.3}/dist/ast-utils/eslint-utils/ReferenceTracker.d.ts

@@ -34,7 +34,7 @@ interface ReferenceTrackerStatic {
          * If this is `"strict"`, the method binds CommonJS modules to the default export. Otherwise, the method binds
          * CommonJS modules to both the default export and named exports. Optional. Default is `"strict"`.
          */
-        mode?: 'strict' | 'legacy';
+        mode?: 'legacy' | 'strict';
         /**
          * The name list of Global Object. Optional. Default is `["global", "globalThis", "self", "window"]`.
          */
@@ -50,7 +50,7 @@ declare namespace ReferenceTracker {
     type CALL = ReferenceTrackerStatic['CALL'];
     type CONSTRUCT = ReferenceTrackerStatic['CONSTRUCT'];
     type ESM = ReferenceTrackerStatic['ESM'];
-    type ReferenceType = READ | CALL | CONSTRUCT;
+    type ReferenceType = CALL | CONSTRUCT | READ;
     type TraceMap<T = any> = Record<string, TraceMapElement<T>>;
     interface TraceMapElement<T> {
         [ReferenceTrackerREAD]?: T;

package/{_ts4.2 → _ts4.3}/dist/ast-utils/eslint-utils/astUtilities.d.ts

@@ -5,13 +5,13 @@ import type { TSESTree } from '../../ts-estree';
  *
  * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionheadlocation}
  */
-declare const getFunctionHeadLocation: (node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression, sourceCode: TSESLint.SourceCode) => TSESTree.SourceLocation;
+declare const getFunctionHeadLocation: (node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression, sourceCode: TSESLint.SourceCode) => TSESTree.SourceLocation;
 /**
  * Get the name and kind of a given function node.
  *
  * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionnamewithkind}
  */
-declare const getFunctionNameWithKind: (node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression, sourceCode?: TSESLint.SourceCode) => string;
+declare const getFunctionNameWithKind: (node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression, sourceCode?: TSESLint.SourceCode) => string;
 /**
  * Get the property name of a given property node.
  * If the node is a computed property, this tries to compute the property name by the getStringIfConstant function.
@@ -19,7 +19,7 @@ declare const getFunctionNameWithKind: (node: TSESTree.FunctionDeclaration | TSE
  * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getpropertyname}
  * @returns The property name of the node. If the property name is not constant then it returns `null`.
  */
-declare const getPropertyName: (node: TSESTree.MemberExpression | TSESTree.Property | TSESTree.MethodDefinition | TSESTree.PropertyDefinition, initialScope?: TSESLint.Scope.Scope) => string | null;
+declare const getPropertyName: (node: TSESTree.MemberExpression | TSESTree.MethodDefinition | TSESTree.Property | TSESTree.PropertyDefinition, initialScope?: TSESLint.Scope.Scope) => string | null;
 /**
  * Get the value of a given node if it can decide the value statically.
  * If the 2nd parameter `initialScope` was given, this function tries to resolve identifier references which are in the

package/{_ts4.2 → _ts4.3}/dist/ast-utils/eslint-utils/scopeAnalysis.d.ts

@@ -5,7 +5,7 @@ import type { TSESTree } from '../../ts-estree';
  *
  * @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#findvariable}
  */
-declare const findVariable: (initialScope: TSESLint.Scope.Scope, nameOrNode: string | TSESTree.Identifier) => TSESLint.Scope.Variable | null;
+declare const findVariable: (initialScope: TSESLint.Scope.Scope, nameOrNode: TSESTree.Identifier | string) => TSESLint.Scope.Variable | null;
 /**
  * Get the innermost scope which contains a given node.
  *

package/{_ts4.2 → _ts4.3}/dist/ast-utils/helpers.d.ts

@@ -1147,7 +1147,7 @@ export declare const isNodeOfTypeWithConditions: <NodeType extends AST_NODE_TYPE
     type: NodeType;
 }> | Extract<TSESTree.YieldExpression, {
     type: NodeType;
-}>, Conditions extends Partial<ExtractedNode>>(nodeType: NodeType, conditions: Conditions) => (node: TSESTree.Node | null | undefined) => node is ExtractedNode & Conditions;
+}>, Conditions extends Partial<ExtractedNode>>(nodeType: NodeType, conditions: Conditions) => (node: TSESTree.Node | null | undefined) => node is Conditions & ExtractedNode;
 export declare const isTokenOfTypeWithConditions: <TokenType extends AST_TOKEN_TYPES, ExtractedToken extends Extract<TSESTree.BooleanToken, {
     type: TokenType;
 }> | Extract<TSESTree.BlockComment, {
@@ -1176,7 +1176,7 @@ export declare const isTokenOfTypeWithConditions: <TokenType extends AST_TOKEN_T
     type: TokenType;
 }>, Conditions extends Partial<TSESTree.Token & {
     type: TokenType;
-}>>(tokenType: TokenType, conditions: Conditions) => (token: TSESTree.Token | null | undefined) => token is ExtractedToken & Conditions;
+}>>(tokenType: TokenType, conditions: Conditions) => (token: TSESTree.Token | null | undefined) => token is Conditions & ExtractedToken;
 export declare const isNotTokenOfTypeWithConditions: <TokenType extends AST_TOKEN_TYPES, ExtractedToken extends Extract<TSESTree.BooleanToken, {
     type: TokenType;
 }> | Extract<TSESTree.BlockComment, {
@@ -1203,5 +1203,5 @@ export declare const isNotTokenOfTypeWithConditions: <TokenType extends AST_TOKE
     type: TokenType;
 }> | Extract<TSESTree.TemplateToken, {
     type: TokenType;
-}>, Conditions extends Partial<ExtractedToken>>(tokenType: TokenType, conditions: Conditions) => (token: TSESTree.Token | null | undefined) => token is Exclude<TSESTree.BooleanToken, ExtractedToken & Conditions> | Exclude<TSESTree.BlockComment, ExtractedToken & Conditions> | Exclude<TSESTree.LineComment, ExtractedToken & Conditions> | Exclude<TSESTree.IdentifierToken, ExtractedToken & Conditions> | Exclude<TSESTree.JSXIdentifierToken, ExtractedToken & Conditions> | Exclude<TSESTree.JSXTextToken, ExtractedToken & Conditions> | Exclude<TSESTree.KeywordToken, ExtractedToken & Conditions> | Exclude<TSESTree.NullToken, ExtractedToken & Conditions> | Exclude<TSESTree.NumericToken, ExtractedToken & Conditions> | Exclude<TSESTree.PunctuatorToken, ExtractedToken & Conditions> | Exclude<TSESTree.RegularExpressionToken, ExtractedToken & Conditions> | Exclude<TSESTree.StringToken, ExtractedToken & Conditions> | Exclude<TSESTree.TemplateToken, ExtractedToken & Conditions>;
+}>, Conditions extends Partial<ExtractedToken>>(tokenType: TokenType, conditions: Conditions) => (token: TSESTree.Token | null | undefined) => token is Exclude<TSESTree.BooleanToken, Conditions & ExtractedToken> | Exclude<TSESTree.BlockComment, Conditions & ExtractedToken> | Exclude<TSESTree.LineComment, Conditions & ExtractedToken> | Exclude<TSESTree.IdentifierToken, Conditions & ExtractedToken> | Exclude<TSESTree.JSXIdentifierToken, Conditions & ExtractedToken> | Exclude<TSESTree.JSXTextToken, Conditions & ExtractedToken> | Exclude<TSESTree.KeywordToken, Conditions & ExtractedToken> | Exclude<TSESTree.NullToken, Conditions & ExtractedToken> | Exclude<TSESTree.NumericToken, Conditions & ExtractedToken> | Exclude<TSESTree.PunctuatorToken, Conditions & ExtractedToken> | Exclude<TSESTree.RegularExpressionToken, Conditions & ExtractedToken> | Exclude<TSESTree.StringToken, Conditions & ExtractedToken> | Exclude<TSESTree.TemplateToken, Conditions & ExtractedToken>;
 //# sourceMappingURL=helpers.d.ts.map

package/{_ts4.2 → _ts4.3}/dist/ast-utils/predicates.d.ts

@@ -1,22 +1,22 @@
 import type { TSESTree } from '../ts-estree';
-declare const isOptionalChainPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.PunctuatorToken & {
+declare const isOptionalChainPunctuator: (token: TSESTree.Token | null | undefined) => token is {
     value: "?.";
-};
+} & TSESTree.PunctuatorToken;
 declare const isNotOptionalChainPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.BooleanToken | TSESTree.BlockComment | TSESTree.LineComment | TSESTree.IdentifierToken | TSESTree.JSXIdentifierToken | TSESTree.JSXTextToken | TSESTree.KeywordToken | TSESTree.NullToken | TSESTree.NumericToken | TSESTree.PunctuatorToken | TSESTree.RegularExpressionToken | TSESTree.StringToken | TSESTree.TemplateToken;
-declare const isNonNullAssertionPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.PunctuatorToken & {
+declare const isNonNullAssertionPunctuator: (token: TSESTree.Token | null | undefined) => token is {
     value: "!";
-};
+} & TSESTree.PunctuatorToken;
 declare const isNotNonNullAssertionPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.BooleanToken | TSESTree.BlockComment | TSESTree.LineComment | TSESTree.IdentifierToken | TSESTree.JSXIdentifierToken | TSESTree.JSXTextToken | TSESTree.KeywordToken | TSESTree.NullToken | TSESTree.NumericToken | TSESTree.PunctuatorToken | TSESTree.RegularExpressionToken | TSESTree.StringToken | TSESTree.TemplateToken;
 /**
  * Returns true if and only if the node represents: foo?.() or foo.bar?.()
  */
-declare const isOptionalCallExpression: (node: TSESTree.Node | null | undefined) => node is TSESTree.CallExpression & {
+declare const isOptionalCallExpression: (node: TSESTree.Node | null | undefined) => node is {
     optional: boolean;
-};
+} & TSESTree.CallExpression;
 /**
  * Returns true if and only if the node represents logical OR
  */
-declare const isLogicalOrOperator: (node: TSESTree.Node | null | undefined) => node is TSESTree.LogicalExpression & Partial<TSESTree.LogicalExpression>;
+declare const isLogicalOrOperator: (node: TSESTree.Node | null | undefined) => node is Partial<TSESTree.LogicalExpression> & TSESTree.LogicalExpression;
 /**
  * Checks if a node is a type assertion:
  * ```
@@ -35,13 +35,13 @@ declare const isClassOrTypeElement: (node: TSESTree.Node | null | undefined) =>
 /**
  * Checks if a node is a constructor method.
  */
-declare const isConstructor: (node: TSESTree.Node | null | undefined) => node is (TSESTree.MethodDefinitionComputedName & Partial<TSESTree.MethodDefinitionComputedName>) | (TSESTree.MethodDefinitionNonComputedName & Partial<TSESTree.MethodDefinitionNonComputedName>);
+declare const isConstructor: (node: TSESTree.Node | null | undefined) => node is (Partial<TSESTree.MethodDefinitionComputedName> & TSESTree.MethodDefinitionComputedName) | (Partial<TSESTree.MethodDefinitionNonComputedName> & TSESTree.MethodDefinitionNonComputedName);
 /**
  * Checks if a node is a setter method.
  */
-declare function isSetter(node: TSESTree.Node | undefined): node is (TSESTree.MethodDefinition | TSESTree.Property) & {
+declare function isSetter(node: TSESTree.Node | undefined): node is {
     kind: 'set';
-};
+} & (TSESTree.MethodDefinition | TSESTree.Property);
 declare const isIdentifier: (node: TSESTree.Node | null | undefined) => node is TSESTree.Identifier;
 /**
  * Checks if a node represents an `await …` expression.
@@ -50,21 +50,21 @@ declare const isAwaitExpression: (node: TSESTree.Node | null | undefined) => nod
 /**
  * Checks if a possible token is the `await` keyword.
  */
-declare const isAwaitKeyword: (token: TSESTree.Token | null | undefined) => token is TSESTree.IdentifierToken & {
+declare const isAwaitKeyword: (token: TSESTree.Token | null | undefined) => token is {
     value: "await";
-};
+} & TSESTree.IdentifierToken;
 /**
  * Checks if a possible token is the `type` keyword.
  */
-declare const isTypeKeyword: (token: TSESTree.Token | null | undefined) => token is TSESTree.IdentifierToken & {
+declare const isTypeKeyword: (token: TSESTree.Token | null | undefined) => token is {
     value: "type";
-};
+} & TSESTree.IdentifierToken;
 /**
  * Checks if a possible token is the `import` keyword.
  */
-declare const isImportKeyword: (token: TSESTree.Token | null | undefined) => token is TSESTree.KeywordToken & {
+declare const isImportKeyword: (token: TSESTree.Token | null | undefined) => token is {
     value: "import";
-};
+} & TSESTree.KeywordToken;
 declare const isLoop: (node: TSESTree.Node | null | undefined) => node is TSESTree.DoWhileStatement | TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement | TSESTree.WhileStatement;
 export { isAwaitExpression, isAwaitKeyword, isConstructor, isClassOrTypeElement, isFunction, isFunctionOrFunctionType, isFunctionType, isIdentifier, isImportKeyword, isLoop, isLogicalOrOperator, isNonNullAssertionPunctuator, isNotNonNullAssertionPunctuator, isNotOptionalChainPunctuator, isOptionalChainPunctuator, isOptionalCallExpression, isSetter, isTSConstructorType, isTSFunctionType, isTypeAssertion, isTypeKeyword, isVariableDeclarator, };
 //# sourceMappingURL=predicates.d.ts.map

package/{_ts4.2 → _ts4.3}/dist/eslint-utils/RuleCreator.d.ts

@@ -1,8 +1,8 @@
 import type { RuleContext, RuleListener, RuleMetaData, RuleMetaDataDocs, RuleModule } from '../ts-eslint/Rule';
 export type NamedCreateRuleMetaDocs = Omit<RuleMetaDataDocs, 'url'>;
-export type NamedCreateRuleMeta<TMessageIds extends string> = {
+export type NamedCreateRuleMeta<TMessageIds extends string> = Omit<RuleMetaData<TMessageIds>, 'docs'> & {
     docs: NamedCreateRuleMetaDocs;
-} & Omit<RuleMetaData<TMessageIds>, 'docs'>;
+};
 export interface RuleCreateAndOptions<TOptions extends readonly unknown[], TMessageIds extends string> {
     create: (context: Readonly<RuleContext<TMessageIds, TOptions>>, optionsWithDefault: Readonly<TOptions>) => RuleListener;
     defaultOptions: Readonly<TOptions>;

package/{_ts4.2 → _ts4.3}/dist/eslint-utils/deepMerge.d.ts

@@ -4,7 +4,7 @@ type ObjectLike<T = unknown> = Record<string, T>;
  * @param obj an object
  * @returns `true` if obj is an object
  */
-declare function isObjectNotArray<T extends ObjectLike>(obj: unknown | unknown[]): obj is T;
+declare function isObjectNotArray<T extends ObjectLike>(obj: unknown): obj is T;
 /**
  * Pure function - doesn't mutate either parameter!
  * Merges two objects together deeply, overwriting the properties in first with the properties in second

package/_ts4.3/dist/eslint-utils/getParserServices.d.ts

@@ -0,0 +1,24 @@
+import type * as TSESLint from '../ts-eslint';
+import type { ParserServices, ParserServicesWithTypeInformation } from '../ts-estree';
+/**
+ * Try to retrieve type-aware parser service from context.
+ * This **_will_** throw if it is not available.
+ */
+declare function getParserServices<TMessageIds extends string, TOptions extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<TMessageIds, TOptions>>): ParserServicesWithTypeInformation;
+/**
+ * Try to retrieve type-aware parser service from context.
+ * This **_will_** throw if it is not available.
+ */
+declare function getParserServices<TMessageIds extends string, TOptions extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<TMessageIds, TOptions>>, allowWithoutFullTypeInformation: false): ParserServicesWithTypeInformation;
+/**
+ * Try to retrieve type-aware parser service from context.
+ * This **_will not_** throw if it is not available.
+ */
+declare function getParserServices<TMessageIds extends string, TOptions extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<TMessageIds, TOptions>>, allowWithoutFullTypeInformation: true): ParserServices;
+/**
+ * Try to retrieve type-aware parser service from context.
+ * This may or may not throw if it is not available, depending on if `allowWithoutFullTypeInformation` is `true`
+ */
+declare function getParserServices<TMessageIds extends string, TOptions extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<TMessageIds, TOptions>>, allowWithoutFullTypeInformation: boolean): ParserServices;
+export { getParserServices };
+//# sourceMappingURL=getParserServices.d.ts.map

package/{_ts4.2 → _ts4.3}/dist/eslint-utils/index.d.ts

@@ -1,9 +1,7 @@
 export * from './applyDefault';
-export * from './batchedSingleLineTests';
 export * from './getParserServices';
 export * from './InferTypesFromRule';
 export * from './RuleCreator';
-export * from './rule-tester/RuleTester';
 export * from './deepMerge';
 export * from './nullThrows';
 //# sourceMappingURL=index.d.ts.map

package/_ts4.3/dist/json-schema.d.ts

@@ -0,0 +1,392 @@
+/**
+ * This is a fork of https://github.com/DefinitelyTyped/DefinitelyTyped/blob/13f63c2eb8d7479caf01ab8d72f9e3683368a8f5/types/json-schema/index.d.ts
+ * We intentionally fork this because:
+ * - ESLint ***ONLY*** supports JSONSchema v4
+ * - We want to provide stricter types
+ */
+/**
+ * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1
+ */
+export type JSONSchema4TypeName = 'any' | 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string';
+/**
+ * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-3.5
+ */
+export type JSONSchema4Type = boolean | number | string | null;
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-04/schema#'
+ * - 'http://json-schema.org/draft-04/hyper-schema#'
+ * - 'http://json-schema.org/draft-03/schema#'
+ * - 'http://json-schema.org/draft-03/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+export type JSONSchema4Version = string;
+/**
+ * JSON Schema V4
+ * @see https://tools.ietf.org/html/draft-zyp-json-schema-04
+ */
+export type JSONSchema4 = JSONSchema4AllOfSchema | JSONSchema4AnyOfSchema | JSONSchema4AnySchema | JSONSchema4ArraySchema | JSONSchema4BoleanSchema | JSONSchema4MultiSchema | JSONSchema4NullSchema | JSONSchema4NumberSchema | JSONSchema4ObjectSchema | JSONSchema4OneOfSchema | JSONSchema4RefSchema | JSONSchema4StringSchema;
+interface JSONSchema4Base {
+    id?: string | undefined;
+    $schema?: JSONSchema4Version | undefined;
+    /**
+     * A single type, or a union of simple types
+     */
+    type?: JSONSchema4TypeName | JSONSchema4TypeName[] | undefined;
+    /**
+     * Path to a schema defined in `definitions`/`$defs` that will form the base
+     * for this schema.
+     *
+     * If you are defining an "array" schema (`schema: [ ... ]`) for your rule
+     * then you should prefix this with `items/0` so that the validator can find
+     * your definitions.
+     *
+     * eg: `'#/items/0/definitions/myDef'`
+     *
+     * Otherwise if you are defining an "object" schema (`schema: { ... }`) for
+     * your rule you can directly reference your definitions
+     *
+     * eg: `'#/definitions/myDef'`
+     */
+    $ref?: string | undefined;
+    /**
+     * This attribute is a string that provides a short description of the
+     * instance property.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.21
+     */
+    title?: string | undefined;
+    /**
+     * This attribute is a string that provides a full description of the of
+     * purpose the instance property.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.22
+     */
+    description?: string | undefined;
+    /**
+     * Reusable definitions that can be referenced via `$ref`
+     */
+    definitions?: {
+        [k: string]: JSONSchema4;
+    } | undefined;
+    /**
+     * Reusable definitions that can be referenced via `$ref`
+     */
+    $defs?: {
+        [k: string]: JSONSchema4;
+    } | undefined;
+    /**
+     * The value of this property MUST be another schema which will provide
+     * a base schema which the current schema will inherit from.  The
+     * inheritance rules are such that any instance that is valid according
+     * to the current schema MUST be valid according to the referenced
+     * schema.  This MAY also be an array, in which case, the instance MUST
+     * be valid for all the schemas in the array.  A schema that extends
+     * another schema MAY define additional attributes, constrain existing
+     * attributes, or add other constraints.
+     *
+     * Conceptually, the behavior of extends can be seen as validating an
+     * instance against all constraints in the extending schema as well as
+     * the extended schema(s).
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.26
+     */
+    extends?: string[] | string | undefined;
+    /**
+     * The default value for the item if not present
+     */
+    default?: JSONSchema4Type | undefined;
+    /**
+     * This attribute indicates if the instance must have a value, and not
+     * be undefined. This is false by default, making the instance
+     * optional.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.7
+     */
+    required?: string[] | boolean | undefined;
+    /**
+     * (NOT) Must not be valid against the given schema
+     */
+    not?: JSONSchema4 | undefined;
+    /**
+     * (AND) Must be valid against all of the sub-schemas
+     */
+    allOf?: JSONSchema4[] | undefined;
+    /**
+     * (OR) Must be valid against any of the sub-schemas
+     */
+    anyOf?: JSONSchema4[] | undefined;
+    /**
+     * (XOR) Must be valid against exactly one of the sub-schemas
+     */
+    oneOf?: JSONSchema4[] | undefined;
+}
+export interface JSONSchema4RefSchema extends JSONSchema4Base {
+    type?: undefined;
+    $ref: string;
+}
+export interface JSONSchema4AllOfSchema extends JSONSchema4Base {
+    type?: undefined;
+    allOf: JSONSchema4[];
+}
+export interface JSONSchema4AnyOfSchema extends JSONSchema4Base {
+    type?: undefined;
+    anyOf: JSONSchema4[];
+}
+export interface JSONSchema4OneOfSchema extends JSONSchema4Base {
+    type?: undefined;
+    oneOf: JSONSchema4[];
+}
+export interface JSONSchema4MultiSchema extends Omit<JSONSchema4ObjectSchema, 'enum' | 'type'>, Omit<JSONSchema4ArraySchema, 'enum' | 'type'>, Omit<JSONSchema4StringSchema, 'enum' | 'type'>, Omit<JSONSchema4NumberSchema, 'enum' | 'type'>, Omit<JSONSchema4BoleanSchema, 'enum' | 'type'>, Omit<JSONSchema4NullSchema, 'enum' | 'type'>, Omit<JSONSchema4AnySchema, 'enum' | 'type'> {
+    type: JSONSchema4TypeName[];
+    /**
+     * This provides an enumeration of all possible values that are valid
+     * for the instance property. This MUST be an array, and each item in
+     * the array represents a possible value for the instance value. If
+     * this attribute is defined, the instance value MUST be one of the
+     * values in the array in order for the schema to be valid.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
+     */
+    enum?: JSONSchema4Type[];
+}
+/**
+ * @see https://json-schema.org/understanding-json-schema/reference/object.html
+ */
+export interface JSONSchema4ObjectSchema extends JSONSchema4Base {
+    type: 'object';
+    /**
+     * This attribute defines a schema for all properties that are not
+     * explicitly defined in an object type definition. If specified, the
+     * value MUST be a schema or a boolean. If false is provided, no
+     * additional properties are allowed beyond the properties defined in
+     * the schema. The default value is an empty schema which allows any
+     * value for additional properties.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.4
+     */
+    additionalProperties?: JSONSchema4 | boolean | undefined;
+    /**
+     * This attribute is an object with property definitions that define the
+     * valid values of instance object property values. When the instance
+     * value is an object, the property values of the instance object MUST
+     * conform to the property definitions in this object. In this object,
+     * each property definition's value MUST be a schema, and the property's
+     * name MUST be the name of the instance property that it defines.  The
+     * instance property value MUST be valid according to the schema from
+     * the property definition. Properties are considered unordered, the
+     * order of the instance properties MAY be in any order.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.2
+     */
+    properties?: {
+        [k: string]: JSONSchema4;
+    } | undefined;
+    /**
+     * This attribute is an object that defines the schema for a set of
+     * property names of an object instance. The name of each property of
+     * this attribute's object is a regular expression pattern in the ECMA
+     * 262/Perl 5 format, while the value is a schema. If the pattern
+     * matches the name of a property on the instance object, the value of
+     * the instance's property MUST be valid against the pattern name's
+     * schema value.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.3
+     */
+    patternProperties?: {
+        [k: string]: JSONSchema4;
+    } | undefined;
+    /**
+     * The `dependencies` keyword conditionally applies a sub-schema when a given
+     * property is present. This schema is applied in the same way `allOf` applies
+     * schemas. Nothing is merged or extended. Both schemas apply independently.
+     */
+    dependencies?: {
+        [k: string]: JSONSchema4 | string[];
+    } | undefined;
+    /**
+     * The maximum number of properties allowed for record-style schemas
+     */
+    maxProperties?: number | undefined;
+    /**
+     * The minimum number of properties required for record-style schemas
+     */
+    minProperties?: number | undefined;
+}
+/**
+ * @see https://json-schema.org/understanding-json-schema/reference/array.html
+ */
+export interface JSONSchema4ArraySchema extends JSONSchema4Base {
+    type: 'array';
+    /**
+     * May only be defined when "items" is defined, and is a tuple of JSONSchemas.
+     *
+     * This provides a definition for additional items in an array instance
+     * when tuple definitions of the items is provided.  This can be false
+     * to indicate additional items in the array are not allowed, or it can
+     * be a schema that defines the schema of the additional items.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.6
+     */
+    additionalItems?: JSONSchema4 | boolean | undefined;
+    /**
+     * This attribute defines the allowed items in an instance array, and
+     * MUST be a schema or an array of schemas.  The default value is an
+     * empty schema which allows any value for items in the instance array.
+     *
+     * When this attribute value is a schema and the instance value is an
+     * array, then all the items in the array MUST be valid according to the
+     * schema.
+     *
+     * When this attribute value is an array of schemas and the instance
+     * value is an array, each position in the instance array MUST conform
+     * to the schema in the corresponding position for this array.  This
+     * called tuple typing.  When tuple typing is used, additional items are
+     * allowed, disallowed, or constrained by the "additionalItems"
+     * (Section 5.6) attribute using the same rules as
+     * "additionalProperties" (Section 5.4) for objects.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5
+     */
+    items?: JSONSchema4 | JSONSchema4[] | undefined;
+    /**
+     * Defines the maximum length of an array
+     */
+    maxItems?: number | undefined;
+    /**
+     * Defines the minimum length of an array
+     */
+    minItems?: number | undefined;
+    /**
+     * Enforces that all items in the array are unique
+     */
+    uniqueItems?: boolean | undefined;
+}
+/**
+ * @see https://json-schema.org/understanding-json-schema/reference/string.html
+ */
+export interface JSONSchema4StringSchema extends JSONSchema4Base {
+    type: 'string';
+    /**
+     * The maximum allowed length for the string
+     */
+    maxLength?: number | undefined;
+    /**
+     * The minimum allowed length for the string
+     */
+    minLength?: number | undefined;
+    /**
+     * The `pattern` keyword is used to restrict a string to a particular regular
+     * expression. The regular expression syntax is the one defined in JavaScript
+     * (ECMA 262 specifically) with Unicode support.
+     *
+     * When defining the regular expressions, it’s important to note that the
+     * string is considered valid if the expression matches anywhere within the
+     * string. For example, the regular expression "p" will match any string with
+     * a p in it, such as "apple" not just a string that is simply "p". Therefore,
+     * it is usually less confusing, as a matter of course, to surround the
+     * regular expression in ^...$, for example, "^p$", unless there is a good
+     * reason not to do so.
+     */
+    pattern?: string | undefined;
+    /**
+     * The `format` keyword allows for basic semantic identification of certain
+     * kinds of string values that are commonly used.
+     *
+     * For example, because JSON doesn’t have a “DateTime” type, dates need to be
+     * encoded as strings. `format` allows the schema author to indicate that the
+     * string value should be interpreted as a date.
+     *
+     * ajv v6 provides a few built-in formats - all other strings will cause AJV
+     * to throw during schema compilation
+     */
+    format?: 'date-time' | 'date' | 'email' | 'hostname' | 'ipv4' | 'ipv6' | 'json-pointer-uri-fragment' | 'json-pointer' | 'regex' | 'relative-json-pointer' | 'time' | 'uri-reference' | 'uri-template' | 'uri' | 'url' | 'uuid' | undefined;
+    enum?: string[] | undefined;
+}
+/**
+ * @see https://json-schema.org/understanding-json-schema/reference/numeric.html
+ */
+export interface JSONSchema4NumberSchema extends JSONSchema4Base {
+    type: 'integer' | 'number';
+    /**
+     * Numbers can be restricted to a multiple of a given number, using the
+     * `multipleOf` keyword. It may be set to any positive number.
+     */
+    multipleOf?: number | undefined;
+    /**
+     * The maximum allowed value for the number
+     */
+    maximum?: number | undefined;
+    /**
+     * The minimum allowed value for the number
+     */
+    minimum?: number | undefined;
+    /**
+     * The exclusive minimum allowed value for the number
+     * - `true` = `x < maximum`
+     * - `false` = `x <= maximum`
+     *
+     * Default is `false`
+     */
+    exclusiveMaximum?: boolean | undefined;
+    /**
+     * Indicates whether or not `minimum` is the inclusive or exclusive minimum
+     * - `true` = `x > minimum`
+     * - `false` = `x ≥ minimum`
+     *
+     * Default is `false`
+     */
+    exclusiveMinimum?: boolean | undefined;
+    /**
+     * This provides an enumeration of all possible values that are valid
+     * for the instance property. This MUST be an array, and each item in
+     * the array represents a possible value for the instance value. If
+     * this attribute is defined, the instance value MUST be one of the
+     * values in the array in order for the schema to be valid.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
+     */
+    enum?: number[] | undefined;
+}
+/**
+ * @see https://json-schema.org/understanding-json-schema/reference/boolean.html
+ */
+export interface JSONSchema4BoleanSchema extends JSONSchema4Base {
+    type: 'boolean';
+    /**
+     * This provides an enumeration of all possible values that are valid
+     * for the instance property. This MUST be an array, and each item in
+     * the array represents a possible value for the instance value. If
+     * this attribute is defined, the instance value MUST be one of the
+     * values in the array in order for the schema to be valid.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
+     */
+    enum?: boolean[] | undefined;
+}
+/**
+ * @see https://json-schema.org/understanding-json-schema/reference/null.html
+ */
+export interface JSONSchema4NullSchema extends JSONSchema4Base {
+    type: 'null';
+    /**
+     * This provides an enumeration of all possible values that are valid
+     * for the instance property. This MUST be an array, and each item in
+     * the array represents a possible value for the instance value. If
+     * this attribute is defined, the instance value MUST be one of the
+     * values in the array in order for the schema to be valid.
+     *
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
+     */
+    enum?: null[] | undefined;
+}
+export interface JSONSchema4AnySchema extends JSONSchema4Base {
+    type: 'any';
+}
+export {};
+//# sourceMappingURL=json-schema.d.ts.map

package/{_ts4.2 → _ts4.3}/dist/ts-eslint/CLIEngine.d.ts

@@ -18,7 +18,7 @@ declare namespace CLIEngine {
         globals?: string[];
         ignore?: boolean;
         ignorePath?: string;
-        ignorePattern?: string | string[];
+        ignorePattern?: string[] | string;
         useEslintrc?: boolean;
         parser?: string;
         parserOptions?: Linter.ParserOptions;