@sprucelabs/schema 25.5.65 → 25.5.69

package/build/esm/__tests__/behavioral/UsingSchemas.test.js

@@ -1,281 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { test, assert } from '@sprucelabs/test';
-import { errorAssertUtil } from '@sprucelabs/test-utils';
-import { unset } from 'lodash';
-import AbstractSchemaTest from '../../AbstractSchemaTest.js';
-import StaticSchemaEntityImplementation from '../../StaticSchemaEntityImplementation.js';
-import buildSchema from '../../utilities/buildSchema.js';
-import isSchemaValid from '../../utilities/isSchemaValid.js';
-import validateSchema from '../../utilities/validateSchema.js';
-import buildPersonWithCars from '../data/personWithCars.js';
-StaticSchemaEntityImplementation.enableDuplicateCheckWhenTracking = false;
-const { personSchema, truckSchema } = buildPersonWithCars();
-const nestedSchemas = buildSchema({
-    id: 'contract',
-    name: 'contract',
-    fields: {
-        requiredArrayField: {
-            type: 'schema',
-            isArray: true,
-            isRequired: true,
-            options: {
-                schema: {
-                    id: 'nested',
-                    name: 'Nested',
-                    fields: {
-                        fieldOnNested: {
-                            type: 'text',
-                            isRequired: true,
-                        },
-                    },
-                },
-            },
-        },
-    },
-});
-const nestedSingleRequiredFieldSchemas = buildSchema({
-    id: 'singleRequiredField',
-    name: 'single required field',
-    fields: {
-        contract: {
-            type: 'schema',
-            isRequired: true,
-            options: {
-                schema: nestedSchemas,
-            },
-        },
-    },
-});
-export default class SchemaTest extends AbstractSchemaTest {
-    static testBasicValidation() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = {
-                id: 'simple-test',
-                name: 'Simple Test Schema',
-            };
-            assert.isFalse(isSchemaValid(schema), 'Bad definition incorrectly passed valid check');
-        });
-    }
-    static testMissingKeys(fieldToDelete, expectedErrors) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = buildSchema({
-                id: 'missing-fields',
-                name: 'missing name',
-                fields: {
-                    firstName: {
-                        type: 'text',
-                    },
-                    lastName: {
-                        type: 'text',
-                    },
-                },
-            });
-            unset(schema, fieldToDelete);
-            const error = assert.doesThrow(() => validateSchema(schema));
-            errorAssertUtil.assertError(error, 'INVALID_SCHEMA', {
-                errors: expectedErrors,
-            });
-        });
-    }
-    static canIsArrayValue() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = buildSchema({
-                id: 'is-array-test',
-                name: 'is array',
-                fields: {
-                    name: {
-                        type: 'text',
-                        label: 'Name',
-                        value: 'Tay',
-                    },
-                    nicknames: {
-                        type: 'text',
-                        label: 'Nick names',
-                        isArray: true,
-                        value: ['Tay', 'Taylor'],
-                    },
-                    anotherName: {
-                        type: 'number',
-                        label: 'Favorite numbers',
-                        isArray: true,
-                        value: [10, 5, 5],
-                    },
-                    schemaField: {
-                        type: 'schema',
-                        label: 'Favorite numbers',
-                        isArray: true,
-                        options: {
-                            schema: {
-                                id: 'nested',
-                                name: 'Nested',
-                                fields: {},
-                            },
-                        },
-                    },
-                },
-            });
-            assert.isTrue(isSchemaValid(schema));
-        });
-    }
-    static getSetArrays() {
-        const entity = new StaticSchemaEntityImplementation({
-            id: 'missing-fields',
-            name: 'missing name',
-            fields: {
-                name: {
-                    type: 'text',
-                    isArray: false,
-                    value: 'tay',
-                },
-                favoriteColors: {
-                    type: 'text',
-                    isArray: true,
-                    value: ['black'],
-                },
-            },
-        });
-        let values = entity.getValues({ fields: ['name'] });
-        assert.isEqual(values.name, 'tay');
-        assert.isUndefined(
-        //@ts-ignore
-        values.favoriteColors, 'getValues did not filter by fields');
-        entity.set('favoriteColors', ['test']);
-        assert.isEqualDeep(entity.get('favoriteColors'), ['test'], 'Did not set value correctly');
-        // @ts-ignore
-        entity.set('favoriteColors', 'test2');
-        assert.isEqualDeep(entity.get('favoriteColors'), ['test2'], 'Did not set value correctly');
-        entity.set('name', 'Taylor');
-        assert.isEqualDeep(entity.getValues(), {
-            name: 'Taylor',
-            favoriteColors: ['test2'],
-        });
-        // @ts-ignore
-        entity.setValues({ name: ['becca'], favoriteColors: 'blue' });
-        const name = entity.get('name');
-        assert.isEqual(name, 'becca');
-        const colors = entity.get('favoriteColors');
-        assert.isTrue(Array.isArray(colors), 'Getter did not transform colors into array');
-    }
-    static testTransformingValuesToValueTypes() {
-        const schema = new StaticSchemaEntityImplementation({
-            id: 'is-array-transform',
-            name: 'transform tests',
-            fields: {
-                name: {
-                    type: 'text',
-                    isArray: false,
-                    value: 'tay',
-                },
-                favoriteColors: {
-                    type: 'text',
-                    isArray: true,
-                    value: ['blue'],
-                },
-                favoriteNumber: {
-                    type: 'number',
-                },
-            },
-        });
-        // @ts-ignore
-        schema.set('favoriteColors', [1, 2, 3]);
-        const favColors = schema.get('favoriteColors');
-        assert.isEqualDeep(favColors, ['1', '2', '3']);
-        // @ts-ignore
-        schema.set('favoriteNumber', ['9', '8', '100']);
-        const favNumber = schema.get('favoriteNumber');
-        assert.isEqual(favNumber, 9, 'Schema did not transform array of strings to single number');
-    }
-    static testValuesTypesAgainstObjectLiteral() {
-        const values = {
-            name: 'test',
-            onlyOnCar: null,
-        };
-        assert.isType(values);
-    }
-    static testFullValuesTypes() {
-        const personEntity = new StaticSchemaEntityImplementation(personSchema);
-        const values = personEntity.getValues({ shouldValidate: false });
-        const valuesWithoutInstances = personEntity.getValues({
-            shouldValidate: false,
-            shouldCreateEntityInstances: false,
-        });
-        assert.isType(values);
-        assert.isType(values);
-        assert.isType(valuesWithoutInstances);
-    }
-    static testGettingOptionsByField() {
-        const entity = new StaticSchemaEntityImplementation(personSchema);
-        entity.set('name', 'a really long name that should get truncated');
-        const name = entity.get('name', { byField: { name: { maxLength: 10 } } });
-        assert.isEqual(name, 'a really l');
-    }
-    static canCorrectlyTypeSchemaWithOneRequiredField() {
-        const values = {
-            contract: {
-                requiredArrayField: [],
-            },
-        };
-        const { contract: { requiredArrayField }, } = values;
-        function testFunc(_options) { }
-        testFunc(requiredArrayField[0]);
-        assert.isExactType(true);
-    }
-    static testGenerics() {
-        const testObj = {
-            payloadSchema: nestedSingleRequiredFieldSchemas,
-            callback: (payload) => {
-                const { requiredArrayField } = payload.contract;
-                const mappedArray = requiredArrayField.map((item) => item.fieldOnNested);
-                assert.isExactType(true);
-            },
-        };
-        assert.isTruthy(testObj);
-    }
-}
-__decorate([
-    test()
-], SchemaTest, "testBasicValidation", null);
-__decorate([
-    test('Catches missing id', 'id', ['id_missing']),
-    test('Catches missing fields', 'fields', [
-        'needs_fields_or_dynamic_field_signature',
-    ])
-], SchemaTest, "testMissingKeys", null);
-__decorate([
-    test('Does isArray make value an array (test always passes, linting should fail if broken)')
-], SchemaTest, "canIsArrayValue", null);
-__decorate([
-    test()
-], SchemaTest, "getSetArrays", null);
-__decorate([
-    test()
-], SchemaTest, "testTransformingValuesToValueTypes", null);
-__decorate([
-    test()
-], SchemaTest, "testValuesTypesAgainstObjectLiteral", null);
-__decorate([
-    test()
-], SchemaTest, "testFullValuesTypes", null);
-__decorate([
-    test()
-], SchemaTest, "testGettingOptionsByField", null);
-__decorate([
-    test()
-], SchemaTest, "canCorrectlyTypeSchemaWithOneRequiredField", null);
-__decorate([
-    test()
-], SchemaTest, "testGenerics", null);

