@travetto/schema 6.0.0-rc.1 → 6.0.0-rc.2

package/README.md

@@ -13,12 +13,12 @@ npm install @travetto/schema
 yarn add @travetto/schema
 ```
 
-This module's purpose is to allow for proper declaration and validation of data types, in the course of running a program.  The framework defined here, is leveraged in the [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support"), [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework"), [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module."), [OpenAPI Specification](https://github.com/travetto/travetto/tree/main/module/openapi#readme "OpenAPI integration support for the Travetto framework") and [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") modules.  The schema is the backbone of all data transfer, as it helps to provide validation on correctness of input, whether it is a rest request, command line inputs, or a configuration file. 
+This module's purpose is to allow for proper declaration and validation of data types, in the course of running a program.  The framework defined here, is leveraged in the [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support"), [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework"), [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative api for Web Applications with support for the dependency injection."), [OpenAPI Specification](https://github.com/travetto/travetto/tree/main/module/openapi#readme "OpenAPI integration support for the Travetto framework") and [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") modules.  The schema is the backbone of all data transfer, as it helps to provide validation on correctness of input, whether it is a web request, command line inputs, or a configuration file. 
 
 This module provides a mechanism for registering classes and field level information as well the ability to apply that information at runtime.
 
 ## Registration
-The registry's schema information is defined by [Typescript](https://typescriptlang.org) AST and only applies to classes registered with the [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14) decoration.
+The registry's schema information is defined by [Typescript](https://typescriptlang.org) AST and only applies to classes registered with the [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L13) decoration.
 
 ### Classes
 The module utilizes AST transformations to collect schema information, and facilitate the registration process without user intervention. The class can also be described using providing a:
@@ -64,27 +64,27 @@ User:
 ### Fields
 This schema provides a powerful base for data binding and validation at runtime.  Additionally there may be types that cannot be detected, or some information that the programmer would like to override. Below are the supported field decorators:
    *  [@Field](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L25) defines a field that will be serialized.
-   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L65) defines a that field should be required
-   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L72) defines the allowable values that a field can have
-   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L93) defines a regular expression that the field value should match
-   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L101) enforces min length of a string
-   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L111) enforces max length of a string
-   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L101) enforces min value for a date or a number
-   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L111) enforces max value for a date or a number
-   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L138) ensures string field matches basic email regex
-   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L145) ensures string field matches basic telephone regex
-   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L152) ensures string field matches basic url regex
-   *  [@Ignore](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L191) exclude from auto schema registration
-   *  [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L166) ensures number passed in is only a whole number
-   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L172) ensures number passed in allows fractional values
-   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L184) provides support for standard currency
-   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L80) indicates that a field is expecting natural language input, not just discrete values
-   *  [@LongText](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L85) same as text, but expects longer form content
-   *  [@Readonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L52) defines a that field should not be bindable external to the class
-   *  [@Writeonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L46) defines a that field should not be exported in serialization, but that it can be bound to
-   *  [@Secret](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L58) marks a field as being sensitive.  This is used by certain logging activities to ensure sensitive information is not logged out.
-   *  [@Specifier](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L200) attributes additional specifiers to a field, allowing for more specification beyond just the field's type.
-   *  [@SubTypeField](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L206) allows for promoting a given field as the owner of the sub type discriminator (defaults to `type`).
+   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L63) defines a that field should be required
+   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L70) defines the allowable values that a field can have
+   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L91) defines a regular expression that the field value should match
+   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L99) enforces min length of a string
+   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L109) enforces max length of a string
+   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L99) enforces min value for a date or a number
+   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L109) enforces max value for a date or a number
+   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L136) ensures string field matches basic email regex
+   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L143) ensures string field matches basic telephone regex
+   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L150) ensures string field matches basic url regex
+   *  [@Ignore](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L189) exclude from auto schema registration
+   *  [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L164) ensures number passed in is only a whole number
+   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L170) ensures number passed in allows fractional values
+   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L182) provides support for standard currency
+   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L78) indicates that a field is expecting natural language input, not just discrete values
+   *  [@LongText](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L83) same as text, but expects longer form content
+   *  [@Readonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L50) defines a that field should not be bindable external to the class
+   *  [@Writeonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L45) defines a that field should not be exported in serialization, but that it can be bound to
+   *  [@Secret](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L56) marks a field as being sensitive.  This is used by certain logging activities to ensure sensitive information is not logged out.
+   *  [@Specifier](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L198) attributes additional specifiers to a field, allowing for more specification beyond just the field's type.
+   *  [@SubTypeField](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L204) allows for promoting a given field as the owner of the sub type discriminator (defaults to `type`).
 Additionally, schemas can be nested to form more complex data structures that are able to bound and validated. 
 
 Just like the class, all fields can be defined with
@@ -93,7 +93,7 @@ Just like the class, all fields can be defined with
 And similarly, the `description` will be picked up from the [JSDoc](http://usejsdoc.org/about-getting-started.html) comments, and additionally all fields can be set using the [@Describe](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/common.ts#L15) decorator.
 
 ### Parameters
-Parameters are available in certain scenarios (e.g. [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.") endpoints and [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework") main methods).  In these scenarios, all of the field decorators are valid, but need to be called slightly differently to pass the typechecker. The simple solution is to use the `Arg` field of the decorator to convince Typescript its the correct type.
+Parameters are available in certain scenarios (e.g. [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative api for Web Applications with support for the dependency injection.") endpoints and [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework") main methods).  In these scenarios, all of the field decorators are valid, but need to be called slightly differently to pass the typechecker. The simple solution is to use the `Arg` field of the decorator to convince Typescript its the correct type.
 
 **Code: Sample Parameter Usage**
 ```typescript
