@travetto/schema 3.0.0-rc.4 → 3.0.0-rc.7

package/README.md

@@ -1,7 +1,7 @@
 <!-- This file was generated by @travetto/doc and should not be modified directly -->
-<!-- Please modify https://github.com/travetto/travetto/tree/main/module/schema/doc.ts and execute "npx trv doc" to rebuild -->
+<!-- Please modify https://github.com/travetto/travetto/tree/main/module/schema/DOC.ts and execute "npx trv doc" to rebuild -->
 # Schema
-## Data type registry for runtime validation, reflection and binding. 
+## Data type registry for runtime validation, reflection and binding.
 
 **Install: @travetto/schema**
 ```bash
@@ -9,13 +9,13 @@ npm install @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 "Environment-aware config management using yaml files"), [Application](https://github.com/travetto/travetto/tree/main/module/app#readme "Application registration/management and run support."), [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
+leveraged in the [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support"), [Application](https://github.com/travetto/travetto/tree/main/module/app#readme "Application registration/management and run support."), [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 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#L12) 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#L14) 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:
@@ -65,22 +65,22 @@ This schema provides a powerful base for data binding and validation at runtime.
 
    
    *  [@Field](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L38) defines a field that will be serialized.
-   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L72) defines a that field should be required
-   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L79) defines the allowable values that a field can have
-   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L100) defines a regular expression that the field value should match
-   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L108) enforces min length of a string
-   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L118) enforces max length of a string
-   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L108) enforces min value for a date or a number
-   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L118) enforces max value for a date or a number
-   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L145) ensures string field matches basic email regex
-   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L152) ensures string field matches basic telephone regex
-   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L159) ensures string field matches basic url regex
-   *  [@Ignore](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L198) exclude from auto schema registration
-   *  [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L173) ensures number passed in is only a whole number
-   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L179) ensures number passed in allows fractional values
-   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L191) provides support for standard currency
-   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L87) 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#L92) same as text, but expects longer form content
+   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L78) defines a that field should be required
+   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L85) defines the allowable values that a field can have
+   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L106) defines a regular expression that the field value should match
+   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L114) enforces min length of a string
+   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L124) enforces max length of a string
+   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L114) enforces min value for a date or a number
+   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L124) enforces max value for a date or a number
+   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L151) ensures string field matches basic email regex
+   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L158) ensures string field matches basic telephone regex
+   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L165) ensures string field matches basic url regex
+   *  [@Ignore](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L204) exclude from auto schema registration
+   *  [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L179) ensures number passed in is only a whole number
+   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L185) ensures number passed in allows fractional values
+   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L197) provides support for standard currency
+   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L93) 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#L98) same as text, but expects longer form content
    *  [@Readonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L65) 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#L59) defines a that field should not be exported in serialization, but that it can be bound to
 
@@ -98,7 +98,7 @@ And similarly, the `description` will be picked up from the [JSDoc](http://usejs
 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#L12) 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#L14) and a JS object that will be the source of the binding. Given the schema:
 
 **Code: Sub Schemas via Address**
 ```typescript
@@ -140,13 +140,14 @@ and the output would be a `Person` instance with the following structure
 
 **Terminal: Sample data output after binding**
 ```bash
-$ node @travetto/base/bin/main ./doc/person-output.ts 
+$ trv main support/main.person-output.ts
 
 Person {
   name: 'Test',
   age: 19,
   address: Address { street1: '1234 Fun', street2: 'Unit 20' }
 }
+
 ```
 
 **Note**: Binding will attempt to convert/coerce types as much as possible to honor the pattern of Javascript and it's dynamic nature.
@@ -200,27 +201,9 @@ would produce an exception similar to following structure
 
 **Terminal: Sample error output**
 ```bash
-$ node @travetto/base/bin/main ./doc/person-invalid-output.ts 
-
-Validation Failed {
-  "message": "Validation errors have occurred",
-  "category": "data",
-  "type": "ValidationResultError",
-  "at": "2022-03-14T04:00:00.618Z",
-  "errors": [
-    {
-      "kind": "type",
-      "message": "age is not a valid number",
-      "path": "age",
-      "type": "number"
-    },
-    {
-      "kind": "required",
-      "message": "address.street2 is required",
-      "path": "address.street2"
-    }
-  ]
-}
+$ trv main support/main.person-invalid-output.ts
+
+
 ```
 
 ### Custom Validators
@@ -294,7 +277,7 @@ This feature is meant to allow for simple Typescript types to be able to be back
 
 **Code: Simple Custom Type**
 ```typescript
-import { Util } from '@travetto/base';
+import { DataUtil } from '@travetto/base';
 
 /**
  * @concrete .:PointImpl
@@ -311,7 +294,7 @@ export class PointImpl {
 
   static bindSchema(input: unknown): [number, number] | typeof INVALID | undefined {
     if (Array.isArray(input) && input.length === 2) {
-      return input.map(x => Util.coerceType(x, Number, false)) as [number, number];
+      return input.map(x => DataUtil.coerceType(x, Number, false)) as [number, number];
     } else {
       return INVALID;
     }
@@ -341,21 +324,7 @@ All that happens now, is the type is exported, and the class above is able to pr
 
 **Terminal: Custom Type Validation**
 ```bash
