eslint-plugin-package-json 1.6.0 → 1.6.1

package/dist/createRule-29pC9RoP.d.mts

@@ -0,0 +1,105 @@
+import { AST, RuleListener } from "jsonc-eslint-parser";
+import { AST as AST$1, Rule, SourceCode } from "eslint";
+import * as ESTree from "estree";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/definitions/jsonSchema.d.ts
+declare const $JSONSchema: unique symbol;
+type $JSONSchema = typeof $JSONSchema;
+type JSONSchemaType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
+type JSONSchema = boolean | Readonly<{
+  [$JSONSchema]?: $JSONSchema;
+  $id?: string | undefined;
+  $ref?: string | undefined;
+  $schema?: string | undefined;
+  $comment?: string | undefined;
+  type?: JSONSchemaType | readonly JSONSchemaType[];
+  const?: unknown;
+  enum?: unknown;
+  multipleOf?: number | undefined;
+  maximum?: number | undefined;
+  exclusiveMaximum?: number | undefined;
+  minimum?: number | undefined;
+  exclusiveMinimum?: number | undefined;
+  maxLength?: number | undefined;
+  minLength?: number | undefined;
+  pattern?: string | undefined;
+  items?: JSONSchema | readonly JSONSchema[];
+  additionalItems?: JSONSchema;
+  contains?: JSONSchema;
+  maxItems?: number | undefined;
+  minItems?: number | undefined;
+  uniqueItems?: boolean | undefined;
+  maxProperties?: number | undefined;
+  minProperties?: number | undefined;
+  required?: readonly string[];
+  properties?: Readonly<Record<string, JSONSchema>>;
+  patternProperties?: Readonly<Record<string, JSONSchema>>;
+  additionalProperties?: JSONSchema;
+  unevaluatedProperties?: JSONSchema;
+  dependencies?: Readonly<Record<string, JSONSchema | readonly string[]>>;
+  propertyNames?: JSONSchema;
+  if?: JSONSchema;
+  then?: JSONSchema;
+  else?: JSONSchema;
+  allOf?: readonly JSONSchema[];
+  anyOf?: readonly JSONSchema[];
+  oneOf?: readonly JSONSchema[];
+  not?: JSONSchema;
+  format?: string | undefined;
+  contentMediaType?: string | undefined;
+  contentEncoding?: string | undefined;
+  definitions?: Readonly<Record<string, JSONSchema>>;
+  title?: string | undefined;
+  description?: string | undefined;
+  default?: unknown;
+  readOnly?: boolean | undefined;
+  writeOnly?: boolean | undefined;
+  examples?: readonly unknown[];
+  nullable?: boolean;
+}>;
+//#endregion
+//#region src/createRule.d.ts
+type ASTBodyExpression = ESTree.Expression & {
+  properties: ASTBodyProperty[];
+};
+type ASTBodyProperty = AST.JSONProperty & {
+  value: string;
+};
+interface ASTBodyStatement extends ESTree.ExpressionStatement {
+  expression: ASTBodyExpression;
+}
+interface PackageAST extends AST$1.Program {
+  body: [ASTBodyStatement];
+}
+interface PackageJsonPluginSettings {
+  /**
+   * Whether `require-*` rules, if used, should enforce the presence of
+   * the corresponding property *in package.json files with `"private": true`*.
+   *
+   * If not specified, it will not enforce the presence only of `name` and `version` properties.
+   */
+  enforceForPrivate?: boolean;
+}
+interface PackageJsonRuleContext<Options extends unknown[] = unknown[]> extends Rule.RuleContext {
+  options: Options;
+  settings: {
+    packageJson?: PackageJsonPluginSettings;
+  };
+  sourceCode: PackageJsonSourceCode;
+}
+interface PackageJsonRuleModule<Options extends unknown[] = unknown[], Schema extends JSONSchema[] = JSONSchema[]> {
+  create(context: PackageJsonRuleContext<Options>): RuleListener;
+  meta: Omit<Rule.RuleMetaData, 'defaultOptions' | 'docs' | 'schema'> & {
+    defaultOptions?: NoInfer<Options>;
+    docs?: Rule.RuleMetaData['docs'] & {
+      category?: string; /** An optional route segment to group this rule under */
+      ruleGroup?: string;
+    };
+    schema?: Schema;
+  };
+}
+interface PackageJsonSourceCode extends SourceCode {
+  ast: PackageAST;
+}
+//#endregion
+export { PackageJsonRuleModule as n, JSONSchema as r, PackageJsonPluginSettings as t };