package/build/esm/__tests__/behavioral/UsingTheSchemaRegisteryForNamespacedSchemas.test.d.ts

@@ -1,14 +0,0 @@
-import { SchemaRegistry } from '../..';
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-import { Schema } from '../../schemas.static.types';
-export default class UsingTheSchemaRegisteryForNamespacedSchemasTest extends AbstractSchemaTest {
-    protected static registry: SchemaRegistry;
-    protected static beforeEach(): Promise<void>;
-    protected static throwsErrorIncludingNamespaceWhenNonFound(): void;
-    protected static canRegisterNamespacedSchema(schemas: Schema[], lookups: {
-        id: string;
-        version?: string;
-        namespace?: string;
-        shouldMatchSchemaAtIdx: number;
-    }[]): void;
-}

package/build/esm/__tests__/behavioral/UsingTheSchemaRegisteryForNamespacedSchemas.test.js

@@ -1,140 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { test, assert } from '@sprucelabs/test';
-import { buildSchema, SchemaRegistry } from '../../index.js';
-import AbstractSchemaTest from '../../AbstractSchemaTest.js';
-const namespacedUnVersionedPersonSchema = buildSchema({
-    id: 'namespacedUnVersionedPerson',
-    namespace: 'namespace-one',
-    fields: {
-        firstName: {
-            type: 'text',
-        },
-    },
-});
-const namespaced2UnVersionedPersonSchema = buildSchema({
-    id: 'namespacedUnVersionedPerson',
-    namespace: 'namespace-two',
-    fields: {
-        firstName: {
-            type: 'text',
-        },
-    },
-});
-const namespacedVersionedPersonSchema = buildSchema({
-    id: 'namespacedUnVersionedPerson',
-    namespace: 'namespace-one',
-    version: 'v1',
-    fields: {
-        firstName: {
-            type: 'text',
-        },
-    },
-});
-const namespaced2VersionedPersonSchema = buildSchema({
-    id: 'namespacedUnVersionedPerson',
-    namespace: 'namespace-one',
-    version: 'v2',
-    fields: {
-        firstName: {
-            type: 'text',
-        },
-    },
-});
-export default class UsingTheSchemaRegisteryForNamespacedSchemasTest extends AbstractSchemaTest {
-    static beforeEach() {
-        const _super = Object.create(null, {
-            beforeEach: { get: () => super.beforeEach }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.beforeEach.call(this);
-            this.registry = new SchemaRegistry();
-        });
-    }
-    static throwsErrorIncludingNamespaceWhenNonFound() {
-        assert.doesThrow(() => this.registry.getSchema('made-up-id', '1.0', 'spruce'), /spruce.made-up-id\(version: 1.0\)/gi);
-        assert.doesThrow(() => this.registry.getSchema('made-up-id', '1.0', 'spruce'), /1\.0/gi);
-        assert.doesThrow(() => this.registry.getSchema('made-up-id', undefined, 'spruce'), /spruce/gi);
-    }
-    static canRegisterNamespacedSchema(schemas, lookups) {
-        for (const schema of schemas) {
-            this.registry.trackSchema(schema);
-        }
-        for (const lookup of lookups) {
-            const gotPerson = this.registry.getSchema(lookup.id, lookup.version, lookup.namespace);
-            assert.isTruthy(gotPerson);
-            //@ts-ignore
-            assert.isEqualDeep(schemas[lookup.shouldMatchSchemaAtIdx], gotPerson);
-        }
-    }
-}
-__decorate([
-    test()
-], UsingTheSchemaRegisteryForNamespacedSchemasTest, "throwsErrorIncludingNamespaceWhenNonFound", null);
-__decorate([
-    test('Register 1 schema, 1 namespace', [namespacedUnVersionedPersonSchema], [
-        {
-            id: 'namespacedUnVersionedPerson',
-            namespace: 'namespace-one',
-            shouldMatchSchemaAtIdx: 0,
-        },
-    ]),
-    test('Register 2 schemas with same id, 2 namespaces', [namespacedUnVersionedPersonSchema, namespaced2UnVersionedPersonSchema], [
-        {
-            id: 'namespacedUnVersionedPerson',
-            namespace: 'namespace-two',
-            shouldMatchSchemaAtIdx: 1,
-        },
-        {
-            id: 'namespacedUnVersionedPerson',
-            namespace: 'namespace-one',
-            shouldMatchSchemaAtIdx: 0,
-        },
-    ]),
-    test('Register 2 schemas with same id, 2 versions, 1 namespaces', [namespacedVersionedPersonSchema, namespaced2VersionedPersonSchema], [
-        {
-            id: 'namespacedUnVersionedPerson',
-            version: 'v1',
-            shouldMatchSchemaAtIdx: 0,
-        },
-        {
-            id: 'namespacedUnVersionedPerson',
-            version: 'v2',
-            shouldMatchSchemaAtIdx: 1,
-        },
-    ]),
-    test('Register 3 schemas with same id, 2 versions, 2 namespaces', [
-        namespacedVersionedPersonSchema,
-        namespaced2VersionedPersonSchema,
-        namespaced2UnVersionedPersonSchema,
-    ], [
-        {
-            id: 'namespacedUnVersionedPerson',
-            version: 'v1',
-            shouldMatchSchemaAtIdx: 0,
-        },
-        {
-            id: 'namespacedUnVersionedPerson',
-            version: 'v2',
-            shouldMatchSchemaAtIdx: 1,
-        },
-        {
-            id: 'namespacedUnVersionedPerson',
-            namespace: 'namespace-two',
-            shouldMatchSchemaAtIdx: 2,
-        },
-    ])
-], UsingTheSchemaRegisteryForNamespacedSchemasTest, "canRegisterNamespacedSchema", null);

