@jsonjoy.com/json-type/lib/type/classes/AbsType.d.ts

High-performance JSON Pointer implementation

import type * as schema from '../../schema';
import type { Printable } from 'tree-dump/lib/types';
import { ValidatorCodegenContext, type ValidatorCodegenContextOptions } from '../../codegen/validator/ValidatorCodegenContext';
import type { JsonTypeValidator, ValidationPath } from '../../codegen/validator/types';
import { JsonTextEncoderCodegenContext, type JsonTextEncoderCodegenContextOptions, type JsonEncoderFn } from '../../codegen/json/JsonTextEncoderCodegenContext';
import type { CompiledBinaryEncoder } from '../../codegen/types';
import { CborEncoderCodegenContext, type CborEncoderCodegenContextOptions } from '../../codegen/binary/CborEncoderCodegenContext';
import { JsonEncoderCodegenContext, type JsonEncoderCodegenContextOptions } from '../../codegen/binary/JsonEncoderCodegenContext';
import { JsExpression } from '@jsonjoy.com/util/lib/codegen/util/JsExpression';
import { MessagePackEncoderCodegenContext, type MessagePackEncoderCodegenContextOptions } from '../../codegen/binary/MessagePackEncoderCodegenContext';
import { EncodingFormat } from '@jsonjoy.com/json-pack/lib/constants';
import { CapacityEstimatorCodegenContext, type CapacityEstimatorCodegenContextOptions, type CompiledCapacityEstimator } from '../../codegen/capacity/CapacityEstimatorCodegenContext';
import type { TExample } from '../../schema';
import type { JsonValueCodec } from '@jsonjoy.com/json-pack/lib/codecs/types';
import type * as jsonSchema from '../../json-schema';
import type { BaseType } from '../types';
import type { TypeSystem } from '../../system/TypeSystem';
import type { json_string } from '@jsonjoy.com/util/lib/json-brand';
import type * as ts from '../../typescript/types';
import type { TypeExportContext } from '../../system/TypeExportContext';
import type { Validators } from './types';
import type * as jtd from '../../jtd/types';
export declare abstract class AbsType<S extends schema.Schema> implements BaseType<S>, Printable {
    /** Default type system to use, if any. */
    system?: TypeSystem;
    protected validators: Validators;
    protected encoders: Map<EncodingFormat, CompiledBinaryEncoder>;
    /** @todo Retype this to `Schema`. */
    protected abstract schema: S;
    getSystem(): TypeSystem;
    getTypeName(): S['kind'];
    /**
     * @todo Add ability to export the whole schema, including aliases.
     */
    getSchema(): S;
    getValidatorNames(): string[];
    toJsonSchema(ctx?: TypeExportContext): jsonSchema.JsonSchemaNode;
    options(options: schema.Optional<S>): this;
    title(title: string): this;
    intro(intro: string): this;
    description(description: string): this;
    default(value: schema.Schema['default']): this;
    example(value: schema.TypeOf<S>, title?: TExample['title'], options?: Omit<TExample, 'value' | 'title'>): this;
    getOptions(): schema.Optional<S>;
    /** Validates own schema, throws on errors. */
    validateSchema(): void;
    validate(value: unknown): void;
    compileValidator(options: Partial<Omit<ValidatorCodegenContextOptions, 'type'>>): JsonTypeValidator;
    private __compileValidator;
    validator(kind: keyof Validators): JsonTypeValidator;
    protected compileJsonTextEncoder(options: Omit<JsonTextEncoderCodegenContextOptions, 'type'>): JsonEncoderFn;
    codegenJsonTextEncoder(ctx: JsonTextEncoderCodegenContext, value: JsExpression): void;
    private __jsonEncoder;
    jsonTextEncoder(): JsonEncoderFn;
    compileEncoder(format: EncodingFormat, name?: string): CompiledBinaryEncoder;
    encoder(kind: EncodingFormat): CompiledBinaryEncoder;
    encode(codec: JsonValueCodec, value: unknown): Uint8Array;
    codegenValidator(ctx: ValidatorCodegenContext, path: ValidationPath, r: string): void;
    compileCborEncoder(options: Omit<CborEncoderCodegenContextOptions, 'type' | 'encoder'>): CompiledBinaryEncoder;
    codegenCborEncoder(ctx: CborEncoderCodegenContext, value: JsExpression): void;
    compileMessagePackEncoder(options: Omit<MessagePackEncoderCodegenContextOptions, 'type' | 'encoder'>): CompiledBinaryEncoder;
    codegenMessagePackEncoder(ctx: MessagePackEncoderCodegenContext, value: JsExpression): void;
    compileJsonEncoder(options: Omit<JsonEncoderCodegenContextOptions, 'type' | 'encoder'>): CompiledBinaryEncoder;
    codegenJsonEncoder(ctx: JsonEncoderCodegenContext, value: JsExpression): void;
    codegenCapacityEstimator(ctx: CapacityEstimatorCodegenContext, value: JsExpression): void;
    compileCapacityEstimator(options: Omit<CapacityEstimatorCodegenContextOptions, 'type'>): CompiledCapacityEstimator;
    private __capacityEstimator;
    capacityEstimator(): CompiledCapacityEstimator;
    random(): unknown;
    toTypeScriptAst(): ts.TsType;
    toJson(value: unknown, system?: TypeSystem | undefined): json_string<unknown>;
    protected toStringTitle(): string;
    protected toStringOptions(): string;
    protected toStringName(): string;
    toString(tab?: string): string;
    toJtdForm(): jtd.JtdForm;
}