package/dist/experimental/index.d.mts

@@ -1,4 +1,4 @@
-import { n as PackageJsonRuleModule, r as JSONSchema, t as PackageJsonPluginSettings } from "../createRule-B1Ow8h0I.mjs";
+import { n as PackageJsonRuleModule, r as JSONSchema, t as PackageJsonPluginSettings } from "../createRule-29pC9RoP.mjs";
 import { ESLint } from "eslint";
 
 //#region src/experimental/plugin.d.ts

package/dist/experimental/index.mjs

@@ -1,4 +1,4 @@
-import { t as plugin$1 } from "../plugin-kxKPlCNd.mjs";
+import { t as plugin$1 } from "../plugin-C-Z8sf5g.mjs";
 import { toCompatRule } from "eslint-json-compat-utils";
 //#region src/experimental/plugin.ts
 const language = "json/json";

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { n as PackageJsonRuleModule, r as JSONSchema, t as PackageJsonPluginSettings } from "./createRule-B1Ow8h0I.mjs";
+import { n as PackageJsonRuleModule, r as JSONSchema, t as PackageJsonPluginSettings } from "./createRule-29pC9RoP.mjs";
 import * as parserJsonc from "jsonc-eslint-parser";
 import { ESLint } from "eslint";
 

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { t as plugin } from "./plugin-kxKPlCNd.mjs";
+import { t as plugin } from "./plugin-C-Z8sf5g.mjs";
 //#region src/index.ts
 const rules = plugin.rules;
 const configs = plugin.configs;

package/dist/{plugin-kxKPlCNd.mjs → plugin-C-Z8sf5g.mjs}