-$ node @travetto/base/bin/main ./doc/custom-type-output.ts 
-
-Validation Failed {
-  "message": "Validation errors have occurred",
-  "category": "data",
-  "type": "ValidationResultError",
-  "at": "2022-03-14T04:00:00.837Z",
-  "errors": [
-    {
-      "kind": "type",
-      "message": "point is not a valid PointImpl",
-      "path": "point",
-      "type": "PointImpl"
-    }
-  ]
-}
+$ trv main support/main.custom-type-output.ts
+
+
 ```
-;

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@travetto/schema",
-  "displayName": "Schema",
-  "version": "3.0.0-rc.4",
-  "description": "Data type registry for runtime validation, reflection and binding. ",
+  "version": "3.0.0-rc.7",
+  "description": "Data type registry for runtime validation, reflection and binding.",
   "keywords": [
     "schema",
     "ast-transformations",
@@ -18,18 +17,28 @@
     "name": "Travetto Framework"
   },
   "files": [
-    "index.ts",
+    "__index__.ts",
     "src",
     "support"
   ],
-  "main": "index.ts",
+  "main": "__index__.ts",
   "repository": {
     "url": "https://github.com/travetto/travetto.git",
     "directory": "module/schema"
   },
   "dependencies": {
-    "@travetto/registry": "^3.0.0-rc.4",
-    "@travetto/transformer": "^3.0.0-rc.4"
+    "@travetto/registry": "^3.0.0-rc.7"
+  },
+  "peerDependencies": {
+    "@travetto/transformer": "^3.0.0-rc.7"
+  },
+  "peerDependenciesMeta": {
+    "@travetto/transformer": {
+      "optional": true
+    }
+  },
+  "travetto": {
+    "displayName": "Schema"
   },
   "publishConfig": {
     "access": "public"

package/src/bind-util.ts

@@ -1,9 +1,15 @@
-import { Class, ClassInstance, ConcreteClass, Util } from '@travetto/base';
+import { Class, ConcreteClass, TypedObject, ObjectUtil, DataUtil } from '@travetto/base';
 
 import { AllViewⲐ } from './internal/types';
 import { SchemaRegistry } from './service/registry';
 import { FieldConfig } from './service/types';
 
+type BindConfig = {
+  view?: string | typeof AllViewⲐ;
+  filterField?: (field: FieldConfig) => boolean;
+  filterValue?: (value: unknown, field: FieldConfig) => boolean;
+};
+
 /**
  * Utilities for binding objects to schemas
  */
@@ -18,7 +24,7 @@ export class BindUtil {
     if (conf.type?.bindSchema) {
       val = conf.type.bindSchema(val);
     } else {
-      val = Util.coerceType(val, conf.type, false);
+      val = DataUtil.coerceType(val, conf.type, false);
 
       if (conf.type === Number && conf.precision && typeof val === 'number') {
         if (conf.precision[1]) { // Supports decimal
@@ -32,16 +38,6 @@ export class BindUtil {
     return val as T;
   }
 
-  /**
-   * Register `from` on the Function prototype
-   */
-  static register(): void {
-    const proto = Object.getPrototypeOf(Function);
-    proto.from = function (data: object | ClassInstance, view?: string): unknown {
-      return BindUtil.bindSchema(this, data, view);
-    };
-  }
-
   /**
    * Convert dotted paths into a full object
    *
@@ -53,7 +49,7 @@ export class BindUtil {
     const out: Record<string, unknown> = {};
     for (const k of Object.keys(obj)) {
       const objK = obj[k];
-      const val = Util.isPlainObject(objK) ? this.expandPaths(objK) : objK;
+      const val = ObjectUtil.isPlainObject(objK) ? this.expandPaths(objK) : objK;
       const parts = k.split('.');
       const last = parts.pop()!;
       let sub = out;
@@ -80,8 +76,8 @@ export class BindUtil {
       }
 
       if (last.indexOf('[') < 0) {
-        if (sub[last] && Util.isPlainObject(val)) {
-          sub[last] = Util.deepAssign(sub[last], val, 'coerce');
+        if (sub[last] && ObjectUtil.isPlainObject(val)) {
+          sub[last] = DataUtil.deepAssign(sub[last], val, 'coerce');
         } else {
           sub[last] = val;
         }
@@ -98,8 +94,8 @@ export class BindUtil {
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             key = sub.length as number;
           }
-          if (sub[key] && Util.isPlainObject(val) && Util.isPlainObject(sub[key])) {
-            sub[key] = Util.deepAssign(sub[key], val, 'coerce');
+          if (sub[key] && ObjectUtil.isPlainObject(val) && ObjectUtil.isPlainObject(sub[key])) {
+            sub[key] = DataUtil.deepAssign(sub[key], val, 'coerce');
           } else {
             sub[key] = val;
           }
@@ -118,13 +114,13 @@ export class BindUtil {
     const out: Record<string, unknown> = {};
     for (const [key, value] of Object.entries(data)) {
       const pre = `${prefix}${key}`;
-      if (Util.isPlainObject(value)) {
+      if (ObjectUtil.isPlainObject(value)) {
         Object.assign(out, this.flattenPaths(value, `${pre}.`)
         );
       } else if (Array.isArray(value)) {
         for (let i = 0; i < value.length; i++) {
           const v = value[i];
-          if (Util.isPlainObject(v)) {
+          if (ObjectUtil.isPlainObject(v)) {
             Object.assign(out, this.flattenPaths(v, `${pre}[${i}].`));
           } else {
             out[`${pre}[${i}]`] = v;
@@ -141,12 +137,12 @@ export class BindUtil {
    * Bind data to the schema for a class, with an optional view
    * @param cons The schema class to bind against
    * @param data The provided data to bind
-   * @param view The optional view to limit the binding against
+   * @param cfg The bind configuration
    */
-  static bindSchema<T>(cons: Class<T>, data?: undefined, view?: string): undefined;
-  static bindSchema<T>(cons: Class<T>, data?: null, view?: string): null;
-  static bindSchema<T>(cons: Class<T>, data?: object | T, view?: string): T;
-  static bindSchema<T>(cons: Class<T>, data?: object | T, view?: string): T | null | undefined {
+  static bindSchema<T>(cons: Class<T>, data?: undefined, cfg?: BindConfig): undefined;
+  static bindSchema<T>(cons: Class<T>, data?: null, cfg?: BindConfig): null;
+  static bindSchema<T>(cons: Class<T>, data?: object | T, cfg?: BindConfig): T;
+  static bindSchema<T>(cons: Class<T>, data?: object | T, cfg?: BindConfig): T | null | undefined {
     if (data === null || data === undefined) {
       return data;
     }
@@ -161,13 +157,13 @@ export class BindUtil {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       SchemaRegistry.ensureInstanceTypeField(cls, tgt as T & { type?: string });
 
-      for (const k of Object.keys(tgt)) { // Do not retain undefined fields
+      for (const k of TypedObject.keys(tgt)) { // Do not retain undefined fields
         if (tgt[k] === undefined) {
           delete tgt[k];
         }
       }
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return this.bindSchemaToObject(cls, tgt, data as object, view);
+      return this.bindSchemaToObject(cls, tgt, data as object, cfg);
     }
   }
 
@@ -176,17 +172,18 @@ export class BindUtil {
    * @param cons The schema class
    * @param obj The target object (instance of cons)
    * @param data The data to bind
-   * @param view The desired view
+   * @param cfg The bind configuration
    */
-  static bindSchemaToObject<T>(cons: Class<T>, obj: T, data?: object, view?: string | typeof AllViewⲐ): T {
-    view ??= AllViewⲐ;
+  static bindSchemaToObject<T>(cons: Class<T>, obj: T, data?: object, cfg: BindConfig = {}): T {
+    const view = cfg.view ?? AllViewⲐ; // Does not convey
+    delete cfg.view;
 
-    if (!!data && !Util.isPrimitive(data)) {
+    if (!!data && !ObjectUtil.isPrimitive(data)) {
       const conf = SchemaRegistry.get(cons);
 
       // If no configuration
       if (!conf) {
-        for (const k of Object.keys(data)) {
+        for (const k of TypedObject.keys(data)) {
           // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           obj[k] = data[k as keyof typeof data];
         }
@@ -198,14 +195,16 @@ export class BindUtil {
         }
 
         for (const schemaFieldName of viewConf.fields) {
+          const field = viewConf.schema[schemaFieldName];
+
           let inboundField: string | undefined = undefined;
-          if (viewConf.schema[schemaFieldName].access === 'readonly') {
+          if (field.access === 'readonly' || cfg.filterField?.(field) === false) {
             continue; // Skip trying to write readonly fields
           }
           if (schemaFieldName in data) {
             inboundField = schemaFieldName;
-          } else if (viewConf.schema[schemaFieldName].aliases) {
-            for (const aliasedField of (viewConf.schema[schemaFieldName].aliases ?? [])) {
+          } else if (field.aliases) {
+            for (const aliasedField of (field.aliases ?? [])) {
               if (aliasedField in data) {
                 inboundField = aliasedField;
                 break;
@@ -220,29 +219,43 @@ export class BindUtil {
           // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           let v: unknown = data[inboundField as keyof typeof data];
 
-          if (v !== undefined && v !== null) {
-            const config = viewConf.schema[schemaFieldName];
+          // Filtering values
+          if (cfg.filterValue && !cfg.filterValue(v, field)) {
+            continue;
+          }
 
+          if (v !== undefined && v !== null) {
             // Ensure its an array
-            if (!Array.isArray(v) && config.array) {
-              v = [v];
+            if (!Array.isArray(v) && field.array) {
+              if (typeof v === 'string' && v.includes(',')) {
+                v = v.split(/\s*,\s*/);
+              } else {
+                v = [v];
+              }
             }
 
-            if (SchemaRegistry.has(config.type)) {
-              if (config.array && Array.isArray(v)) {
-                v = v.map(el => this.bindSchema(config.type, el));
+            if (SchemaRegistry.has(field.type)) {
+              if (field.array && Array.isArray(v)) {
+                v = v.map(el => this.bindSchema(field.type, el, cfg));
               } else {
-                v = this.bindSchema(config.type, v);
+                v = this.bindSchema(field.type, v, cfg);
               }
-            } else if (config.array && Array.isArray(v)) {
-              v = v.map(el => this.#coerceType(config, el));
+            } else if (field.array && Array.isArray(v)) {
+              v = v.map(el => this.#coerceType(field, el));
             } else {
-              v = this.#coerceType(config, v);
+              v = this.#coerceType(field, v);
             }
           }
 
           // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           obj[schemaFieldName as keyof typeof obj] = v as (typeof obj)[keyof typeof obj];
+
+          if (field.accessor) {
+            Object.defineProperty(obj, schemaFieldName, {
+              ...SchemaRegistry.getAccessorDescriptor(cons, schemaFieldName),
+              enumerable: true
+            });
+          }
         }
       }
     }
@@ -265,15 +278,15 @@ export class BindUtil {
     if (field.array) {
       const valArr = !Array.isArray(val) ? [val] : val;
       if (complex) {
-        val = valArr.map(x => this.bindSchema(field.type, x, field.view));
+        val = valArr.map(x => this.bindSchema(field.type, x, { view: field.view }));
       } else {
-        val = valArr.map(x => Util.coerceType(x, field.type, false));
+        val = valArr.map(x => DataUtil.coerceType(x, field.type, false));
       }
     } else {
       if (complex) {
-        val = this.bindSchema(field.type, val, field.view);
+        val = this.bindSchema(field.type, val, { view: field.view });
       } else {
-        val = Util.coerceType(val, field.type, false);
+        val = DataUtil.coerceType(val, field.type, false);
       }
     }
     return val;

package/src/decorator/common.ts

@@ -10,7 +10,7 @@ function isClassInstance(o: Class | ClassInstance, property?: string): o is Clas
 /**
  * Describe a model or a field
  * @param config The describe configuration
- * @augments `@trv:schema/Describe`
+ * @augments `@travetto/schema:Describe`
  */
 export function Describe(config: Partial<DescribableConfig>) {
   return (target: Class | ClassInstance, property?: string, descOrIdx?: PropertyDescriptor | number): void => {

package/src/decorator/field.ts

@@ -33,7 +33,7 @@ const dateNumberProp: (obj: Partial<FieldConfig>) => <T extends Partial<Record<K
  * Registering a field
  * @param type The type for the field
  * @param config The field configuration
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Field(type: ClassList, config?: Partial<FieldConfig>) {
   return (f: ClassInstance, k: string, idx?: number | PropertyDescriptor): void => {
@@ -48,33 +48,39 @@ export function Field(type: ClassList, config?: Partial<FieldConfig>) {
 /**
  * Alias for the field
  * @param aliases List of all aliases for a field
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Alias(...aliases: string[]): ReturnType<typeof prop> { return prop({ aliases }); }
 /**
  * Mark a field as writeonly
  * @param active This determines if this field is readonly or not.
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Writeonly(active = true): ReturnType<typeof prop> { return prop({ access: 'writeonly' }); }
 /**
  * Mark a field as readonly
  * @param active This determines if this field is readonly or not.
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Readonly(active = true): ReturnType<typeof prop> { return prop({ access: 'readonly' }); }
+/**
+ * Mark a field as sensitive
+ * @param active This determines if this field is sensitive or not.
+ * @augments `@travetto/schema:Field`
+ */
+export function Secret(active = true): ReturnType<typeof prop> { return prop({ secret: active }); }
 /**
  * Mark a field as required
  * @param active This determines if this field is required or not.
  * @param message The error message when a the constraint fails.
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Required(active = true, message?: string): ReturnType<typeof prop> { return prop({ required: { active, message } }); }
 /**
  * Define a field as a set of enumerated values
  * @param values The list of values allowed for the enumeration
  * @param message The error message to show when the constraint fails
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Enum(values: string[], message?: string): ReturnType<typeof stringNumberProp> {
   message = message || `{path} is only allowed to be "${values.join('" or "')}"`;
@@ -82,12 +88,12 @@ export function Enum(values: string[], message?: string): ReturnType<typeof stri
 }
 /**
  * Mark the field as indicating it's storing textual data
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Text(): ReturnType<typeof stringArrStringProp> { return stringArrStringProp({ specifier: 'text' }); }
 /**
  * Mark the field to indicate it's for long form text
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function LongText(): ReturnType<typeof stringArrStringProp> { return stringArrStringProp({ specifier: 'text-long' }); }
 
@@ -95,7 +101,7 @@ export function LongText(): ReturnType<typeof stringArrStringProp> { return stri
  * Require the field to match a specific RegExp
  * @param re The regular expression to match against
  * @param message The message to show when the constraint fails
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Match(re: RegExp, message?: string): ReturnType<typeof stringArrStringProp> { return stringArrStringProp({ match: { re, message } }); }
 
@@ -103,7 +109,7 @@ export function Match(re: RegExp, message?: string): ReturnType<typeof stringArr
  * The minimum length for the string or array
  * @param n The minimum length
  * @param message The message to show when the constraint fails
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function MinLength(n: number, message?: string): ReturnType<typeof stringArrProp> {
   return stringArrProp({ minlength: { n, message }, ...(n === 0 ? { required: { active: false } } : {}) });
@@ -113,7 +119,7 @@ export function MinLength(n: number, message?: string): ReturnType<typeof string
  * The maximum length for the string or array
  * @param n The maximum length
  * @param message The message to show when the constraint fails
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function MaxLength(n: number, message?: string): ReturnType<typeof stringArrProp> { return stringArrProp({ maxlength: { n, message } }); }
 
@@ -121,7 +127,7 @@ export function MaxLength(n: number, message?: string): ReturnType<typeof string
  * The minimum value
  * @param n The minimum value
  * @param message The message to show when the constraint fails
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Min<T extends number | Date>(n: T, message?: string): ReturnType<typeof dateNumberProp> {
   return dateNumberProp({ min: { n, message } });
@@ -131,7 +137,7 @@ export function Min<T extends number | Date>(n: T, message?: string): ReturnType
  * The maximum value
  * @param n The maximum value
  * @param message The message to show when the constraint fails
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Max<T extends number | Date>(n: T, message?: string): ReturnType<typeof dateNumberProp> {
   return dateNumberProp({ max: { n, message } });
@@ -140,21 +146,21 @@ export function Max<T extends number | Date>(n: T, message?: string): ReturnType
 /**
  * Mark a field as an email
  * @param message The message to show when the constraint fails
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Email(message?: string): ReturnType<typeof Match> { return Match(CommonRegExp.email, message); }
 
 /**
  * Mark a field as an telephone number
  * @param message The message to show when the constraint fails
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Telephone(message?: string): ReturnType<typeof Match> { return Match(CommonRegExp.telephone, message); }
 
 /**
  * Mark a field as a url
  * @param message The message to show when the constraint fails
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Url(message?: string): ReturnType<typeof Match> { return Match(CommonRegExp.url, message); }
 
@@ -162,38 +168,38 @@ export function Url(message?: string): ReturnType<typeof Match> { return Match(C
  * Determine the numeric precision of the value
  * @param digits The number of digits a number should have
  * @param decimals The number of decimal digits to support
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Precision(digits: number, decimals?: number): ReturnType<typeof numberProp> { return numberProp({ precision: [digits, decimals] }); }
 
 /**
  * Mark a number as an integer
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Integer(): ReturnType<typeof numberProp> { return Precision(0); }
 
 /**
  * Mark a number as a float
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Float(): ReturnType<typeof numberProp> { return Precision(10, 7); }
 
 /**
  * Mark a number as a long value
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Long(): ReturnType<typeof numberProp> { return Precision(19, 0); }
 
 /**
  * Mark a number as a currency
- * @augments `@trv:schema/Field`
+ * @augments `@travetto/schema:Field`
  */
 export function Currency(): ReturnType<typeof numberProp> { return Precision(13, 2); }
 
 /**
  * Mark a field as ignored
  *
- * @augments `@trv:schema/Ignore`
+ * @augments `@travetto/schema:Ignore`
  */
 export function Ignore(): PropertyDecorator {
   return (target: Object, property: string | symbol) => { };

package/src/decorator/schema.ts

@@ -1,16 +1,21 @@
 import { Class } from '@travetto/base';
 
+import { BindUtil } from '../bind-util';
 import { SchemaRegistry } from '../service/registry';
 import { ViewFieldsConfig } from '../service/types';
+import { DeepPartial } from '../types';
 import { ValidatorFn } from '../validate/types';
 
 /**
  * Register a class as a Schema
  *
- * @augments `@trv:schema/Schema`
+ * @augments `@travetto/schema:Schema`
  */
 export function Schema() { // Auto is used during compilation
   return <T, U extends Class<T>>(target: U): U => {
+    target.from ??= function <V>(this: Class<V>, data: DeepPartial<V>, view?: string): V {
+      return BindUtil.bindSchema(this, data, { view });
+    };
     SchemaRegistry.getOrCreatePending(target);
     return target;
   };

package/src/internal/types.ts

@@ -1 +1 @@
-export const AllViewⲐ: unique symbol = Symbol.for('@trv:schema/all');
+export const AllViewⲐ: unique symbol = Symbol.for('@travetto/schema:all');

package/src/service/changes.ts

@@ -6,7 +6,7 @@ import { ChangeEvent } from '@travetto/registry';
 import { FieldConfig, ClassConfig } from './types';
 import { AllViewⲐ } from '../internal/types';
 
-const id = (c: Class | string): string => typeof c === 'string' ? c : c.ᚕid;
+const id = (c: Class | string): string => typeof c === 'string' ? c : c.Ⲑid;
 
 interface FieldMapping {
   path: FieldConfig[];
@@ -57,13 +57,6 @@ class $SchemaChangeListener {
     this.#emitter.on('field', handler);
   }
 
-  /**
-   * Reset the listener
-   */
-  reset(): void {
-    this.#mapping.clear();
-  }
-
   /**
    * Clear dependency mappings for a given class
    */
@@ -139,7 +132,7 @@ class $SchemaChangeListener {
     }
 
     // Handle class references changing, but keeping same id
-    const compareTypes = (a: Class, b: Class): boolean => 'ᚕid' in a ? a.ᚕid === b.ᚕid : a === b;
+    const compareTypes = (a: Class, b: Class): boolean => 'Ⲑid' in a ? a.Ⲑid === b.Ⲑid : a === b;
 
     for (const c of currFields) {
       if (prevFields.has(c)) {

package/src/service/registry.ts

@@ -1,4 +1,4 @@
-import { Class, AppError, Util, ClassInstance, ConcreteClass } from '@travetto/base';
+import { Class, AppError, ObjectUtil, ClassInstance, ConcreteClass } from '@travetto/base';
 import { MetadataRegistry, RootRegistry, ChangeEvent } from '@travetto/registry';
 
 import { ClassList, FieldConfig, ClassConfig, SchemaConfig, ViewFieldsConfig, ViewConfig } from './types';
@@ -8,7 +8,7 @@ import { AllViewⲐ } from '../internal/types';
 
 function hasType<T>(o: unknown): o is { type: Class<T> | string } {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !!o && !Util.isPrimitive(o) && 'type' in (o as object) && !!(o as Record<string, string>)['type'];
+  return !!o && !ObjectUtil.isPrimitive(o) && 'type' in (o as object) && !!(o as Record<string, string>)['type'];
 }
 
 function isWithType<T>(o: T, cfg: ClassConfig | undefined): o is T & { type?: string } {
@@ -20,12 +20,12 @@ function getConstructor<T>(o: T): ConcreteClass<T> {
   return (o as unknown as ClassInstance<T>).constructor;
 }
 
-
 /**
  * Schema registry for listening to changes
  */
 class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
 
+  #accessorDescriptors = new Map<Class, Map<string, PropertyDescriptor>>();
   #subTypes = new Map<Class, Map<string, Class>>();
   #typeKeys = new Map<Class, string>();
   #pendingViews = new Map<Class, Map<string, ViewFieldsConfig<unknown>>>();
@@ -55,6 +55,32 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     }
   }
 
+  /**
+   * Retrieve class level metadata
+   * @param cls
+   * @param prop
+   * @param key
+   * @returns
+   */
+  getMetadata<K>(cls: Class, key: symbol): K | undefined {
+    const cfg = this.get(cls);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return cfg.metadata?.[key] as K;
+  }
+
+  /**
+   * Retrieve pending class level metadata, or create if needed
+   * @param cls
+   * @param prop
+   * @param key
+   * @returns
+   */
+  getOrCreatePendingMetadata<K>(cls: Class, key: symbol, value: K): K {
+    const cfg = this.getOrCreatePending(cls);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return ((cfg.metadata ??= {})[key] ??= value) as K;
+  }
+
   /**
    * Ensure type is set properly
    */
@@ -64,6 +90,24 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     }
   }
 
+  /**
+   * Provides the prototype-derived descriptor for a property
+   */
+  getAccessorDescriptor(cls: Class, field: string): PropertyDescriptor {
+    if (!this.#accessorDescriptors.has(cls)) {
+      this.#accessorDescriptors.set(cls, new Map());
+    }
+    const map = this.#accessorDescriptors.get(cls)!;
+    if (!map.has(field)) {
+      let proto = cls.prototype;
+      while (proto && !Object.hasOwn(proto, field)) {
+        proto = proto.prototype;
+      }
+      map.set(field, Object.getOwnPropertyDescriptor(proto, field)!);
+    }
+    return map.get(field)!;
+  }
+
   /**
    * Find the subtype for a given instance
    * @param cls Class for instance
@@ -80,7 +124,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    */
   resolveSubType(cls: Class, type: Class | string): Class {
     if (this.#subTypes.has(cls)) {
-      const typeId = type && (typeof type === 'string' ? type : type.ᚕid);
+      const typeId = type && (typeof type === 'string' ? type : type.Ⲑid);
       if (type) {
         return this.#subTypes.get(cls)!.get(typeId) ?? cls;
       }
@@ -114,7 +158,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
         this.#subTypes.set(parent, new Map());
       }
       this.#subTypes.get(parent)!.set(type, cls);
-      this.#subTypes.get(parent)!.set(cls.ᚕid, cls);
+      this.#subTypes.get(parent)!.set(cls.Ⲑid, cls);
       parent = this.getParentClass(parent!)!;
       parentConfig = this.get(parent);
     }
@@ -147,6 +191,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       class: cls,
       validators: [],
       subType: false,
+      metadata: {},
       views: {
         [AllViewⲐ]: {
           schema: {},
@@ -301,6 +346,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       schema: { ...dest.views[AllViewⲐ].schema, ...src.views?.[AllViewⲐ].schema },
       fields: [...dest.views[AllViewⲐ].fields, ...src.views?.[AllViewⲐ].fields ?? []]
     };
+    dest.metadata = { ...src.metadata ?? {}, ...dest.metadata ?? {} };
     dest.subType = src.subType || dest.subType;
     dest.title = src.title || dest.title;
     dest.validators = [...src.validators ?? [], ...dest.validators];
@@ -377,6 +423,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       this.#subTypes.clear();
       this.#typeKeys.delete(cls);
       this.#methodSchemas.delete(cls);
+      this.#accessorDescriptors.delete(cls);
 
       // Recompute subtype mappings
       for (const el of this.entries.keys()) {

package/src/service/types.ts

@@ -1,5 +1,4 @@
-import { Class } from '@travetto/base';
-import { Primitive } from '@travetto/base/src/internal/global-types';
+import { Primitive, Class } from '@travetto/base';
 
 import { AllViewⲐ } from '../internal/types';
 import { ValidatorFn } from '../validate/types';
@@ -68,6 +67,10 @@ export interface ClassConfig extends DescribableConfig {
    * Is the class a sub type
    */
   subType?: boolean;
+  /**
+   * Metadata that is related to the schema structure
+   */
+  metadata?: Record<symbol, unknown>;
 }
 
 /**
@@ -149,6 +152,14 @@ export interface FieldConfig extends DescribableConfig {
    * Is the field readonly, or write only?, defaults to no restrictions
    */
   access?: 'readonly' | 'writeonly';
+  /**
+   * Is this field secret, defaults to no, can be used to hide field when exporting values
+   */
+  secret?: boolean;
+  /**
+   * Is this field a getter or setter
+   */
+  accessor?: string;
 }
 
 export type ViewFieldsConfig<T> = { with: Extract<(keyof T), string>[] } | { without: Extract<(keyof T), string>[] };

package/src/typings.d.ts

@@ -13,7 +13,7 @@ declare global {
 
   namespace NodeJS {
     /**
-     * @concrete stream:Readable:node
+     * @concrete stream:Readable
      */
     interface ReadableStream { }
   }
@@ -21,7 +21,7 @@ declare global {
 
 declare module 'stream' {
   /**
-   * @concrete stream:Readable:node
+   * @concrete stream:Readable
    */
   interface Readable { }
 }

package/src/validate/regexp.ts

@@ -1,3 +1,4 @@
+import { TypedObject } from '@travetto/base';
 import { Messages } from './messages';
 
 declare global {
@@ -18,7 +19,7 @@ export const CommonRegExp = {
 };
 
 // Rebind regexes
-for (const k of Object.keys(CommonRegExp)) {
+for (const k of TypedObject.keys(CommonRegExp)) {
   CommonRegExp[k].name = `[[:${k}:]]`;
   Messages.set(CommonRegExp[k].name!, Messages.get(k)!);
 }

package/src/validate/validator.ts

@@ -1,4 +1,4 @@
-import { Class, ClassInstance, Util } from '@travetto/base';
+import { Class, ClassInstance, TypedObject, ObjectUtil } from '@travetto/base';
 
 import { FieldConfig, SchemaConfig } from '../service/types';
 import { SchemaRegistry } from '../service/registry';
@@ -38,7 +38,7 @@ export class SchemaValidator {
   static #validateSchema<T>(schema: SchemaConfig, o: T, relative: string): ValidationError[] {
     let errors: ValidationError[] = [];
 
-    const fields = Object.keys<SchemaConfig>(schema);
+    const fields = TypedObject.keys<SchemaConfig>(schema);
     for (const field of fields) {
       if (schema[field].access !== 'readonly') { // Do not validate readonly fields
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -236,7 +236,7 @@ export class SchemaValidator {
    */
   static async validate<T>(cls: Class<T>, o: T, view?: string): Promise<T> {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    if (!Util.isPlainObject(o) && !(o instanceof cls || cls.ᚕid === (o as ClassInstance<T>).constructor.ᚕid)) {
+    if (!ObjectUtil.isPlainObject(o) && !(o instanceof cls || cls.Ⲑid === (o as ClassInstance<T>).constructor.Ⲑid)) {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       throw new TypeMismatchError(cls.name, (o as ClassInstance).constructor.name);
     }

package/support/transform-util.ts

@@ -1,5 +1,5 @@
-import * as ts from 'typescript';
-import { AnyType, DeclarationUtil, DecoratorUtil, DocUtil, ParamDocumentation, TransformerId, TransformerState } from '@travetto/transformer';
+import ts from 'typescript';
+import { type AnyType, DeclarationUtil, DecoratorUtil, DocUtil, ParamDocumentation, TransformerState } from '@travetto/transformer';
 
 const SCHEMA_MOD = '@travetto/schema/src/decorator/schema';
 const FIELD_MOD = '@travetto/schema/src/decorator/field';
@@ -16,7 +16,7 @@ export class SchemaTransformUtil {
       case 'external': return state.getOrImport(type);
       case 'tuple': return state.fromLiteral(type.subTypes.map(x => this.toConcreteType(state, x, node, root)!));
       case 'literal': {
-        if ((type.ctor === Array || type.ctor === Set) && type.typeArguments?.length) {
+        if ((type.ctor === Array) && type.typeArguments?.length) {
           return state.fromLiteral([this.toConcreteType(state, type.typeArguments[0], node, root)]);
         } else if (type.ctor) {
           return state.createIdentifier(type.ctor.name!);
@@ -50,7 +50,7 @@ export class SchemaTransformUtil {
               )
           );
           cls.getText = (): string => '';
-          state.addStatement(cls, root || node);
+          state.addStatements([cls], root || node);
         }
         return id;
       }
@@ -81,7 +81,7 @@ export class SchemaTransformUtil {
     if (!ts.isGetAccessorDeclaration(node) && !ts.isSetAccessorDeclaration(node)) {
       // eslint-disable-next-line no-bitwise
       if ((ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Readonly) > 0) {
-        attrs.push(state.factory.createPropertyAssignment('mode', state.fromLiteral('readonly')));
+        attrs.push(state.factory.createPropertyAssignment('access', state.fromLiteral('readonly')));
       } else if (!node.questionToken && !typeExpr.undefinable && !node.initializer) {
         attrs.push(state.factory.createPropertyAssignment('required', state.fromLiteral({ active: true })));
       }
@@ -90,11 +90,12 @@ export class SchemaTransformUtil {
       }
     } else {
       const acc = DeclarationUtil.getAccessorPair(node);
+      attrs.push(state.factory.createPropertyAssignment('accessor', state.fromLiteral(true)));
       if (!acc.setter) {
         attrs.push(state.factory.createPropertyAssignment('access', state.fromLiteral('readonly')));
       }
       if (!acc.getter) {
-        attrs.push(state.factory.createPropertyAssignment('mode', state.fromLiteral('writeonly')));
+        attrs.push(state.factory.createPropertyAssignment('access', state.fromLiteral('writeonly')));
       } else if (!typeExpr.undefinable) {
         attrs.push(state.factory.createPropertyAssignment('required', state.fromLiteral({ active: true })));
       }
@@ -129,7 +130,7 @@ export class SchemaTransformUtil {
 
     const params: ts.Expression[] = [];
 
-    const existing = state.findDecorator({ [TransformerId]: '@trv:schema', name: 'util' }, node, 'Field', FIELD_MOD);
+    const existing = state.findDecorator('@travetto/schema', node, 'Field', FIELD_MOD);
     if (!existing) {
       const resolved = this.toConcreteType(state, typeExpr, node, config.root);
       params.push(resolved);
@@ -179,7 +180,7 @@ export class SchemaTransformUtil {
     const out: Record<string, unknown> = {};
 
     while (type?.key === 'literal' && type.typeArguments?.length) {
-      if (type.ctor === Array || type.ctor === Set) {
+      if (type.ctor === Array) {
         out.array = true;
       }
       type = type.typeArguments?.[0] ?? { key: 'literal', ctor: Object }; // We have a promise nested

package/support/transformer.schema.ts

@@ -1,29 +1,27 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
 import {
-  TransformerState, OnProperty, OnClass, AfterClass, DecoratorMeta, DocUtil, DeclarationUtil, TransformerId, OnGetter, OnSetter
+  TransformerState, OnProperty, OnClass, AfterClass, DecoratorMeta, DocUtil, DeclarationUtil, OnGetter, OnSetter
 } from '@travetto/transformer';
 
 import { SchemaTransformUtil } from './transform-util';
 
-const inSchema = Symbol.for('@trv:schema/schema');
-const accessors = Symbol.for('@trv:schema/schema');
+const inSchema = Symbol.for('@travetto/schema:schema');
+const accessors = Symbol.for('@travetto/schema:accessors');
 
 interface AutoState {
   [inSchema]?: boolean;
   [accessors]?: Set<string>;
 }
 
-const SCHEMA_MOD = '@travetto/schema/src/decorator/schema';
-const COMMON_MOD = '@travetto/schema/src/decorator/common';
+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
  */
 export class SchemaTransformer {
 
-  static [TransformerId] = '@trv:schema';
-
   /**
    * Track schema on start
    */
@@ -43,12 +41,12 @@ export class SchemaTransformer {
 
     const comments = DocUtil.describeDocs(node);
 
-    if (!state.findDecorator(this, node, 'Schema', SCHEMA_MOD)) {
-      modifiers.unshift(state.createDecorator(SCHEMA_MOD, 'Schema'));
+    if (!state.findDecorator(this, node, 'Schema', SCHEMA_IMPORT)) {
+      modifiers.unshift(state.createDecorator(SCHEMA_IMPORT, 'Schema'));
     }
 
     if (comments.description) {
-      modifiers.push(state.createDecorator(COMMON_MOD, 'Describe', state.fromLiteral({
+      modifiers.push(state.createDecorator(COMMON_IMPORT, 'Describe', state.fromLiteral({
         title: comments.description
       })));
     }

package/support/phase.init.ts

@@ -1,11 +0,0 @@
-/**
- * Registers the bind utilities on class
- */
-export const init = {
-  key: '@trv:schema/init',
-  after: ['@trv:registry/init'], // Should be global
-  action: async (): Promise<void> => {
-    const { BindUtil } = await import('../src/bind-util');
-    BindUtil.register();
-  }
-};