import IOValidationError from './errors/io-validation-error.js';
import IOSyntaxError from './errors/io-syntax-error.js';
import GeneralErrorCodes from './errors/general-error-codes.js';
import TokenizationErrorCodes from './errors/tokenization-error-codes.js';
import ParsingErrorCodes from './errors/parsing-error-codes.js';
import ValidationErrorCodes from './errors/validation-error-codes.js';
import IOError from './errors/io-error.js';
import Decimal from './core/decimal/decimal.js';
import IOSchema from './schema/schema.js';
import IOHeader from './core/header.js';
import IOObject from './core/internet-object.js';
import IOCollection from './core/collection.js';
import IOSection from './core/section.js';
import IOSectionCollection from './core/section-collection.js';
import IODefinitions from './core/definitions.js';
import IODocument from './core/document.js';
import { ioDocument, ioObject, ioDefinitions, ioSchema } from './template-funcs.js';
export { IOStreamSource, IOStreamTransport, StreamItem, StreamReaderOptions, StreamWriterOptions } from './streaming/types.js';
import { createStreamReader } from './streaming/reader.js';
export { IOStreamReader } from './streaming/reader.js';
import { createStreamWriter } from './streaming/writer.js';
export { BufferTransport, createPushSource } from './streaming/adapters.js';
import { validate, validateObject, validateCollection } from './facade/validate.js';
export { ValidationResult } from './facade/validate.js';
import { toObject } from './facade/to-object.js';
export { Jsonable, toJSON } from './facade/to-object.js';
import { stringify } from './facade/stringify.js';
import { load, loadObject } from './facade/load.js';
export { LoadObjectOptions, LoadOptions, loadCollection } from './facade/load.js';
import parseSchema from './schema/parse-schema.js';
import parseDefinitions from './parser/parse-defs.js';
import parse from './parser/index.js';
export { default as ErrorCodes } from './errors/io-error-codes.js';
export { LoadInferredOptions, default as loadInferred } from './facade/load-inferred.js';
export { stringifyDocument } from './facade/stringify-document.js';
import io from './facade.js';
import './core/positions.js';
import './schema/types/memberdef.js';
import './schema/schema-types.js';
import './parser/parser-options.js';
import './facade/load-document.js';

declare const IO: {
    parse: typeof parse;
    parseDefs: typeof parseDefinitions;
    parseDefinitions: typeof parseDefinitions;
    parseSchema: typeof parseSchema;
    load: typeof load;
    loadObject: typeof loadObject;
    stringify: typeof stringify;
    toObject: typeof toObject;
    toJSON: typeof toObject;
    validate: typeof validate;
    validateObject: typeof validateObject;
    validateCollection: typeof validateCollection;
    createStreamReader: typeof createStreamReader;
    createStreamWriter: typeof createStreamWriter;
    doc: typeof ioDocument;
    object: typeof ioObject;
    defs: typeof ioDefinitions;
    schema: typeof ioSchema;
    document: typeof ioDocument;
    definitions: typeof ioDefinitions;
    IODocument: typeof IODocument;
    IODefinitions: typeof IODefinitions;
    IOSectionCollection: typeof IOSectionCollection;
    IOSection: typeof IOSection;
    IOCollection: typeof IOCollection;
    IOObject: typeof IOObject;
    IOHeader: typeof IOHeader;
    IOSchema: typeof IOSchema;
    Decimal: typeof Decimal;
    IOError: typeof IOError;
    ErrorCodes: {
        readonly invalidObject: ValidationErrorCodes.invalidObject;
        readonly unknownMember: ValidationErrorCodes.unknownMember;
        readonly duplicateMember: ValidationErrorCodes.duplicateMember;
        readonly additionalValuesNotAllowed: ValidationErrorCodes.additionalValuesNotAllowed;
        readonly invalidArray: ValidationErrorCodes.invalidArray;
        readonly notAnArray: ValidationErrorCodes.notAnArray;
        readonly notAString: ValidationErrorCodes.notAString;
        readonly invalidEmail: ValidationErrorCodes.invalidEmail;
        readonly invalidUrl: ValidationErrorCodes.invalidUrl;
        readonly invalidLength: ValidationErrorCodes.invalidLength;
        readonly invalidMinLength: ValidationErrorCodes.invalidMinLength;
        readonly invalidMaxLength: ValidationErrorCodes.invalidMaxLength;
        readonly invalidPattern: ValidationErrorCodes.invalidPattern;
        readonly unsupportedNumberType: ValidationErrorCodes.unsupportedNumberType;
        readonly notANumber: ValidationErrorCodes.notANumber;
        readonly notAnInteger: ValidationErrorCodes.notAnInteger;
        readonly outOfRange: ValidationErrorCodes.outOfRange;
        readonly invalidRange: ValidationErrorCodes.invalidRange;
        readonly invalidScale: ValidationErrorCodes.invalidScale;
        readonly invalidPrecision: ValidationErrorCodes.invalidPrecision;
        readonly notABool: ValidationErrorCodes.notABool;
        readonly invalidChoice: ValidationErrorCodes.invalidChoice;
        readonly unexpectedToken: ParsingErrorCodes.unexpectedToken;
        readonly expectingBracket: ParsingErrorCodes.expectingBracket;
        readonly unexpectedPositionalMember: ParsingErrorCodes.unexpectedPositionalMember;
        readonly invalidKey: ParsingErrorCodes.invalidKey;
        readonly invalidSchema: ParsingErrorCodes.invalidSchema;
        readonly schemaNotFound: ParsingErrorCodes.schemaNotFound;
        readonly schemaMissing: ParsingErrorCodes.schemaMissing;
        readonly emptyMemberDef: ParsingErrorCodes.emptyMemberDef;
        readonly invalidDefinition: ParsingErrorCodes.invalidDefinition;
        readonly invalidMemberDef: ParsingErrorCodes.invalidMemberDef;
        readonly invalidSchemaName: ParsingErrorCodes.invalidSchemaName;
        readonly variableNotDefined: ParsingErrorCodes.variableNotDefined;
        readonly schemaNotDefined: ParsingErrorCodes.schemaNotDefined;
        readonly stringNotClosed: TokenizationErrorCodes.stringNotClosed;
        readonly invalidEscapeSequence: TokenizationErrorCodes.invalidEscapeSequence;
        readonly unsupportedAnnotation: TokenizationErrorCodes.unsupportedAnnotation;
        readonly invalidBase64: TokenizationErrorCodes.invalidBase64;
        readonly invalidDateTime: TokenizationErrorCodes.invalidDateTime;
        readonly invalidType: GeneralErrorCodes.invalidType;
        readonly invalidValue: GeneralErrorCodes.invalidValue;
        readonly valueRequired: GeneralErrorCodes.valueRequired;
        readonly nullNotAllowed: GeneralErrorCodes.nullNotAllowed;
        readonly definitionsRequired: GeneralErrorCodes.definitionsRequired;
        readonly expectedObject: GeneralErrorCodes.expectedObject;
        readonly expectedArray: GeneralErrorCodes.expectedArray;
    };
    IOSyntaxError: typeof IOSyntaxError;
    IOValidationError: typeof IOValidationError;
};

export { Decimal, IO, IOCollection, IODefinitions, IODocument, IOError, IOHeader, IOObject, IOSchema, IOSection, IOSectionCollection, IOSyntaxError, IOValidationError, createStreamReader, createStreamWriter, io as default, ioDefinitions, ioDocument, ioObject, ioSchema, load, loadObject, parse, parseDefinitions, parseDefinitions as parseDefs, parseSchema, stringify, toObject, validate, validateCollection, validateObject };