Fix types for NodeNext

lib/ajv.ts

@@ -31,39 +31,75 @@ class Ajv extends AjvCore {
   }
 }
 
-module.exports = exports = Ajv
-Object.defineProperty(exports, "__esModule", {value: true})
+export = Ajv
+Object.defineProperty(Ajv, "__esModule", {value: true})
+Object.defineProperty(Ajv, "default", {value: Ajv})
 
-export default Ajv
+// eslint-disable-next-line @typescript-eslint/no-namespace, no-redeclare
+declare namespace Ajv {
+  // compatibility with NodeNext
+  export {Ajv as default}
+}
+
+import * as types from "./types"
+import * as core from "./core"
+import * as compile from "./compile"
+import * as compileValidate from "./compile/validate"
+import * as vocabulariesErrors from "./vocabularies/errors"
+import * as compileRules from "./compile/rules"
+import * as typesJsonSchema from "./types/json-schema"
+import * as compileCodegen from "./compile/codegen"
+import * as runtimeValidationError from "./runtime/validation_error"
+import * as compileRefError from "./compile/ref_error"
+
+// eslint-disable-next-line @typescript-eslint/no-namespace, no-redeclare
+namespace Ajv {
+  /* eslint-disable @typescript-eslint/no-unused-vars */
+  export import Format = types.Format
+  export import FormatDefinition = types.FormatDefinition
+  export import AsyncFormatDefinition = types.AsyncFormatDefinition
+  export import KeywordDefinition = types.KeywordDefinition
+  export import KeywordErrorDefinition = types.KeywordErrorDefinition
+  export import CodeKeywordDefinition = types.CodeKeywordDefinition
+  export import MacroKeywordDefinition = types.MacroKeywordDefinition
+  export import FuncKeywordDefinition = types.FuncKeywordDefinition
+  export import Vocabulary = types.Vocabulary
+  export import Schema = types.Schema
+  export import SchemaObject = types.SchemaObject
+  // eslint-disable-next-line no-shadow
+  export import AnySchemaObject = types.AnySchemaObject
+  export import AsyncSchema = types.AsyncSchema
+  export import AnySchema = types.AnySchema
+  export import ValidateFunction = types.ValidateFunction
+  export import AsyncValidateFunction = types.AsyncValidateFunction
+  export import SchemaValidateFunction = types.SchemaValidateFunction
+  export import ErrorObject = types.ErrorObject
+  export import ErrorNoParams = types.ErrorNoParams
 
-export {
-  Format,
-  FormatDefinition,
-  AsyncFormatDefinition,
-  KeywordDefinition,
-  KeywordErrorDefinition,
-  CodeKeywordDefinition,
-  MacroKeywordDefinition,
-  FuncKeywordDefinition,
-  Vocabulary,
-  Schema,
-  SchemaObject,
-  AnySchemaObject,
-  AsyncSchema,
-  AnySchema,
-  ValidateFunction,
-  AsyncValidateFunction,
-  SchemaValidateFunction,
-  ErrorObject,
-  ErrorNoParams,
-} from "./types"
+  export import Plugin = core.Plugin
+  export import Options = core.Options
+  export import CodeOptions = core.CodeOptions
+  export import InstanceOptions = core.InstanceOptions
+  export import Logger = core.Logger
+  export import ErrorsTextOptions = core.ErrorsTextOptions
 
-export {Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions} from "./core"
-export {SchemaCxt, SchemaObjCxt} from "./compile"
-export {KeywordCxt} from "./compile/validate"
-export {DefinedError} from "./vocabularies/errors"
-export {JSONType} from "./compile/rules"
-export {JSONSchemaType} from "./types/json-schema"
-export {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from "./compile/codegen"
-export {default as ValidationError} from "./runtime/validation_error"
-export {default as MissingRefError} from "./compile/ref_error"
+  export import SchemaCxt = compile.SchemaCxt
+  export import SchemaObjCxt = compile.SchemaObjCxt
+
+  export import KeywordCxt = compileValidate.KeywordCxt
+  export import DefinedError = vocabulariesErrors.DefinedError
+  export import JSONType = compileRules.JSONType
+  export import JSONSchemaType = typesJsonSchema.JSONSchemaType
+  export import _ = compileCodegen._
+  export import str = compileCodegen.str
+  export import stringify = compileCodegen.stringify
+  export import nil = compileCodegen.nil
+  export import Name = compileCodegen.Name
+  export import Code = compileCodegen.Code
+  export import CodeGen = compileCodegen.CodeGen
+  export import CodeGenOptions = compileCodegen.CodeGenOptions
+
+  export import ValidationError = runtimeValidationError.ValidationError
+  export import MissingRefError = compileRefError.MissingRefError
+  /* eslint-enable @typescript-eslint/no-unused-vars */
+}

lib/compile/ref_error.ts

@@ -1,7 +1,7 @@
 import {resolveUrl, normalizeId, getFullPath} from "./resolve"
 import type {UriResolver} from "../types"
 
-export default class MissingRefError extends Error {
+export class MissingRefError extends Error {
   readonly missingRef: string
   readonly missingSchema: string
 
@@ -11,3 +11,5 @@ export default class MissingRefError extends Error {
     this.missingSchema = normalizeId(getFullPath(resolver, this.missingRef))
   }
 }
+
+export default MissingRefError

lib/runtime/validation_error.ts

@@ -1,6 +1,6 @@
 import type {ErrorObject} from "../types"
 
-export default class ValidationError extends Error {
+export class ValidationError extends Error {
   readonly errors: Partial<ErrorObject>[]
   readonly ajv: true
   readonly validation: true
@@ -11,3 +11,5 @@ export default class ValidationError extends Error {
     this.ajv = this.validation = true
   }
 }
+
+export default ValidationError

spec/ajv.ts

@@ -3,4 +3,3 @@ const AjvClass: typeof Ajv = typeof window == "object" ? (window as any).ajv7 :
 
 export default AjvClass
 module.exports = AjvClass
-module.exports.default = AjvClass