@@ -112,7 +112,7 @@ export class ParamUsage {
 At runtime, once a schema is registered, a programmer can utilize this structure to perform specific operations. Specifically binding and validation.
 
 ### Binding
-Binding is a very simple operation, as it takes in a class registered as as [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14) and a JS object that will be the source of the binding. Given the schema:
+Binding is a very simple operation, as it takes in a class registered as as [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L13) and a JS object that will be the source of the binding. Given the schema:
 
 **Code: Sub Schemas via Address**
 ```typescript
@@ -136,7 +136,7 @@ A binding operation could look like:
 
 **Code: Binding from JSON to Schema**
 ```typescript
-import { Person } from './person';
+import { Person } from './person.ts';
 
 export function Test(): Person {
   return Person.from({
@@ -192,7 +192,7 @@ But now with an invalid json object
 ```typescript
 import { SchemaValidator } from '@travetto/schema';
 
-import { Person } from './person';
+import { Person } from './person.ts';
 
 export async function validate(): Promise<void> {
 
@@ -310,32 +310,49 @@ To that end, the module supports two concepts:
 ### Type Adapters
 This feature is meant to allow for simple Typescript types to be able to be backed by a proper class.  This is because all of the typescript type information disappears at runtime, and so only concrete types (like classes) remain.  An example of this, can be found with how the [Data Model Querying](https://github.com/travetto/travetto/tree/main/module/model-query#readme "Datastore abstraction for advanced query support.") module handles geo data.
 
-**Code: Simple Custom Type**
+**Code: Point Contract**
 ```typescript
-import { DataUtil } from '@travetto/schema';
-
 /**
- * @concrete #PointImpl
+ * Geometric Point as [number,number] with validation and binding support
+ *
+ * @concrete ./internal/types.ts#PointImpl
  */
 export type Point = [number, number];
+```
+
+**Code: Point Implementation**
+```typescript
+import { DataUtil } from '../data.ts';
 
-const INVALID = Symbol.for('invalid-point');
+const InvalidSymbol = Symbol();
 
+/**
+ * Point Implementation
+ */
 export class PointImpl {
+
+  /**
+   * Validate we have an actual point
+   */
   static validateSchema(input: unknown): 'type' | undefined {
-    const ret = this.bindSchema(input);
-    return ret !== INVALID && ret && !isNaN(ret[0]) && !isNaN(ret[1]) ? undefined : 'type';
+    const bound = this.bindSchema(input);
+    return bound !== InvalidSymbol && bound && !isNaN(bound[0]) && !isNaN(bound[1]) ? undefined : 'type';
   }
 
-  static bindSchema(input: unknown): [number, number] | typeof INVALID | undefined {
+  /**
+   * Convert to tuple of two numbers
+   */
+  static bindSchema(input: unknown): [number, number] | typeof InvalidSymbol | undefined {
     if (Array.isArray(input) && input.length === 2) {
       const [a, b] = input.map(x => DataUtil.coerceType(x, Number, false));
       return [a, b];
     } else {
-      return INVALID;
+      return InvalidSymbol;
     }
   }
 }
+
+Object.defineProperty(PointImpl, 'name', { value: 'Point' });
 ```
 
 What you can see here is that the `Point` type is now backed by a class that supports:
@@ -344,8 +361,7 @@ What you can see here is that the `Point` type is now backed by a class that sup
 
 **Code: Simple Custom Type Usage**
 ```typescript
-import { Schema } from '@travetto/schema';
-import { Point } from './custom-type';
+import { Schema, Point } from '@travetto/schema';
 
 @Schema()
 export class LocationAware {
@@ -369,8 +385,8 @@ Validation Failed {
     "errors": [
       {
         "kind": "type",
-        "type": "PointImpl",
-        "message": "point is not a valid PointImpl",
+        "type": "Point",
+        "message": "point is not a valid Point",
         "path": "point"
       }
     ]

package/__index__.ts

@@ -1,15 +1,16 @@
-import type { } from './src/global';
-export * from './src/decorator/field';
-export * from './src/decorator/schema';
-export * from './src/decorator/common';
-export * from './src/service/changes';
-export * from './src/service/registry';
-export * from './src/service/types';
-export * from './src/validate/messages';
-export * from './src/validate/regexp';
-export * from './src/validate/validator';
-export * from './src/validate/error';
-export * from './src/validate/types';
-export * from './src/bind-util';
-export * from './src/data';
-export * from './src/name';
+import type { } from './src/global.d.ts';
+export * from './src/decorator/field.ts';
+export * from './src/decorator/schema.ts';
+export * from './src/decorator/common.ts';
+export * from './src/service/changes.ts';
+export * from './src/service/registry.ts';
+export * from './src/service/types.ts';
+export * from './src/validate/messages.ts';
+export * from './src/validate/regexp.ts';
+export * from './src/validate/validator.ts';
+export * from './src/validate/error.ts';
+export * from './src/validate/types.ts';
+export * from './src/bind-util.ts';
+export * from './src/data.ts';
+export * from './src/name.ts';
+export * from './src/types.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/schema",
-  "version": "6.0.0-rc.1",
+  "version": "6.0.0-rc.2",
   "description": "Data type registry for runtime validation, reflection and binding.",
   "keywords": [
     "schema",
@@ -27,10 +27,10 @@
     "directory": "module/schema"
   },
   "dependencies": {
-    "@travetto/registry": "^6.0.0-rc.1"
+    "@travetto/registry": "^6.0.0-rc.2"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^6.0.0-rc.1"
+    "@travetto/transformer": "^6.0.0-rc.3"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/bind-util.ts

@@ -1,12 +1,11 @@
 import { castTo, Class, classConstruct, asFull, TypedObject, castKey } from '@travetto/runtime';
 
-import { DataUtil } from './data';
-import { AllViewSymbol } from './internal/types';
-import { SchemaRegistry } from './service/registry';
-import { FieldConfig } from './service/types';
+import { DataUtil } from './data.ts';
+import { SchemaRegistry } from './service/registry.ts';
+import { FieldConfig } from './service/types.ts';
 
 type BindConfig = {
-  view?: string | typeof AllViewSymbol;
+  view?: string;
   filterField?: (field: FieldConfig) => boolean;
   filterValue?: (value: unknown, field: FieldConfig) => boolean;
 };
@@ -169,7 +168,7 @@ export class BindUtil {
    * @param cfg The bind configuration
    */
   static bindSchemaToObject<T>(cons: Class<T>, obj: T, data?: object, cfg: BindConfig = {}): T {
-    const view = cfg.view ?? AllViewSymbol; // Does not convey
+    const view = cfg.view; // Does not convey
     delete cfg.view;
 
     if (!!data && isInstance<T>(data)) {
@@ -181,10 +180,12 @@ export class BindUtil {
           obj[k] = data[k];
         }
       } else {
-
-        const viewConf = conf.views[view];
-        if (!viewConf) {
-          throw new Error(`View not found: ${view.toString()}`);
+        let viewConf = conf.totalView;
+        if (view) {
+          viewConf = conf.views[view];
+          if (!viewConf) {
+            throw new Error(`View not found: ${view.toString()}`);
+          }
         }
 
         for (const schemaFieldName of viewConf.fields) {

package/src/data.ts

@@ -1,7 +1,7 @@
 import { isNumberObject as isNum, isBooleanObject as isBool, isStringObject as isStr } from 'node:util/types';
 
 import { asConstructable, castTo, Class, asFull, TypedObject } from '@travetto/runtime';
-import { UnknownType } from './internal/types';
+import { UnknownType } from './types.ts';
 
 const REGEX_PAT = /[\/](.*)[\/](i|g|m|s)?/;
 
@@ -49,26 +49,26 @@ export class DataUtil {
     const isSimpA = !isEmptyA && this.isSimpleValue(a);
     const isSimpB = !isEmptyB && this.isSimpleValue(b);
 
-    let ret: unknown;
+    let value: unknown;
 
     if (isEmptyA || isEmptyB) { // If no `a`, `b` always wins
       if (mode === 'replace' || b === null || !isEmptyB) {
-        ret = isEmptyB ? b : this.shallowClone(b);
+        value = isEmptyB ? b : this.shallowClone(b);
       } else if (!isEmptyA) {
-        ret = this.shallowClone(a);
+        value = this.shallowClone(a);
       } else {
-        ret = undefined;
+        value = undefined;
       }
     } else {
       if (isArrA !== isArrB || isSimpA !== isSimpB) {
         throw new Error(`Cannot merge differing types ${a} and ${b}`);
       }
       if (Array.isArray(b)) { // Arrays
-        ret = a; // Write onto A
+        value = a; // Write onto A
         if (mode === 'replace') {
-          ret = b;
+          value = b;
         } else {
-          const retArr: unknown[] = castTo(ret);
+          const retArr: unknown[] = castTo(value);
           const bArr = b;
           for (let i = 0; i < bArr.length; i++) {
             retArr[i] = this.#deepAssignRaw(retArr[i], bArr[i], mode);
@@ -76,19 +76,19 @@ export class DataUtil {
         }
       } else if (isSimpB) { // Scalars
         const match = typeof a === typeof b;
-        ret = b;
+        value = b;
 
         if (!match) { // If types do not match
           if (mode === 'strict') { // Bail on strict
             throw new Error(`Cannot merge ${a} [${typeof a}] with ${b} [${typeof b}]`);
           } else if (mode === 'coerce') { // Force on coerce
-            ret = this.coerceType(b, asConstructable(a).constructor, false);
+            value = this.coerceType(b, asConstructable(a).constructor, false);
           }
         }
       } else { // Object merge
-        ret = a;
+        value = a;
         const bObj: Record<string, unknown> = castTo(b);
-        const retObj: Record<string, unknown> = castTo(ret);
+        const retObj: Record<string, unknown> = castTo(value);
 
         for (const key of Object.keys(bObj)) {
           if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
@@ -98,7 +98,7 @@ export class DataUtil {
         }
       }
     }
-    return ret;
+    return value;
   }
 
   /**
@@ -142,11 +142,11 @@ export class DataUtil {
 
     switch (type) {
       case Date: {
-        let res: Date | undefined;
+        let value: Date | undefined;
         if (typeof input === 'object' && 'toDate' in input && typeof input.toDate === 'function') {
-          res = castTo(input.toDate());
+          value = castTo(input.toDate());
         } else {
-          res = input instanceof Date ?
+          value = input instanceof Date ?
             input :
             typeof input === 'number' ?
               new Date(input) :
@@ -154,17 +154,17 @@ export class DataUtil {
                 new Date(parseInt(input, 10)) :
                 new Date(input.toString());
         }
-        if (strict && res && Number.isNaN(res.getTime())) {
+        if (strict && value && Number.isNaN(value.getTime())) {
           throw new Error(`Invalid date value: ${input}`);
         }
-        return res;
+        return value;
       }
       case Number: {
-        const res = `${input}`.includes('.') ? parseFloat(`${input}`) : parseInt(`${input}`, 10);
-        if (strict && Number.isNaN(res)) {
+        const value = `${input}`.includes('.') ? parseFloat(`${input}`) : parseInt(`${input}`, 10);
+        if (strict && Number.isNaN(value)) {
           throw new Error(`Invalid numeric value: ${input}`);
         }
-        return res;
+        return value;
       }
       case BigInt: {
         if (typeof input === 'bigint') {
@@ -252,7 +252,9 @@ export class DataUtil {
    * @returns
    */
   static filterByKeys<T>(obj: T, exclude: (string | RegExp)[]): T {
-    if (obj !== null && obj !== undefined && typeof obj === 'object') {
+    if (Array.isArray(obj)) {
+      return castTo(obj.map(x => this.filterByKeys(x, exclude)));
+    } else if (obj !== null && obj !== undefined && typeof obj === 'object') {
       const out: Partial<T> = {};
       for (const key of TypedObject.keys(obj)) {
         if (!exclude.some(r => typeof key === 'string' && (typeof r === 'string' ? r === key : r.test(key)))) {

package/src/decorator/common.ts

@@ -1,7 +1,7 @@
 import { Class, ClassInstance } from '@travetto/runtime';
 
-import { DescribableConfig } from '../service/types';
-import { SchemaRegistry } from '../service/registry';
+import { DescribableConfig } from '../service/types.ts';
+import { SchemaRegistry } from '../service/registry.ts';
 
 function isClassInstance(o: Class | ClassInstance, property?: string): o is ClassInstance {
   return !!property;

package/src/decorator/field.ts

@@ -1,8 +1,8 @@
 import { Any, ClassInstance } from '@travetto/runtime';
 
-import { SchemaRegistry } from '../service/registry';
-import { CommonRegExp } from '../validate/regexp';
-import { ClassList, FieldConfig } from '../service/types';
+import { SchemaRegistry } from '../service/registry.ts';
+import { CommonRegExp } from '../validate/regexp.ts';
+import { ClassList, FieldConfig } from '../service/types.ts';
 
 type PropType<V> = (<T extends Partial<Record<K, V | Function>>, K extends string>(t: T, k: K, idx?: TypedPropertyDescriptor<Any> | number) => void);
 
@@ -40,16 +40,14 @@ export function Field(type: ClassList, ...config: Partial<FieldConfig>[]) {
 export function Alias(...aliases: string[]): PropType<unknown> { return prop({ aliases }); }
 /**
  * Mark a field as writeonly
- * @param active This determines if this field is readonly or not.
  * @augments `@travetto/schema:Field`
  */
-export function Writeonly(active = true): PropType<unknown> { return prop({ access: 'writeonly' }); }
+export function Writeonly(): PropType<unknown> { return prop({ access: 'writeonly' }); }
 /**
  * Mark a field as readonly
- * @param active This determines if this field is readonly or not.
  * @augments `@travetto/schema:Field`
  */
-export function Readonly(active = true): PropType<unknown> { return prop({ access: 'readonly' }); }
+export function Readonly(): PropType<unknown> { return prop({ access: 'readonly' }); }
 /**
  * Mark a field as sensitive
  * @param active This determines if this field is sensitive or not.
@@ -189,7 +187,7 @@ export function Currency(): PropType<number> { return Precision(13, 2); }
  * @augments `@travetto/schema:Ignore`
  */
 export function Ignore(): PropertyDecorator {
-  return (target: Object, property: string | symbol) => { };
+  return () => { };
 }
 
 /**

package/src/decorator/schema.ts

@@ -1,14 +1,13 @@
 import { Any, castTo, Class, ClassInstance, DeepPartial } from '@travetto/runtime';
 
-import { BindUtil } from '../bind-util';
-import { SchemaRegistry } from '../service/registry';
-import { ClassConfig, ViewFieldsConfig } from '../service/types';
-import { MethodValidatorFn, ValidatorFn } from '../validate/types';
+import { BindUtil } from '../bind-util.ts';
+import { SchemaRegistry } from '../service/registry.ts';
+import { ClassConfig, ViewFieldsConfig } from '../service/types.ts';
+import { MethodValidatorFn, ValidatorFn } from '../validate/types.ts';
 
 /**
  * Register a class as a Schema
  *
- *
  * @augments `@travetto/schema:Schema`
  */
 export function Schema(cfg?: Partial<Pick<ClassConfig, 'subTypeName' | 'subTypeField' | 'baseType'>>) { // Auto is used during compilation
@@ -27,7 +26,7 @@ export function Schema(cfg?: Partial<Pick<ClassConfig, 'subTypeName' | 'subTypeF
  * @param fn The validator function
  */
 export const Validator = <T>(fn: ValidatorFn<T, string>) =>
-  (target: Class<T>, k?: string): void => {
+  (target: Class<T>, _k?: string): void => {
     SchemaRegistry.getOrCreatePending(target).validators!.push(castTo(fn));
   };
 
@@ -37,7 +36,7 @@ export const Validator = <T>(fn: ValidatorFn<T, string>) =>
  * @param fn The validator function
  */
 export function MethodValidator<T extends (...args: Any[]) => Any>(fn: MethodValidatorFn<Parameters<T>>) {
-  return (target: ClassInstance, k: string, prop: TypedPropertyDescriptor<T>): void => {
+  return (target: ClassInstance, k: string, _prop: TypedPropertyDescriptor<T>): void => {
     SchemaRegistry.registerPendingMethod(target.constructor, k).validators!.push(castTo(fn));
   };
 }

package/src/internal/types.ts

@@ -1,2 +1,31 @@
-export const AllViewSymbol: unique symbol = Symbol.for('@travetto/schema:all');
-export class UnknownType { }
+import { DataUtil } from '../data.ts';
+
+const InvalidSymbol = Symbol();
+
+/**
+ * Point Implementation
+ */
+export class PointImpl {
+
+  /**
+   * Validate we have an actual point
+   */
+  static validateSchema(input: unknown): 'type' | undefined {
+    const bound = this.bindSchema(input);
+    return bound !== InvalidSymbol && bound && !isNaN(bound[0]) && !isNaN(bound[1]) ? undefined : 'type';
+  }
+
+  /**
+   * Convert to tuple of two numbers
+   */
+  static bindSchema(input: unknown): [number, number] | typeof InvalidSymbol | undefined {
+    if (Array.isArray(input) && input.length === 2) {
+      const [a, b] = input.map(x => DataUtil.coerceType(x, Number, false));
+      return [a, b];
+    } else {
+      return InvalidSymbol;
+    }
+  }
+}
+
+Object.defineProperty(PointImpl, 'name', { value: 'Point' });

package/src/name.ts

@@ -1,4 +1,4 @@
-import { ClassConfig } from './service/types';
+import { ClassConfig } from './service/types.ts';
 
 const ID_RE = /(\d{1,100})Δ$/;
 

package/src/service/changes.ts

@@ -3,8 +3,7 @@ import { EventEmitter } from 'node:events';
 import { Class } from '@travetto/runtime';
 import { ChangeEvent } from '@travetto/registry';
 
-import { FieldConfig, ClassConfig } from './types';
-import { AllViewSymbol } from '../internal/types';
+import { FieldConfig, ClassConfig } from './types.ts';
 
 const id = (c: Class | string): string => typeof c === 'string' ? c : c.Ⲑid;
 
@@ -111,8 +110,8 @@ class $SchemaChangeListener {
    */
   emitFieldChanges({ prev, curr }: ChangeEvent<ClassConfig>): void {
 
-    const prevView = prev?.views[AllViewSymbol] || { fields: [], schema: {} };
-    const currView = curr!.views[AllViewSymbol];
+    const prevView = prev?.totalView || { fields: [], schema: {} };
+    const currView = curr!.totalView;
 
     const prevFields = new Set(prevView.fields);
     const currFields = new Set(currView.fields);

package/src/service/registry.ts

@@ -1,10 +1,9 @@
 import { Class, AppError, describeFunction, castTo, classConstruct, asFull, castKey } from '@travetto/runtime';
 import { MetadataRegistry, RootRegistry, ChangeEvent } from '@travetto/registry';
 
-import { ClassList, FieldConfig, ClassConfig, SchemaConfig, ViewFieldsConfig, ViewConfig, SchemaMethodConfig } from './types';
-import { SchemaChangeListener } from './changes';
-import { AllViewSymbol } from '../internal/types';
-import { MethodValidatorFn } from '../validate/types';
+import { ClassList, FieldConfig, ClassConfig, SchemaConfig, ViewFieldsConfig, ViewConfig, SchemaMethodConfig } from './types.ts';
+import { SchemaChangeListener } from './changes.ts';
+import { MethodValidatorFn } from '../validate/types.ts';
 
 const classToSubTypeName = (cls: Class): string => cls.name
   .replace(/([A-Z])([A-Z][a-z])/g, (all, l, r) => `${l}_${r.toLowerCase()}`)
@@ -73,7 +72,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
   ensureInstanceTypeField<T>(cls: Class, o: T): void {
     const schema = this.get(cls);
     const typeField = castKey<T>(schema.subTypeField);
-    if (schema.subTypeName && typeField in schema.views[AllViewSymbol].schema && !o[typeField]) {  // Do we have a type field defined
+    if (schema.subTypeName && typeField in schema.totalView.schema && !o[typeField]) {  // Do we have a type field defined
       o[typeField] = castTo(schema.subTypeName); // Assign if missing
     }
   }
@@ -110,11 +109,11 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
 
     if (clsSchema.subTypeName || baseSchema.baseType) { // We have a sub type
       const type = castTo<string>(o[castKey<T>(baseSchema.subTypeField)]) ?? clsSchema.subTypeName ?? baseSchema.subTypeName;
-      const ret = this.#subTypes.get(base)!.get(type)!;
-      if (ret && !(classConstruct(ret) instanceof cls)) {
-        throw new AppError(`Resolved class ${ret.name} is not assignable to ${cls.name}`);
+      const subType = this.#subTypes.get(base)!.get(type)!;
+      if (subType && !(classConstruct(subType) instanceof cls)) {
+        throw new AppError(`Resolved class ${subType.name} is not assignable to ${cls.name}`);
       }
-      return ret;
+      return subType;
     } else {
       return cls;
     }
@@ -169,7 +168,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     SchemaChangeListener.trackSchemaDependency(curr, cls, path, this.get(cls));
 
     // Read children
-    const view = config.views[AllViewSymbol];
+    const view = config.totalView;
     for (const k of view.fields) {
       if (this.has(view.schema[k].type) && view.schema[k].type !== cls) {
         this.trackSchemaDependencies(cls, view.schema[k].type, [...path, view.schema[k]]);
@@ -185,12 +184,11 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       baseType: describeFunction(cls)?.abstract,
       metadata: {},
       methods: {},
-      views: {
-        [AllViewSymbol]: {
-          schema: {},
-          fields: []
-        }
-      }
+      totalView: {
+        schema: {},
+        fields: [],
+      },
+      views: {}
     };
   }
 
@@ -199,16 +197,17 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param cls The class to retrieve the schema for
    * @param view The view name
    */
-  getViewSchema<T>(cls: Class<T>, view?: string | typeof AllViewSymbol): ViewConfig {
-    view = view ?? AllViewSymbol;
-
+  getViewSchema<T>(cls: Class<T>, view?: string): ViewConfig {
     const schema = this.get(cls)!;
     if (!schema) {
       throw new Error(`Unknown schema class ${cls.name}`);
     }
-    const res = schema.views[view];
-    if (!res) {
-      throw new Error(`Unknown view ${view.toString()} for ${cls.name}`);
+    let res = schema.totalView;
+    if (view) {
+      res = schema.views[view];
+      if (!res) {
+        throw new Error(`Unknown view ${view.toString()} for ${cls.name}`);
+      }
     }
     return res;
   }
@@ -219,7 +218,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param method
    */
   getMethodSchema<T>(cls: Class<T>, method: string): FieldConfig[] {
-    return (this.get(cls)?.methods?.[method] ?? {}).fields?.filter(x => !!x).sort((a, b) => a.index! - b.index!) ?? [];
+    return (this.get(cls)?.methods?.[method] ?? {}).fields?.filter(x => !!x).toSorted((a, b) => a.index! - b.index!) ?? [];
   }
 
   /**
@@ -275,7 +274,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       config.specifiers = [...params[idx]?.specifiers ?? [], ...config.specifiers];
     }
     if (config.enum?.values) {
-      config.enum.values = config.enum.values.slice().sort();
+      config.enum.values = config.enum.values.toSorted();
     }
 
     params[idx] = {
@@ -296,24 +295,28 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param config The config to register
    */
   registerPendingFieldFacet(target: Class, prop: string, config: Partial<FieldConfig>): Class {
-    const allViewConf = this.getOrCreatePending(target).views![AllViewSymbol];
+    if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') {
+      throw new AppError('Invalid property name');
+    }
+
+    const totalViewConf = this.getOrCreatePending(target).totalView!;
 
-    if (!allViewConf.schema[prop]) {
-      allViewConf.fields.push(prop);
+    if (!totalViewConf.schema[prop]) {
+      totalViewConf.fields.push(prop);
       // Partial config while building
-      allViewConf.schema[prop] = asFull<FieldConfig>({});
+      totalViewConf.schema[prop] = asFull<FieldConfig>({});
     }
     if (config.aliases) {
-      config.aliases = [...allViewConf.schema[prop].aliases ?? [], ...config.aliases];
+      config.aliases = [...totalViewConf.schema[prop].aliases ?? [], ...config.aliases];
     }
     if (config.specifiers) {
-      config.specifiers = [...allViewConf.schema[prop].specifiers ?? [], ...config.specifiers];
+      config.specifiers = [...totalViewConf.schema[prop].specifiers ?? [], ...config.specifiers];
     }
     if (config.enum?.values) {
-      config.enum.values = config.enum.values.slice().sort();
+      config.enum.values = config.enum.values.toSorted();
     }
 
-    Object.assign(allViewConf.schema[prop], config);
+    Object.assign(totalViewConf.schema[prop], config);
 
     return target;
   }
@@ -359,9 +362,9 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param src Source config
    */
   mergeConfigs(dest: ClassConfig, src: Partial<ClassConfig>, inherited = false): ClassConfig {
-    dest.views[AllViewSymbol] = {
-      schema: { ...dest.views[AllViewSymbol].schema, ...src.views?.[AllViewSymbol].schema },
-      fields: [...dest.views[AllViewSymbol].fields, ...src.views?.[AllViewSymbol].fields ?? []]
+    dest.totalView = {
+      schema: { ...dest.totalView.schema, ...src.totalView?.schema },
+      fields: [...dest.totalView.fields, ...src.totalView?.fields ?? []]
     };
     if (!inherited) {
       dest.baseType = src.baseType ?? dest.baseType;
@@ -381,20 +384,20 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param conf The class config
    */
   finalizeViews<T>(target: Class<T>, conf: ClassConfig): ClassConfig {
-    const allViewConf = conf.views![AllViewSymbol];
+    const totalViewConf = conf.totalView;
     const pending = this.#pendingViews.get(target) ?? new Map<string, ViewFieldsConfig<string>>();
     this.#pendingViews.delete(target);
 
     for (const [view, fields] of pending.entries()) {
       const withoutSet = 'without' in fields ? new Set<string>(fields.without) : undefined;
       const fieldList = withoutSet ?
-        allViewConf.fields.filter(x => !withoutSet.has(x)) :
+        totalViewConf.fields.filter(x => !withoutSet.has(x)) :
         ('with' in fields ? fields.with : []);
 
       conf.views![view] = {
         fields: fieldList,
         schema: fieldList.reduce<SchemaConfig>((acc, v) => {
-          acc[v] = allViewConf.schema[v];
+          acc[v] = totalViewConf.schema[v];
           return acc;
         }, {})
       };
@@ -427,9 +430,9 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     // Write views out
     config = this.finalizeViews(cls, config);
 
-    if (config.subTypeName && config.subTypeField in config.views[AllViewSymbol].schema) {
-      const field = config.views[AllViewSymbol].schema[config.subTypeField];
-      config.views[AllViewSymbol].schema[config.subTypeField] = {
+    if (config.subTypeName && config.subTypeField in config.totalView.schema) {
+      const field = config.totalView.schema[config.subTypeField];
+      config.totalView.schema[config.subTypeField] = {
         ...field,
         enum: {
           values: [config.subTypeName],

package/src/service/types.ts

@@ -1,7 +1,6 @@
 import { Any, Class, Primitive } from '@travetto/runtime';
 
-import { AllViewSymbol } from '../internal/types';
-import { MethodValidatorFn, ValidatorFn } from '../validate/types';
+import { MethodValidatorFn, ValidatorFn } from '../validate/types.ts';
 
 export type ClassList = Class | [Class];
 
@@ -69,7 +68,11 @@ export interface ClassConfig extends DescribableConfig {
   /**
    * List of all views
    */
-  views: Record<string, ViewConfig> & { [AllViewSymbol]: ViewConfig };
+  views: Record<string, ViewConfig>;
+  /**
+   * Composite of all views
+   */
+  totalView: ViewConfig;
   /**
    * Global validators
    */

package/src/types.ts

@@ -0,0 +1,8 @@
+export class UnknownType { }
+
+/**
+ * Geometric Point as [number,number] with validation and binding support
+ *
+ * @concrete ./internal/types.ts#PointImpl
+ */
+export type Point = [number, number];

package/src/validate/error.ts

@@ -1,5 +1,5 @@
 import { Class, AppError } from '@travetto/runtime';
-import { ValidationError } from './types';
+import { ValidationError } from './types.ts';
 
 /**
  * Validation results error.

package/src/validate/regexp.ts

@@ -1,5 +1,5 @@
 import { TypedObject } from '@travetto/runtime';
-import { Messages } from './messages';
+import { Messages } from './messages.ts';
 
 /**
  * List of common regular expressions for fields

package/src/validate/types.ts

@@ -3,6 +3,7 @@ export type ValidationKind = ValidationKindCore | string;
 
 /**
  * Individual Validation Error
+ * @concrete
  */
 export interface ValidationError {
   /**

package/src/validate/validator.ts

@@ -1,12 +1,12 @@
 import { castKey, castTo, Class, ClassInstance, TypedObject } from '@travetto/runtime';
 
-import { FieldConfig, SchemaConfig } from '../service/types';
-import { SchemaRegistry } from '../service/registry';
-import { ValidationError, ValidationKindCore, ValidationResult } from './types';
-import { Messages } from './messages';
-import { isValidationError, TypeMismatchError, ValidationResultError } from './error';
-import { DataUtil } from '../data';
-import { CommonRegExpToName } from './regexp';
+import { FieldConfig, SchemaConfig } from '../service/types.ts';
+import { SchemaRegistry } from '../service/registry.ts';
+import { ValidationError, ValidationKindCore, ValidationResult } from './types.ts';
+import { Messages } from './messages.ts';
+import { isValidationError, TypeMismatchError, ValidationResultError } from './error.ts';
+import { DataUtil } from '../data.ts';
+import { CommonRegExpToName } from './regexp.ts';
 
 /**
  * Get the schema config for Class/Schema config, including support for polymorphism
@@ -184,22 +184,22 @@ export class SchemaValidator {
    */
   static #prepareErrors(path: string, results: ValidationResult[]): ValidationError[] {
     const out: ValidationError[] = [];
-    for (const res of results) {
+    for (const result of results) {
       const err: ValidationError = {
-        ...res,
-        kind: res.kind,
-        value: res.value,
+        ...result,
+        kind: result.kind,
+        value: result.value,
         message: '',
-        re: CommonRegExpToName.get(res.re!) ?? res.re?.source ?? '',
+        re: CommonRegExpToName.get(result.re!) ?? result.re?.source ?? '',
         path,
-        type: (typeof res.type === 'function' ? res.type.name : res.type)
+        type: (typeof result.type === 'function' ? result.type.name : result.type)
       };
 
       if (!err.re) {
         delete err.re;
       }
 
-      const msg = res.message ?? (
+      const msg = result.message ?? (
         Messages.get(err.re ?? '') ??
         Messages.get(err.kind) ??
         Messages.get('default')!

package/support/transformer/util.ts

@@ -4,13 +4,13 @@ import {
   DecoratorUtil, DocUtil, ParamDocumentation, TransformerState, transformCast,
 } from '@travetto/transformer';
 
-const SCHEMA_MOD = '@travetto/schema/src/decorator/schema';
-const FIELD_MOD = '@travetto/schema/src/decorator/field';
-const COMMON_MOD = '@travetto/schema/src/decorator/common';
-const TYPES_FILE = '@travetto/schema/src/internal/types';
-
 export class SchemaTransformUtil {
 
+  static SCHEMA_IMPORT = '@travetto/schema/src/decorator/schema.ts';
+  static FIELD_IMPORT = '@travetto/schema/src/decorator/field.ts';
+  static COMMON_IMPORT = '@travetto/schema/src/decorator/common.ts';
+  static TYPES_IMPORT = '@travetto/schema/src/types.ts';
+
   /**
    * Produce concrete type given transformer type
    */
@@ -29,7 +29,7 @@ export class SchemaTransformUtil {
         break;
       }
       case 'unknown': {
-        const imp = state.importFile(TYPES_FILE);
+        const imp = state.importFile(this.TYPES_IMPORT);
         return state.createAccess(imp.ident, 'UnknownType');
       }
       case 'shape': {
@@ -40,8 +40,8 @@ export class SchemaTransformUtil {
         if (!existing) {
           const cls = state.factory.createClassDeclaration(
             [
-              state.createDecorator(SCHEMA_MOD, 'Schema'),
-              state.createDecorator(COMMON_MOD, 'Describe',
+              state.createDecorator(this.SCHEMA_IMPORT, 'Schema'),
+              state.createDecorator(this.COMMON_IMPORT, 'Describe',
                 state.fromLiteral({
                   title: type.name,
                   description: type.comment
@@ -163,7 +163,7 @@ export class SchemaTransformUtil {
 
     const params: ts.Expression[] = [];
 
-    const existing = state.findDecorator('@travetto/schema', node, 'Field', FIELD_MOD);
+    const existing = state.findDecorator('@travetto/schema', node, 'Field', this.FIELD_IMPORT);
     if (!existing) {
       const resolved = this.toConcreteType(state, typeExpr, node, config.root);
       params.push(resolved);
@@ -183,31 +183,31 @@ export class SchemaTransformUtil {
 
     const newModifiers = [
       ...(node.modifiers ?? []).filter(x => x !== existing),
-      state.createDecorator(FIELD_MOD, 'Field', ...params)
+      state.createDecorator(this.FIELD_IMPORT, 'Field', ...params)
     ];
 
-    let ret: unknown;
+    let result: unknown;
     if (ts.isPropertyDeclaration(node)) {
       const comments = DocUtil.describeDocs(node);
       if (comments.description) {
-        newModifiers.push(state.createDecorator(COMMON_MOD, 'Describe', state.fromLiteral({
+        newModifiers.push(state.createDecorator(this.COMMON_IMPORT, 'Describe', state.fromLiteral({
           description: comments.description
         })));
       }
 
-      ret = state.factory.updatePropertyDeclaration(node,
+      result = state.factory.updatePropertyDeclaration(node,
         newModifiers, node.name, node.questionToken, node.type, node.initializer);
     } else if (ts.isParameter(node)) {
-      ret = state.factory.updateParameterDeclaration(node,
+      result = state.factory.updateParameterDeclaration(node,
         newModifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
     } else if (ts.isGetAccessorDeclaration(node)) {
-      ret = state.factory.updateGetAccessorDeclaration(node,
+      result = state.factory.updateGetAccessorDeclaration(node,
         newModifiers, node.name, node.parameters, node.type, node.body);
     } else {
-      ret = state.factory.updateSetAccessorDeclaration(node,
+      result = state.factory.updateSetAccessorDeclaration(node,
         newModifiers, node.name, node.parameters, node.body);
     }
-    return transformCast(ret);
+    return transformCast(result);
   }
 
   /**

package/support/transformer.schema.ts

@@ -1,22 +1,19 @@
 import ts from 'typescript';
 
 import {
-  TransformerState, OnProperty, OnClass, AfterClass, DecoratorMeta, DocUtil, DeclarationUtil, OnGetter, OnSetter
+  TransformerState, OnProperty, OnClass, AfterClass, DocUtil, DeclarationUtil, OnGetter, OnSetter
 } from '@travetto/transformer';
 
-import { SchemaTransformUtil } from './transformer/util';
+import { SchemaTransformUtil } from './transformer/util.ts';
 
-const inSchema = Symbol.for('@travetto/schema:schema');
-const accessors = Symbol.for('@travetto/schema:accessors');
+const InSchemaSymbol = Symbol();
+const AccessorsSymbol = Symbol();
 
 interface AutoState {
-  [inSchema]?: boolean;
-  [accessors]?: Set<string>;
+  [InSchemaSymbol]?: boolean;
+  [AccessorsSymbol]?: Set<string>;
 }
 
-const SCHEMA_IMPORT = '@travetto/schema/src/decorator/schema';
-const COMMON_IMPORT = '@travetto/schema/src/decorator/common';
-
 /**
  * Processes `@Schema` to register class as a valid Schema
  */
@@ -26,9 +23,9 @@ export class SchemaTransformer {
    * Track schema on start
    */
   @OnClass('Schema')
-  static startSchema(state: AutoState & TransformerState, node: ts.ClassDeclaration, dec?: DecoratorMeta): ts.ClassDeclaration {
-    state[inSchema] = true;
-    state[accessors] = new Set();
+  static startSchema(state: AutoState & TransformerState, node: ts.ClassDeclaration): ts.ClassDeclaration {
+    state[InSchemaSymbol] = true;
+    state[AccessorsSymbol] = new Set();
     return node;
   }
 
@@ -41,18 +38,18 @@ export class SchemaTransformer {
 
     const comments = DocUtil.describeDocs(node);
 
-    if (!state.findDecorator(this, node, 'Schema', SCHEMA_IMPORT)) {
-      modifiers.unshift(state.createDecorator(SCHEMA_IMPORT, 'Schema'));
+    if (!state.findDecorator(this, node, 'Schema', SchemaTransformUtil.SCHEMA_IMPORT)) {
+      modifiers.unshift(state.createDecorator(SchemaTransformUtil.SCHEMA_IMPORT, 'Schema'));
     }
 
     if (comments.description) {
-      modifiers.push(state.createDecorator(COMMON_IMPORT, 'Describe', state.fromLiteral({
+      modifiers.push(state.createDecorator(SchemaTransformUtil.COMMON_IMPORT, 'Describe', state.fromLiteral({
         title: comments.description
       })));
     }
 
-    delete state[inSchema];
-    delete state[accessors];
+    delete state[InSchemaSymbol];
+    delete state[AccessorsSymbol];
 
     return state.factory.updateClassDeclaration(
       node,
@@ -70,7 +67,7 @@ export class SchemaTransformer {
   @OnProperty()
   static processSchemaField(state: TransformerState & AutoState, node: ts.PropertyDeclaration): ts.PropertyDeclaration {
     const ignore = state.findDecorator(this, node, 'Ignore');
-    return state[inSchema] && !ignore && DeclarationUtil.isPublic(node) ?
+    return state[InSchemaSymbol] && !ignore && DeclarationUtil.isPublic(node) ?
       SchemaTransformUtil.computeField(state, node) : node;
   }
 
@@ -80,8 +77,8 @@ export class SchemaTransformer {
   @OnGetter()
   static processSchemaGetter(state: TransformerState & AutoState, node: ts.GetAccessorDeclaration): ts.GetAccessorDeclaration {
     const ignore = state.findDecorator(this, node, 'Ignore');
-    if (state[inSchema] && !ignore && DeclarationUtil.isPublic(node) && !state[accessors]?.has(node.name.getText())) {
-      state[accessors]?.add(node.name.getText());
+    if (state[InSchemaSymbol] && !ignore && DeclarationUtil.isPublic(node) && !state[AccessorsSymbol]?.has(node.name.getText())) {
+      state[AccessorsSymbol]?.add(node.name.getText());
       return SchemaTransformUtil.computeField(state, node);
     }
     return node;
@@ -93,8 +90,8 @@ export class SchemaTransformer {
   @OnSetter()
   static processSchemaSetter(state: TransformerState & AutoState, node: ts.SetAccessorDeclaration): ts.SetAccessorDeclaration {
     const ignore = state.findDecorator(this, node, 'Ignore');
-    if (state[inSchema] && !ignore && DeclarationUtil.isPublic(node) && !state[accessors]?.has(node.name.getText())) {
-      state[accessors]?.add(node.name.getText());
+    if (state[InSchemaSymbol] && !ignore && DeclarationUtil.isPublic(node) && !state[AccessorsSymbol]?.has(node.name.getText())) {
+      state[AccessorsSymbol]?.add(node.name.getText());
       return SchemaTransformUtil.computeField(state, node);
     }
     return node;