package/build/esm/__tests__/behavioral/UsingTheSchemaRegistry.test.d.ts

@@ -1,15 +0,0 @@
-import AbstractSpruceTest from '@sprucelabs/test';
-import SchemaRegistry from '../../singletons/SchemaRegistry';
-export default class UsingTheSchemaRegistryTest extends AbstractSpruceTest {
-    protected static registry: SchemaRegistry;
-    protected static beforeEach(): Promise<void>;
-    protected static canAccessRegistryInstance(): void;
-    protected static throwsWhenTrackingTwice(): void;
-    protected static canRegisterUnVersionedSchema(): void;
-    protected static canRegisterVersionAndUnVersionedSchema(): void;
-    protected static schemasCanBeForgotten(): void;
-    private static buildPersonsAllVersions;
-    protected static versionedSchemasAreForgotten(): void;
-    protected static canForgetAllSchemas(): void;
-    protected static canGetAllSchemas(): void;
-}

package/build/esm/__tests__/behavioral/UsingTheSchemaRegistry.test.js

@@ -1,117 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import AbstractSpruceTest, { assert, test } from '@sprucelabs/test';
-import SchemaRegistry from '../../singletons/SchemaRegistry.js';
-import buildPersonWithCars from '../data/personWithCars.js';
-import buildVersionedPersonWithCars from '../data/versionedPersonWithCars.js';
-export default class UsingTheSchemaRegistryTest extends AbstractSpruceTest {
-    static beforeEach() {
-        const _super = Object.create(null, {
-            beforeEach: { get: () => super.beforeEach }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.beforeEach.call(this);
-            SchemaRegistry.getInstance().forgetAllSchemas();
-            this.registry = new SchemaRegistry();
-        });
-    }
-    static canAccessRegistryInstance() {
-        assert.isTruthy(this.registry);
-    }
-    static throwsWhenTrackingTwice() {
-        const { personSchema } = buildPersonWithCars();
-        const { personV1Schema } = buildVersionedPersonWithCars();
-        this.registry.trackSchema(personSchema);
-        this.registry.trackSchema(personV1Schema);
-        assert.doesThrow(() => this.registry.trackSchema(personSchema), /person/i);
-        assert.doesThrow(() => this.registry.trackSchema(personV1Schema), /person\(version: v1\)/);
-    }
-    static canRegisterUnVersionedSchema() {
-        const { personSchema } = buildPersonWithCars();
-        this.registry.trackSchema(personSchema);
-        const gotPerson = this.registry.getSchema(personSchema.id);
-        assert.isEqualDeep(gotPerson, personSchema);
-    }
-    static canRegisterVersionAndUnVersionedSchema() {
-        const { personSchema } = buildPersonWithCars();
-        const { personV1Schema, personV2Schema } = buildVersionedPersonWithCars();
-        this.registry.trackSchema(personSchema);
-        this.registry.trackSchema(personV1Schema);
-        this.registry.trackSchema(personV2Schema);
-        assert.isEqualDeep(this.registry.getSchema(personSchema.id), personSchema);
-        assert.isEqualDeep(this.registry.getSchema(personV1Schema.id, personV1Schema.version), personV1Schema);
-        assert.isEqualDeep(this.registry.getSchema(personV2Schema.id, personV2Schema.version), personV2Schema);
-    }
-    static schemasCanBeForgotten() {
-        const { personSchema } = buildPersonWithCars();
-        this.registry.trackSchema(personSchema);
-        this.registry.forgetSchema(personSchema.id);
-        assert.doesThrow(() => this.registry.getSchema(personSchema.id), /'person'/);
-    }
-    static buildPersonsAllVersions() {
-        const { personSchema } = buildPersonWithCars();
-        const { personV1Schema, personV2Schema } = buildVersionedPersonWithCars();
-        this.registry.trackSchema(personSchema);
-        this.registry.trackSchema(personV1Schema);
-        this.registry.trackSchema(personV2Schema);
-        return { personSchema, personV1Schema, personV2Schema };
-    }
-    static versionedSchemasAreForgotten() {
-        const { personSchema, personV1Schema, personV2Schema } = this.buildPersonsAllVersions();
-        this.registry.forgetSchema(personSchema.id);
-        assert.doesThrow(() => this.registry.getSchema(personSchema.id), /VERSION_NOT_FOUND/);
-        assert.isEqualDeep(this.registry.getSchema(personV1Schema.id, personV1Schema.version), personV1Schema);
-        assert.isEqualDeep(this.registry.getSchema(personV2Schema.id, personV2Schema.version), personV2Schema);
-        this.registry.forgetSchema(personV2Schema.id, personV2Schema.version);
-        assert.doesThrow(() => this.registry.getSchema(personV2Schema.id, personV2Schema.version), /VERSION_NOT_FOUND/);
-    }
-    static canForgetAllSchemas() {
-        const { personSchema, personV1Schema, personV2Schema } = this.buildPersonsAllVersions();
-        this.registry.forgetAllSchemas();
-        for (const schema of [personSchema, personV1Schema, personV2Schema]) {
-            assert.doesThrow(() => this.registry.getSchema(schema.id, schema.version), 'person');
-        }
-    }
-    static canGetAllSchemas() {
-        const { personSchema, personV1Schema, personV2Schema } = this.buildPersonsAllVersions();
-        const pulled = this.registry.getAllSchemas();
-        assert.isEqualDeep(pulled, [personSchema, personV1Schema, personV2Schema]);
-    }
-}
-__decorate([
-    test()
-], UsingTheSchemaRegistryTest, "canAccessRegistryInstance", null);
-__decorate([
-    test()
-], UsingTheSchemaRegistryTest, "throwsWhenTrackingTwice", null);
-__decorate([
-    test()
-], UsingTheSchemaRegistryTest, "canRegisterUnVersionedSchema", null);
-__decorate([
-    test()
-], UsingTheSchemaRegistryTest, "canRegisterVersionAndUnVersionedSchema", null);
-__decorate([
-    test()
-], UsingTheSchemaRegistryTest, "schemasCanBeForgotten", null);
-__decorate([
-    test()
-], UsingTheSchemaRegistryTest, "versionedSchemasAreForgotten", null);
-__decorate([
-    test()
-], UsingTheSchemaRegistryTest, "canForgetAllSchemas", null);
-__decorate([
-    test()
-], UsingTheSchemaRegistryTest, "canGetAllSchemas", null);