@@ -512,7 +512,7 @@ const createShorthand = (url, provider) => {
 };
 const createUrl = (shorthand) => {
 	if (shorthand.includes(":")) {
-		const [provider, repo] = shorthand.split(":");
+		const [provider, repo] = shorthand.split(":", 2);
 		if (isProvider(provider)) return `${providerUrls[provider]}${repo}`;
 	}
 	return `${providerUrls.github}${shorthand}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-package-json",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "Rules for consistent, readable, and valid package.json files. 🗂️",
   "homepage": "https://github.com/michaelfaith/eslint-plugin-package-json#readme",
   "bugs": {
@@ -71,24 +71,24 @@
     "@typescript/native": "npm:typescript@7.0.2",
     "@vitest/coverage-v8": "4.1.8",
     "@vitest/eslint-plugin": "1.6.20",
-    "astro": "7.0.6",
+    "astro": "7.1.0",
     "astro-og-canvas": "0.13.0",
     "canvaskit-wasm": "0.41.1",
     "console-fail-test": "0.6.0",
-    "eslint": "10.6.0",
-    "eslint-doc-generator": "3.6.0",
-    "eslint-plugin-eslint-plugin": "7.4.0",
-    "eslint-plugin-jsdoc": "63.0.2",
+    "eslint": "10.7.0",
+    "eslint-doc-generator": "3.7.0",
+    "eslint-plugin-eslint-plugin": "7.5.0",
+    "eslint-plugin-jsdoc": "63.2.0",
     "eslint-plugin-jsonc": "3.3.0",
     "eslint-plugin-n": "18.2.1",
     "eslint-plugin-node-dependencies": "2.2.0",
     "eslint-plugin-perfectionist": "5.10.0",
     "eslint-plugin-regexp": "3.1.0",
-    "eslint-plugin-unicorn": "71.1.0",
+    "eslint-plugin-unicorn": "72.0.0",
     "eslint-plugin-yml": "3.6.0",
     "jiti": "2.7.0",
     "json-schema-to-ts": "3.1.1",
-    "knip": "6.26.0",
+    "knip": "6.27.0",
     "prettier": "3.9.0",
     "prettier-plugin-curly": "0.4.1",
     "prettier-plugin-packagejson": "3.0.2",
@@ -99,16 +99,20 @@
     "starlight-auto-sidebar": "0.4.0",
     "tsdown": "0.22.2",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "typescript-eslint": "8.63.0",
+    "typescript-eslint": "8.65.0",
     "vitest": "4.1.8"
   },
   "peerDependencies": {
     "@eslint/json": ">=1.0.0",
+    "@types/estree": ">=1.0.0",
     "eslint": ">=9.0.0"
   },
   "peerDependenciesMeta": {
     "@eslint/json": {
       "optional": true
+    },
+    "@types/estree": {
+      "optional": true
     }
   },
   "engines": {

package/dist/createRule-B1Ow8h0I.d.mts

@@ -1,541 +0,0 @@
-import { AST, RuleListener } from "jsonc-eslint-parser";
-import { AST as AST$1, Rule, SourceCode } from "eslint";
-
-//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/definitions/jsonSchema.d.ts
-declare const $JSONSchema: unique symbol;
-type $JSONSchema = typeof $JSONSchema;
-type JSONSchemaType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
-type JSONSchema = boolean | Readonly<{
-  [$JSONSchema]?: $JSONSchema;
-  $id?: string | undefined;
-  $ref?: string | undefined;
-  $schema?: string | undefined;
-  $comment?: string | undefined;
-  type?: JSONSchemaType | readonly JSONSchemaType[];
-  const?: unknown;
-  enum?: unknown;
-  multipleOf?: number | undefined;
-  maximum?: number | undefined;
-  exclusiveMaximum?: number | undefined;
-  minimum?: number | undefined;
-  exclusiveMinimum?: number | undefined;
-  maxLength?: number | undefined;
-  minLength?: number | undefined;
-  pattern?: string | undefined;
-  items?: JSONSchema | readonly JSONSchema[];
-  additionalItems?: JSONSchema;
-  contains?: JSONSchema;
-  maxItems?: number | undefined;
-  minItems?: number | undefined;
-  uniqueItems?: boolean | undefined;
-  maxProperties?: number | undefined;
-  minProperties?: number | undefined;
-  required?: readonly string[];
-  properties?: Readonly<Record<string, JSONSchema>>;
-  patternProperties?: Readonly<Record<string, JSONSchema>>;
-  additionalProperties?: JSONSchema;
-  unevaluatedProperties?: JSONSchema;
-  dependencies?: Readonly<Record<string, JSONSchema | readonly string[]>>;
-  propertyNames?: JSONSchema;
-  if?: JSONSchema;
-  then?: JSONSchema;
-  else?: JSONSchema;
-  allOf?: readonly JSONSchema[];
-  anyOf?: readonly JSONSchema[];
-  oneOf?: readonly JSONSchema[];
-  not?: JSONSchema;
-  format?: string | undefined;
-  contentMediaType?: string | undefined;
-  contentEncoding?: string | undefined;
-  definitions?: Readonly<Record<string, JSONSchema>>;
-  title?: string | undefined;
-  description?: string | undefined;
-  default?: unknown;
-  readOnly?: boolean | undefined;
-  writeOnly?: boolean | undefined;
-  examples?: readonly unknown[];
-  nullable?: boolean;
-}>;
-//#endregion
-//#region node_modules/.pnpm/@types+estree@1.0.8/node_modules/@types/estree/index.d.ts
-// This definition file follows a somewhat unusual format. ESTree allows
-// runtime type checks based on the `type` parameter. In order to explain this
-// to typescript we want to use discriminated union types:
-// https://github.com/Microsoft/TypeScript/pull/9163
-//
-// For ESTree this is a bit tricky because the high level interfaces like
-// Node or Function are pulling double duty. We want to pass common fields down
-// to the interfaces that extend them (like Identifier or
-// ArrowFunctionExpression), but you can't extend a type union or enforce
-// common fields on them. So we've split the high level interfaces into two
-// types, a base type which passes down inherited fields, and a type union of
-// all types which extend the base type. Only the type union is exported, and
-// the union is how other types refer to the collection of inheriting types.
-//
-// This makes the definitions file here somewhat more difficult to maintain,
-// but it has the notable advantage of making ESTree much easier to use as
-// an end user.
-interface BaseNodeWithoutComments {
-  // Every leaf interface that extends BaseNode must specify a type property.
-  // The type property should be a string literal. For example, Identifier
-  // has: `type: "Identifier"`
-  type: string;
-  loc?: SourceLocation | null | undefined;
-  range?: [number, number] | undefined;
-}
-interface BaseNode extends BaseNodeWithoutComments {
-  leadingComments?: Comment[] | undefined;
-  trailingComments?: Comment[] | undefined;
-}
-interface Comment extends BaseNodeWithoutComments {
-  type: "Line" | "Block";
-  value: string;
-}
-interface SourceLocation {
-  source?: string | null | undefined;
-  start: Position;
-  end: Position;
-}
-interface Position {
-  /** >= 1 */
-  line: number;
-  /** >= 0 */
-  column: number;
-}
-interface BaseFunction extends BaseNode {
-  params: Pattern[];
-  generator?: boolean | undefined;
-  async?: boolean | undefined; // The body is either BlockStatement or Expression because arrow functions
-  // can have a body that's either. FunctionDeclarations and
-  // FunctionExpressions have only BlockStatement bodies.
-  body: BlockStatement | Expression;
-}
-type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
-interface BaseStatement extends BaseNode {}
-interface EmptyStatement extends BaseStatement {
-  type: "EmptyStatement";
-}
-interface BlockStatement extends BaseStatement {
-  type: "BlockStatement";
-  body: Statement[];
-  innerComments?: Comment[] | undefined;
-}
-interface StaticBlock extends Omit<BlockStatement, "type"> {
-  type: "StaticBlock";
-}
-interface ExpressionStatement extends BaseStatement {
-  type: "ExpressionStatement";
-  expression: Expression;
-}
-interface IfStatement extends BaseStatement {
-  type: "IfStatement";
-  test: Expression;
-  consequent: Statement;
-  alternate?: Statement | null | undefined;
-}
-interface LabeledStatement extends BaseStatement {
-  type: "LabeledStatement";
-  label: Identifier;
-  body: Statement;
-}
-interface BreakStatement extends BaseStatement {
-  type: "BreakStatement";
-  label?: Identifier | null | undefined;
-}
-interface ContinueStatement extends BaseStatement {
-  type: "ContinueStatement";
-  label?: Identifier | null | undefined;
-}
-interface WithStatement extends BaseStatement {
-  type: "WithStatement";
-  object: Expression;
-  body: Statement;
-}
-interface SwitchStatement extends BaseStatement {
-  type: "SwitchStatement";
-  discriminant: Expression;
-  cases: SwitchCase[];
-}
-interface ReturnStatement extends BaseStatement {
-  type: "ReturnStatement";
-  argument?: Expression | null | undefined;
-}
-interface ThrowStatement extends BaseStatement {
-  type: "ThrowStatement";
-  argument: Expression;
-}
-interface TryStatement extends BaseStatement {
-  type: "TryStatement";
-  block: BlockStatement;
-  handler?: CatchClause | null | undefined;
-  finalizer?: BlockStatement | null | undefined;
-}
-interface WhileStatement extends BaseStatement {
-  type: "WhileStatement";
-  test: Expression;
-  body: Statement;
-}
-interface DoWhileStatement extends BaseStatement {
-  type: "DoWhileStatement";
-  body: Statement;
-  test: Expression;
-}
-interface ForStatement extends BaseStatement {
-  type: "ForStatement";
-  init?: VariableDeclaration | Expression | null | undefined;
-  test?: Expression | null | undefined;
-  update?: Expression | null | undefined;
-  body: Statement;
-}
-interface BaseForXStatement extends BaseStatement {
-  left: VariableDeclaration | Pattern;
-  right: Expression;
-  body: Statement;
-}
-interface ForInStatement extends BaseForXStatement {
-  type: "ForInStatement";
-}
-interface DebuggerStatement extends BaseStatement {
-  type: "DebuggerStatement";
-}
-type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
-interface BaseDeclaration extends BaseStatement {}
-interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
-  type: "FunctionDeclaration";
-  /** It is null when a function declaration is a part of the `export default function` statement */
-  id: Identifier | null;
-  body: BlockStatement;
-}
-interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
-  id: Identifier;
-}
-interface VariableDeclaration extends BaseDeclaration {
-  type: "VariableDeclaration";
-  declarations: VariableDeclarator[];
-  kind: "var" | "let" | "const" | "using" | "await using";
-}
-interface VariableDeclarator extends BaseNode {
-  type: "VariableDeclarator";
-  id: Pattern;
-  init?: Expression | null | undefined;
-}
-interface ExpressionMap {
-  ArrayExpression: ArrayExpression;
-  ArrowFunctionExpression: ArrowFunctionExpression;
-  AssignmentExpression: AssignmentExpression;
-  AwaitExpression: AwaitExpression;
-  BinaryExpression: BinaryExpression;
-  CallExpression: CallExpression;
-  ChainExpression: ChainExpression;
-  ClassExpression: ClassExpression;
-  ConditionalExpression: ConditionalExpression;
-  FunctionExpression: FunctionExpression;
-  Identifier: Identifier;
-  ImportExpression: ImportExpression;
-  Literal: Literal;
-  LogicalExpression: LogicalExpression;
-  MemberExpression: MemberExpression;
-  MetaProperty: MetaProperty;
-  NewExpression: NewExpression;
-  ObjectExpression: ObjectExpression;
-  SequenceExpression: SequenceExpression;
-  TaggedTemplateExpression: TaggedTemplateExpression;
-  TemplateLiteral: TemplateLiteral;
-  ThisExpression: ThisExpression;
-  UnaryExpression: UnaryExpression;
-  UpdateExpression: UpdateExpression;
-  YieldExpression: YieldExpression;
-}
-type Expression = ExpressionMap[keyof ExpressionMap];
-interface BaseExpression extends BaseNode {}
-type ChainElement = SimpleCallExpression | MemberExpression;
-interface ChainExpression extends BaseExpression {
-  type: "ChainExpression";
-  expression: ChainElement;
-}
-interface ThisExpression extends BaseExpression {
-  type: "ThisExpression";
-}
-interface ArrayExpression extends BaseExpression {
-  type: "ArrayExpression";
-  elements: Array<Expression | SpreadElement | null>;
-}
-interface ObjectExpression extends BaseExpression {
-  type: "ObjectExpression";
-  properties: Array<Property | SpreadElement>;
-}
-interface PrivateIdentifier extends BaseNode {
-  type: "PrivateIdentifier";
-  name: string;
-}
-interface Property extends BaseNode {
-  type: "Property";
-  key: Expression | PrivateIdentifier;
-  value: Expression | Pattern; // Could be an AssignmentProperty
-  kind: "init" | "get" | "set";
-  method: boolean;
-  shorthand: boolean;
-  computed: boolean;
-}
-interface PropertyDefinition extends BaseNode {
-  type: "PropertyDefinition";
-  key: Expression | PrivateIdentifier;
-  value?: Expression | null | undefined;
-  computed: boolean;
-  static: boolean;
-}
-interface FunctionExpression extends BaseFunction, BaseExpression {
-  id?: Identifier | null | undefined;
-  type: "FunctionExpression";
-  body: BlockStatement;
-}
-interface SequenceExpression extends BaseExpression {
-  type: "SequenceExpression";
-  expressions: Expression[];
-}
-interface UnaryExpression extends BaseExpression {
-  type: "UnaryExpression";
-  operator: UnaryOperator;
-  prefix: true;
-  argument: Expression;
-}
-interface BinaryExpression extends BaseExpression {
-  type: "BinaryExpression";
-  operator: BinaryOperator;
-  left: Expression | PrivateIdentifier;
-  right: Expression;
-}
-interface AssignmentExpression extends BaseExpression {
-  type: "AssignmentExpression";
-  operator: AssignmentOperator;
-  left: Pattern | MemberExpression;
-  right: Expression;
-}
-interface UpdateExpression extends BaseExpression {
-  type: "UpdateExpression";
-  operator: UpdateOperator;
-  argument: Expression;
-  prefix: boolean;
-}
-interface LogicalExpression extends BaseExpression {
-  type: "LogicalExpression";
-  operator: LogicalOperator;
-  left: Expression;
-  right: Expression;
-}
-interface ConditionalExpression extends BaseExpression {
-  type: "ConditionalExpression";
-  test: Expression;
-  alternate: Expression;
-  consequent: Expression;
-}
-interface BaseCallExpression extends BaseExpression {
-  callee: Expression | Super;
-  arguments: Array<Expression | SpreadElement>;
-}
-type CallExpression = SimpleCallExpression | NewExpression;
-interface SimpleCallExpression extends BaseCallExpression {
-  type: "CallExpression";
-  optional: boolean;
-}
-interface NewExpression extends BaseCallExpression {
-  type: "NewExpression";
-}
-interface MemberExpression extends BaseExpression, BasePattern {
-  type: "MemberExpression";
-  object: Expression | Super;
-  property: Expression | PrivateIdentifier;
-  computed: boolean;
-  optional: boolean;
-}
-type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
-interface BasePattern extends BaseNode {}
-interface SwitchCase extends BaseNode {
-  type: "SwitchCase";
-  test?: Expression | null | undefined;
-  consequent: Statement[];
-}
-interface CatchClause extends BaseNode {
-  type: "CatchClause";
-  param: Pattern | null;
-  body: BlockStatement;
-}
-interface Identifier extends BaseNode, BaseExpression, BasePattern {
-  type: "Identifier";
-  name: string;
-}
-type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
-interface SimpleLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value: string | boolean | number | null;
-  raw?: string | undefined;
-}
-interface RegExpLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: RegExp | null | undefined;
-  regex: {
-    pattern: string;
-    flags: string;
-  };
-  raw?: string | undefined;
-}
-interface BigIntLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: bigint | null | undefined;
-  bigint: string;
-  raw?: string | undefined;
-}
-type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
-type LogicalOperator = "||" | "&&" | "??";
-type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
-type UpdateOperator = "++" | "--";
-interface ForOfStatement extends BaseForXStatement {
-  type: "ForOfStatement";
-  await: boolean;
-}
-interface Super extends BaseNode {
-  type: "Super";
-}
-interface SpreadElement extends BaseNode {
-  type: "SpreadElement";
-  argument: Expression;
-}
-interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
-  type: "ArrowFunctionExpression";
-  expression: boolean;
-  body: BlockStatement | Expression;
-}
-interface YieldExpression extends BaseExpression {
-  type: "YieldExpression";
-  argument?: Expression | null | undefined;
-  delegate: boolean;
-}
-interface TemplateLiteral extends BaseExpression {
-  type: "TemplateLiteral";
-  quasis: TemplateElement[];
-  expressions: Expression[];
-}
-interface TaggedTemplateExpression extends BaseExpression {
-  type: "TaggedTemplateExpression";
-  tag: Expression;
-  quasi: TemplateLiteral;
-}
-interface TemplateElement extends BaseNode {
-  type: "TemplateElement";
-  tail: boolean;
-  value: {
-    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */cooked?: string | null | undefined;
-    raw: string;
-  };
-}
-interface AssignmentProperty extends Property {
-  value: Pattern;
-  kind: "init";
-  method: boolean; // false
-}
-interface ObjectPattern extends BasePattern {
-  type: "ObjectPattern";
-  properties: Array<AssignmentProperty | RestElement>;
-}
-interface ArrayPattern extends BasePattern {
-  type: "ArrayPattern";
-  elements: Array<Pattern | null>;
-}
-interface RestElement extends BasePattern {
-  type: "RestElement";
-  argument: Pattern;
-}
-interface AssignmentPattern extends BasePattern {
-  type: "AssignmentPattern";
-  left: Pattern;
-  right: Expression;
-}
-interface BaseClass extends BaseNode {
-  superClass?: Expression | null | undefined;
-  body: ClassBody;
-}
-interface ClassBody extends BaseNode {
-  type: "ClassBody";
-  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
-}
-interface MethodDefinition extends BaseNode {
-  type: "MethodDefinition";
-  key: Expression | PrivateIdentifier;
-  value: FunctionExpression;
-  kind: "constructor" | "method" | "get" | "set";
-  computed: boolean;
-  static: boolean;
-}
-interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
-  type: "ClassDeclaration";
-  /** It is null when a class declaration is a part of the `export default class` statement */
-  id: Identifier | null;
-}
-interface ClassDeclaration extends MaybeNamedClassDeclaration {
-  id: Identifier;
-}
-interface ClassExpression extends BaseClass, BaseExpression {
-  type: "ClassExpression";
-  id?: Identifier | null | undefined;
-}
-interface MetaProperty extends BaseExpression {
-  type: "MetaProperty";
-  meta: Identifier;
-  property: Identifier;
-}
-interface ImportExpression extends BaseExpression {
-  type: "ImportExpression";
-  source: Expression;
-  options?: Expression | null | undefined;
-}
-interface AwaitExpression extends BaseExpression {
-  type: "AwaitExpression";
-  argument: Expression;
-}
-//#endregion
-//#region src/createRule.d.ts
-type ASTBodyExpression = Expression & {
-  properties: ASTBodyProperty[];
-};
-type ASTBodyProperty = AST.JSONProperty & {
-  value: string;
-};
-interface ASTBodyStatement extends ExpressionStatement {
-  expression: ASTBodyExpression;
-}
-interface PackageAST extends AST$1.Program {
-  body: [ASTBodyStatement];
-}
-interface PackageJsonPluginSettings {
-  /**
-   * Whether `require-*` rules, if used, should enforce the presence of
-   * the corresponding property *in package.json files with `"private": true`*.
-   *
-   * If not specified, it will not enforce the presence only of `name` and `version` properties.
-   */
-  enforceForPrivate?: boolean;
-}
-interface PackageJsonRuleContext<Options extends unknown[] = unknown[]> extends Rule.RuleContext {
-  options: Options;
-  settings: {
-    packageJson?: PackageJsonPluginSettings;
-  };
-  sourceCode: PackageJsonSourceCode;
-}
-interface PackageJsonRuleModule<Options extends unknown[] = unknown[], Schema extends JSONSchema[] = JSONSchema[]> {
-  create(context: PackageJsonRuleContext<Options>): RuleListener;
-  meta: Omit<Rule.RuleMetaData, 'defaultOptions' | 'docs' | 'schema'> & {
-    defaultOptions?: NoInfer<Options>;
-    docs?: Rule.RuleMetaData['docs'] & {
-      category?: string; /** An optional route segment to group this rule under */
-      ruleGroup?: string;
-    };
-    schema?: Schema;
-  };
-}
-interface PackageJsonSourceCode extends SourceCode {
-  ast: PackageAST;
-}
-//#endregion
-export { PackageJsonRuleModule as n, JSONSchema as r, PackageJsonPluginSettings as t };