UNPKG

5.47 kBTypeScriptView Raw
1import { JsonSchemaErrorBase } from './error';
2import { Serializer } from './serializer';
3import { SchemaNode, TypeScriptType } from './node';
4export declare class InvalidSchema extends JsonSchemaErrorBase {
5}
6export declare class InvalidValueError extends JsonSchemaErrorBase {
7}
8export declare class MissingImplementationError extends JsonSchemaErrorBase {
9}
10export declare class SettingReadOnlyPropertyError extends JsonSchemaErrorBase {
11}
12export declare class InvalidUpdateValue extends JsonSchemaErrorBase {
13}
14export interface Schema {
15 [key: string]: any;
16}
17/** This interface is defined to simplify the arguments passed in to the SchemaTreeNode. */
18export declare type TreeNodeConstructorArgument<T> = {
19 parent?: SchemaTreeNode<T>;
20 name?: string;
21 value: T;
22 forward?: SchemaTreeNode<any>;
23 schema: Schema;
24};
25/**
26 * Holds all the information, including the value, of a node in the schema tree.
27 */
28export declare abstract class SchemaTreeNode<T> implements SchemaNode {
29 protected _parent: SchemaTreeNode<any>;
30 protected _defined: boolean;
31 protected _dirty: boolean;
32 protected _schema: Schema;
33 protected _name: string;
34 protected _value: T;
35 protected _forward: SchemaTreeNode<any>;
36 constructor(nodeMetaData: TreeNodeConstructorArgument<T>);
37 dispose(): void;
38 readonly defined: boolean;
39 dirty: boolean;
40 readonly value: T;
41 readonly abstract type: string;
42 readonly abstract tsType: TypeScriptType;
43 abstract destroy(): void;
44 readonly abstract defaultValue: any | null;
45 readonly name: string;
46 readonly readOnly: boolean;
47 readonly frozen: boolean;
48 readonly description: any;
49 readonly required: boolean;
50 isChildRequired(_name: string): boolean;
51 readonly parent: SchemaTreeNode<any>;
52 readonly children: {
53 [key: string]: SchemaTreeNode<any>;
54 } | null;
55 readonly items: SchemaTreeNode<any>[] | null;
56 readonly itemPrototype: SchemaTreeNode<any> | null;
57 abstract get(): T;
58 set(_v: T, _init?: boolean, _force?: boolean): void;
59 isCompatible(_v: any): boolean;
60 abstract serialize(serializer: Serializer): void;
61 protected static _defineProperty<T>(proto: any, treeNode: SchemaTreeNode<T>): void;
62}
63/** Base Class used for Non-Leaves TreeNode. Meaning they can have children. */
64export declare abstract class NonLeafSchemaTreeNode<T> extends SchemaTreeNode<T> {
65 dispose(): void;
66 get(): T;
67 destroy(): void;
68 protected _createChildProperty<T>(name: string, value: T, forward: SchemaTreeNode<T>, schema: Schema, define?: boolean): SchemaTreeNode<T>;
69}
70export declare class OneOfSchemaTreeNode extends NonLeafSchemaTreeNode<any> {
71 protected _typesPrototype: SchemaTreeNode<any>[];
72 protected _currentTypeHolder: SchemaTreeNode<any> | null;
73 constructor(metaData: TreeNodeConstructorArgument<any>);
74 _set(v: any, init: boolean, force: boolean): void;
75 set(v: any, _init?: boolean, force?: boolean): void;
76 get(): any;
77 readonly defaultValue: any | null;
78 readonly defined: boolean;
79 readonly items: SchemaTreeNode<any>[];
80 readonly type: string;
81 readonly tsType: null;
82 serialize(serializer: Serializer): void;
83}
84/** A Schema Tree Node that represents an object. */
85export declare class ObjectSchemaTreeNode extends NonLeafSchemaTreeNode<{
86 [key: string]: any;
87}> {
88 protected _children: {
89 [key: string]: SchemaTreeNode<any>;
90 };
91 protected _frozen: boolean;
92 constructor(metaData: TreeNodeConstructorArgument<any>);
93 _set(value: any, init: boolean, force: boolean): void;
94 set(v: any, force?: boolean): void;
95 readonly frozen: boolean;
96 readonly children: {
97 [key: string]: SchemaTreeNode<any>;
98 } | null;
99 readonly type: string;
100 readonly tsType: ObjectConstructor;
101 readonly defaultValue: any | null;
102 isCompatible(v: any): boolean;
103 isChildRequired(name: string): boolean;
104 serialize(serializer: Serializer): void;
105}
106/** A Schema Tree Node that represents an array. */
107export declare class ArraySchemaTreeNode extends NonLeafSchemaTreeNode<Array<any>> {
108 protected _items: SchemaTreeNode<any>[];
109 protected _itemPrototype: SchemaTreeNode<any>;
110 constructor(metaData: TreeNodeConstructorArgument<Array<any>>);
111 _set(value: any, init: boolean, _force: boolean): void;
112 set(v: any, init?: boolean, force?: boolean): void;
113 isCompatible(v: any): boolean;
114 readonly type: string;
115 readonly tsType: ArrayConstructor;
116 readonly items: SchemaTreeNode<any>[];
117 readonly itemPrototype: SchemaTreeNode<any>;
118 readonly defaultValue: any | null;
119 serialize(serializer: Serializer): void;
120}
121/**
122 * The root class of the tree node. Receives a prototype that will be filled with the
123 * properties of the Schema root.
124 */
125export declare class RootSchemaTreeNode extends ObjectSchemaTreeNode {
126 constructor(proto: any, metaData: TreeNodeConstructorArgument<Object>);
127}
128/** A leaf in the schema tree. Must contain a single primitive value. */
129export declare abstract class LeafSchemaTreeNode<T> extends SchemaTreeNode<T> {
130 protected _default: T;
131 constructor(metaData: TreeNodeConstructorArgument<T>);
132 get(): any;
133 set(v: T, init?: boolean, force?: boolean): void;
134 destroy(): void;
135 readonly defaultValue: T;
136 readonly hasDefault: boolean;
137 abstract convert(v: any): T;
138 abstract isCompatible(v: any): boolean;
139 serialize(serializer: Serializer): void;
140}