package/build/esm/__tests__/behavioral/ValidatingSchemaValues.test.d.ts

@@ -1,28 +0,0 @@
-import AbstractSchemaTest from '../../AbstractSchemaTest';
-export default class CanValidateSchemasTest extends AbstractSchemaTest {
-    protected static beforeEach(): Promise<void>;
-    protected static canValidateBasicSchemaValues(): Promise<void>;
-    protected static canValidateSchemaWithArrayValues(): Promise<void>;
-    protected static typesValidatedValues(): Promise<void>;
-    protected static canValidateSpecificFields(): Promise<void>;
-    protected static canCheckValidityWithoutThrowing(): Promise<void>;
-    protected static canCheckValidityOnDynamicFieldsWithoutThrowing(): Promise<void>;
-    protected static canCheckValidityOnSpecificFields(): Promise<void>;
-    protected static failsOnSpecificFields(): Promise<void>;
-    protected static passesWithValidPerson(): Promise<void>;
-    protected static failsWithBadSchema(): Promise<void>;
-    protected static failsWhenValidatingFieldsNotOnSchema(): Promise<void>;
-    protected static givesInvalidFieldErrorWhenValidatingEmptyArrayNestedSchemas(): Promise<void>;
-    protected static givesInvalidFieldErrorWhenValidatingNestedSchemas(): Promise<void>;
-    protected static canValidateNestedArraySchema(): Promise<void>;
-    protected static canValidateArrayOfUnionValuesMissingRequired(): Promise<void>;
-    protected static canValidateArrayOfUnionValues(): Promise<void>;
-    protected static canValidateArrayOfVersionedUnionValues(): Promise<void>;
-    protected static canValidateArrayOfVersionedUnionValuesAndThrowsReallyHelpfulError(): Promise<void>;
-    protected static throwsWhenAddingExtraFieldAtTopLevel(): void;
-    protected static throwsWhenAddingExtraFieldInNestedSchema(): void;
-    protected static validationErrorsAreTyped(): void;
-    protected static printsSoPretty(): void;
-    protected static dynamicSchemasHaveFieldNameInError(): void;
-    protected static invalidFieldsGiveDescriptionsOnWhySomethingIsInvalid(): void;
-}