@afora/core 0.0.9 → 0.0.12

package/dist/core/parse/parse.js

@@ -0,0 +1,323 @@
+import { isBlueprint } from "../blueprint/is-blueprint.js";
+import { isBlueprintList } from "../blueprint/list.js";
+import { recordFieldOf } from "../blueprint/record-field.js";
+import { isBlueprintVariant } from "../blueprint/variant.js";
+import {
+  AbstractProperty,
+  parsingDefinitionOf
+} from "../property/abstract-property.js";
+import { parserOf, takeRejectionIssues } from "../property/define-property.js";
+import { isProperty } from "../property/is-property.js";
+import { recordNameOf } from "../record/name.js";
+import { movedIssue, REJECTED } from "./issue.js";
+const entriesOf = new WeakMap;
+export function fieldsOf(properties) {
+  let entries = entriesOf.get(properties);
+  if (!entries) {
+    entries = Object.entries(properties);
+    entriesOf.set(properties, entries);
+  }
+  return entries;
+}
+export function isPlainObject(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+const PROPERTY = 0;
+const LIST = 1;
+const BLUEPRINT = 2;
+const RECORD = 3;
+const UNDECLARED_FIELD = 4;
+const VARIANT = 5;
+function stepOf(field) {
+  const record = recordFieldOf(field);
+  const kind = isBlueprintList(field) ? LIST : isBlueprint(field) ? BLUEPRINT : isBlueprintVariant(field) ? VARIANT : record ? RECORD : isProperty(field) ? PROPERTY : UNDECLARED_FIELD;
+  return {
+    kind,
+    property: kind === PROPERTY ? field : undefined,
+    parser: undefined,
+    list: kind === LIST ? field : undefined,
+    item: undefined,
+    blueprint: kind === BLUEPRINT ? field : undefined,
+    collection: undefined,
+    record: kind === RECORD ? record?.record : undefined,
+    optionalRecord: kind === RECORD && record?.optional === true,
+    variant: kind === VARIANT ? field : undefined,
+    variants: undefined
+  };
+}
+const UNDECLARED = {
+  kind: UNDECLARED_FIELD,
+  property: undefined,
+  parser: undefined,
+  list: undefined,
+  item: undefined,
+  blueprint: undefined,
+  collection: undefined,
+  record: undefined,
+  optionalRecord: false,
+  variant: undefined,
+  variants: undefined
+};
+const steps = new WeakMap;
+function keptStepOf(field) {
+  if (typeof field !== "object" && typeof field !== "function" || field === null) {
+    return UNDECLARED;
+  }
+  let step = steps.get(field);
+  if (!step) {
+    step = stepOf(field);
+    steps.set(field, step);
+  }
+  return step;
+}
+const collections = new WeakMap;
+function collectionOf(properties) {
+  let collection = collections.get(properties);
+  if (!collection) {
+    const fields = fieldsOf(properties);
+    collection = {
+      properties,
+      names: fields.map(([name]) => name),
+      steps: fields.map(([, field]) => keptStepOf(field))
+    };
+    collections.set(properties, collection);
+  }
+  return collection;
+}
+function runOf(base, source) {
+  return { source, base, keys: [], issues: undefined };
+}
+function pathOf(run, depth) {
+  const { base, keys } = run;
+  const path = base.length === 0 ? [] : [...base];
+  for (let index = 0;index < depth; index++) {
+    path.push(keys[index]);
+  }
+  return path;
+}
+function reject(run, code, message, path) {
+  run.issues ??= [];
+  run.issues.push({ code, message, path, source: run.source });
+  return REJECTED;
+}
+function resultOf(run, handled) {
+  return handled === REJECTED ? { issues: run.issues ?? [] } : { value: handled };
+}
+export function parseCollection(properties, value, path, source) {
+  const run = runOf(path, source);
+  return resultOf(run, collectionAt(collectionOf(properties), value, run, 0));
+}
+const ROOT = Object.freeze([]);
+export function collectionParserOf(properties, source) {
+  let collection;
+  return (value, vouched, complete) => {
+    collection ??= collectionOf(properties);
+    const run = runOf(ROOT, source);
+    return resultOf(run, collectionAt(collection, value, run, 0, vouched, undefined, complete));
+  };
+}
+function collectionAt(collection, value, run, depth, vouched, tag, complete) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return reject(run, "invalid_type", "must be an object", pathOf(run, depth));
+  }
+  const { properties, names, steps } = collection;
+  let rejected = false;
+  const keys = Object.keys(value);
+  for (let index = 0;index < keys.length; index++) {
+    const name = keys[index];
+    if (name === names[index] || name === tag || Object.hasOwn(properties, name)) {
+      continue;
+    }
+    rejected = true;
+    reject(run, "undeclared_key", "is not declared", [
+      ...pathOf(run, depth),
+      name
+    ]);
+  }
+  const handled = tag === undefined ? {} : { [tag]: value[tag] };
+  const first = vouched?.[0];
+  const second = vouched?.[1];
+  const third = vouched?.[2];
+  for (let index = 0;index < names.length; index++) {
+    const name = names[index];
+    if (vouched !== undefined && (name === first || name === second || name === third || vouched.length > 3 && vouched.includes(name))) {
+      handled[name] = value[name];
+      continue;
+    }
+    run.keys[depth] = name;
+    const item = fieldAt(steps[index], value[name], run, depth + 1);
+    if (item === REJECTED)
+      rejected = true;
+    else if (item !== undefined)
+      handled[name] = item;
+  }
+  if (!rejected && complete !== undefined) {
+    for (const name of complete(handled) ?? []) {
+      run.keys[depth] = name;
+      const item = fieldAt(steps[names.indexOf(name)], handled[name], run, depth + 1);
+      if (item === REJECTED)
+        rejected = true;
+      else if (item !== undefined)
+        handled[name] = item;
+    }
+  }
+  return rejected ? REJECTED : Object.freeze(handled);
+}
+export function parseField(field, value, path, source) {
+  const run = runOf(path, source);
+  return resultOf(run, fieldAt(keptStepOf(field), value, run, 0));
+}
+const DECLARED_SAFE_PARSE = AbstractProperty.safeParse;
+function fieldAt(step, value, run, depth) {
+  switch (step.kind) {
+    case PROPERTY:
+      return propertyAt(step, value, run, depth);
+    case LIST: {
+      const list = step.list;
+      if (value === undefined) {
+        return list.optional ? value : required(run, depth);
+      }
+      if (!Array.isArray(value)) {
+        return reject(run, "invalid_type", "must be an array", pathOf(run, depth));
+      }
+      const { minItems, maxItems } = list;
+      let rejected = false;
+      if (minItems !== undefined && value.length < minItems || maxItems !== undefined && value.length > maxItems) {
+        rejected = true;
+        const path = pathOf(run, depth);
+        if (minItems !== undefined && value.length < minItems) {
+          reject(run, "too_few_items", `must have at least ${minItems} items`, path);
+        }
+        if (maxItems !== undefined && value.length > maxItems) {
+          reject(run, "too_many_items", `must have at most ${maxItems} items`, path);
+        }
+      }
+      step.item ??= keptStepOf(list.item);
+      const { item } = step;
+      const items = [];
+      for (let index = 0;index < value.length; index++) {
+        run.keys[depth] = index;
+        const handled = fieldAt(item, value[index], run, depth + 1);
+        if (handled === REJECTED)
+          rejected = true;
+        else
+          items.push(handled);
+      }
+      return rejected ? REJECTED : Object.freeze(items);
+    }
+    case BLUEPRINT: {
+      const blueprint = step.blueprint;
+      if (value === undefined) {
+        return blueprint.optional ? value : required(run, depth);
+      }
+      step.collection ??= collectionOf(blueprint.properties);
+      return collectionAt(step.collection, value, run, depth);
+    }
+    case VARIANT: {
+      const variant = step.variant;
+      if (value === undefined) {
+        return variant.optional ? value : required(run, depth);
+      }
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return reject(run, "invalid_type", "must be an object", pathOf(run, depth));
+      }
+      let { variants } = step;
+      if (variants === undefined) {
+        variants = new Map;
+        const declared = variant.variants;
+        for (const tag of Object.keys(declared)) {
+          const one = declared[tag];
+          variants.set(tag, isBlueprint(one) ? collectionOf(one.properties) : one);
+        }
+        step.variants = variants;
+      }
+      if (!isPlainObject(value)) {
+        for (const one of variants.values()) {
+          if (typeof one === "function" && value instanceof one)
+            return value;
+        }
+      }
+      const { key } = variant;
+      const tag = value[key];
+      const named = typeof tag === "string" ? variants.get(tag) : undefined;
+      if (named === undefined) {
+        return reject(run, "invalid_value", "must be equal to one of the allowed values", [...pathOf(run, depth), key]);
+      }
+      if (typeof named !== "function") {
+        return collectionAt(named, value, run, depth, undefined, key);
+      }
+      const { [key]: _name, ...input } = value;
+      const result = named.safeParse(input);
+      if (!result.issues)
+        return result.value;
+      const path = pathOf(run, depth);
+      run.issues ??= [];
+      for (const issue of result.issues) {
+        run.issues.push(movedIssue(issue, [...path, ...issue.path]));
+      }
+      return REJECTED;
+    }
+    case RECORD: {
+      const Record = step.record;
+      if (value === undefined) {
+        return step.optionalRecord ? value : required(run, depth);
+      }
+      if (value instanceof Record)
+        return value;
+      if (!isPlainObject(value)) {
+        return reject(run, "not_record", `must be an instance of record "${recordNameOf(Record)}"`, pathOf(run, depth));
+      }
+      const result = Record.safeParse(value);
+      if (!result.issues)
+        return result.value;
+      const path = pathOf(run, depth);
+      run.issues ??= [];
+      for (const issue of result.issues) {
+        run.issues.push(movedIssue(issue, [...path, ...issue.path]));
+      }
+      return REJECTED;
+    }
+    default:
+      return reject(run, "undeclared_key", "is not declared", pathOf(run, depth));
+  }
+}
+function required(run, depth) {
+  return reject(run, "required", "is required", pathOf(run, depth));
+}
+function propertyAt(step, value, run, depth) {
+  const property = step.property;
+  if (property.safeParse === DECLARED_SAFE_PARSE) {
+    let { parser } = step;
+    if (parser === undefined) {
+      parser = parserOf(parsingDefinitionOf(property)) ?? null;
+      step.parser = parser;
+    }
+    if (parser !== null) {
+      const handled = parser(value);
+      if (handled !== REJECTED)
+        return handled;
+      run.issues ??= [];
+      takeRejectionIssues(pathOf(run, depth), run.issues);
+      return REJECTED;
+    }
+  }
+  const result = property.safeParse(value);
+  if (!result.issues)
+    return result.value;
+  const path = pathOf(run, depth);
+  run.issues ??= [];
+  if (result.issues.some((issue) => Object.isFrozen(issue))) {
+    for (const issue of result.issues) {
+      run.issues.push(movedIssue(issue, [...path, ...issue.path]));
+    }
+  } else {
+    for (const issue of result.issues) {
+      issue.path = [...path, ...issue.path];
+      run.issues.push(issue);
+    }
+  }
+  return REJECTED;
+}

package/dist/core/parse/strip.js

@@ -0,0 +1,48 @@
+import { isBlueprint } from "../blueprint/is-blueprint.js";
+import { isBlueprintList } from "../blueprint/list.js";
+import { recordFieldOf } from "../blueprint/record-field.js";
+import { isBlueprintVariant, variantOfValue } from "../blueprint/variant.js";
+import { fieldsOf, isPlainObject } from "./parse.js";
+function collectionOf(properties, value) {
+  if (!isPlainObject(value))
+    return value;
+  const kept = {};
+  for (const [name, field] of fieldsOf(properties)) {
+    if (!Object.hasOwn(value, name))
+      continue;
+    const item = fieldOf(field, value[name]);
+    if (item === undefined)
+      continue;
+    Object.defineProperty(kept, name, {
+      value: item,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+  return kept;
+}
+function fieldOf(field, value) {
+  if (isBlueprintList(field)) {
+    return Array.isArray(value) ? value.map((item) => fieldOf(field.item, item)) : value;
+  }
+  if (isBlueprint(field))
+    return collectionOf(field.properties, value);
+  if (isBlueprintVariant(field)) {
+    const variant = variantOfValue(field, value);
+    if (!variant || !isPlainObject(value))
+      return value;
+    return {
+      [field.key]: value[field.key],
+      ...collectionOf(variant.properties, value)
+    };
+  }
+  const record = recordFieldOf(field);
+  if (record) {
+    return collectionOf(record.record.blueprint.properties, value);
+  }
+  return value;
+}
+export function stripUndeclared(shape, value) {
+  return fieldOf(shape, value);
+}

package/dist/core/property/abstract-property.js

@@ -0,0 +1,37 @@
+import { standardOfClass } from "../standard/standard.js";
+import { Demo } from "../symbols/demo.js";
+import { State } from "../symbols/state.js";
+import { refinePropertyOf } from "./refine.js";
+const parsingDefinitions = new WeakMap;
+export function parsingDefinitionOf(Class) {
+  let definition = parsingDefinitions.get(Class);
+  if (!definition) {
+    definition = Object.create(Class.prototype).createDefinition();
+    parsingDefinitions.set(Class, definition);
+  }
+  return definition;
+}
+
+export class AbstractProperty {
+  get [State]() {
+    return this.definition[State];
+  }
+  definition;
+  value;
+  constructor(value) {
+    this.definition = this.createDefinition();
+    this.value = this.definition.make(value === Demo ? this.definition.type[Demo] : value);
+  }
+  static demo() {
+    return new this(Demo);
+  }
+  static safeParse(value) {
+    return parsingDefinitionOf(this).parse(value);
+  }
+  static with(options) {
+    return refinePropertyOf(this, options);
+  }
+  static get "~standard"() {
+    return standardOfClass(this);
+  }
+}

package/dist/core/property/define-property.js

@@ -0,0 +1,209 @@
+import { Exception } from "../exception/exception.js";
+import { LazyIssue, REJECTED } from "../parse/issue.js";
+import {
+  checksOfSchema,
+  describeError,
+  errorsOfSchema
+} from "../schema/schema.js";
+import { State } from "../symbols/state.js";
+import { PropertyStates } from "./enums/property-states.js";
+import { InvalidPropertyValue, PropertyRequired } from "./exceptions.js";
+const MISMATCH = Symbol("mismatch");
+
+class Failure {
+  source;
+  raised;
+  errors;
+  cause;
+  constructor(source, raised, errors) {
+    this.source = source;
+    this.raised = raised;
+    this.errors = errors;
+    this.cause = raised;
+  }
+  exception() {
+    if (this.cause === undefined) {
+      const { source, errors } = this;
+      this.cause = errors ? new InvalidPropertyValue({
+        source,
+        details: { errors: errors.map(describeError) }
+      }) : new PropertyRequired({ source });
+    }
+    return this.cause;
+  }
+}
+let rejection;
+function reject(failure) {
+  rejection = failure;
+  return REJECTED;
+}
+function segmentsOf(pointer) {
+  return pointer.slice(1).split("/").map((segment) => {
+    const key = segment.replaceAll("~1", "/").replaceAll("~0", "~");
+    return /^(0|[1-9]\d*)$/.test(key) ? Number(key) : key;
+  });
+}
+function issueOf(failure, message, path, code) {
+  return new LazyIssue(message, path, code, failure.source, failure);
+}
+export function takeRejectionIssues(path, issues) {
+  const failure = rejection;
+  rejection = undefined;
+  const { raised, errors, source } = failure;
+  if (raised) {
+    issues.push({
+      message: raised.message,
+      path,
+      code: "invalid_value",
+      source,
+      cause: raised
+    });
+  } else if (!errors) {
+    issues.push(issueOf(failure, "is required", path, "required"));
+  } else if (errors.length === 0) {
+    issues.push(issueOf(failure, "is invalid", path, "invalid_value"));
+  } else {
+    for (const { message, instancePath } of errors) {
+      issues.push(issueOf(failure, message, instancePath === "" ? path : [...path, ...segmentsOf(instancePath)], "invalid_value"));
+    }
+  }
+}
+
+export class AbstractDefineProperty {
+  [State] = PropertyStates.Declared;
+  make(value) {
+    const handled = this.attempt(value);
+    if (handled !== REJECTED)
+      return handled;
+    const failure = rejection;
+    rejection = undefined;
+    throw failure.exception();
+  }
+  parse(value) {
+    const handled = this.attemptWithoutThrowing(value);
+    if (handled !== REJECTED)
+      return { value: handled };
+    const issues = [];
+    takeRejectionIssues([], issues);
+    return { issues };
+  }
+  preHandle(value) {
+    return value;
+  }
+  afterHandle(value) {
+    return value;
+  }
+  handle(value) {
+    return this.type.schema.match(value) ? value : MISMATCH;
+  }
+  attemptWithoutThrowing(value) {
+    try {
+      return this.attempt(value);
+    } catch (error) {
+      return this.raise(error instanceof Exception ? error : this.invalidValue(error));
+    }
+  }
+  attempt(value) {
+    const { name, optional, schema } = this.type;
+    this[State] = PropertyStates.Declared;
+    if (value === undefined) {
+      if (!optional)
+        return reject(new Failure(name, undefined, undefined));
+      this[State] = PropertyStates.Done;
+      return value;
+    }
+    const preHandles = this.preHandle !== PASS.preHandle;
+    const handles = this.handle !== PASS.handle;
+    if ((preHandles || handles) && !schema.matchShape(value)) {
+      return this.mismatch(value);
+    }
+    try {
+      if (preHandles) {
+        this[State] = PropertyStates.PreHandling;
+        value = this.runHandler(this.preHandle, value);
+      }
+      this[State] = PropertyStates.Handling;
+      if (handles) {
+        const handled = this.handle(value);
+        if (handled === MISMATCH)
+          return this.mismatch(value);
+        value = handled;
+      } else if (!schema.match(value)) {
+        if (!preHandles && !schema.matchShape(value)) {
+          this[State] = PropertyStates.Declared;
+        }
+        return this.mismatch(value);
+      }
+      if (this.afterHandle !== PASS.afterHandle) {
+        this[State] = PropertyStates.AfterHandling;
+        value = this.runHandler(this.afterHandle, value);
+      }
+    } catch (error) {
+      if (error instanceof Exception)
+        return this.raise(error);
+      throw error;
+    }
+    this[State] = PropertyStates.Done;
+    return value;
+  }
+  runHandler(handler, value) {
+    try {
+      return handler.call(this, value);
+    } catch (error) {
+      if (error instanceof Exception)
+        throw error;
+      throw this.invalidValue(error);
+    }
+  }
+  invalidValue(error) {
+    return new InvalidPropertyValue({
+      source: this.type.name,
+      details: {
+        errors: [error instanceof Error ? error.message : String(error)]
+      },
+      cause: error
+    });
+  }
+  raise(exception) {
+    return reject(new Failure(this.type.name, exception, undefined));
+  }
+  mismatch(value) {
+    const { name, schema } = this.type;
+    return reject(new Failure(name, undefined, errorsOfSchema(schema, value)));
+  }
+}
+const PASS = AbstractDefineProperty.prototype;
+const declared = new WeakSet;
+export function declarePipeline(prototype) {
+  declared.add(prototype);
+}
+export function parserOf(definition) {
+  const pipeline = definition;
+  if (pipeline.parse !== AbstractDefineProperty.prototype.parse) {
+    return;
+  }
+  if (!declared.has(Object.getPrototypeOf(definition)) || pipeline.handle !== PASS.handle || Object.hasOwn(definition, "preHandle") || Object.hasOwn(definition, "afterHandle")) {
+    return (value) => pipeline.attemptWithoutThrowing(value);
+  }
+  const { name, optional, schema } = pipeline.type;
+  const { match, matchShape } = checksOfSchema(schema);
+  const preHandle = pipeline.preHandle === PASS.preHandle ? undefined : pipeline.preHandle;
+  const afterHandle = pipeline.afterHandle === PASS.afterHandle ? undefined : pipeline.afterHandle;
+  return (value) => {
+    if (value === undefined) {
+      return optional ? value : reject(new Failure(name, undefined, undefined));
+    }
+    try {
+      if (preHandle !== undefined) {
+        if (!matchShape(value))
+          return pipeline.mismatch(value);
+        value = preHandle.call(pipeline, value);
+      }
+      if (!match(value))
+        return pipeline.mismatch(value);
+      return afterHandle === undefined ? value : afterHandle.call(pipeline, value);
+    } catch (error) {
+      return pipeline.raise(error instanceof Exception ? error : pipeline.invalidValue(error));
+    }
+  };
+}

package/dist/core/property/enums/property-states.js

@@ -0,0 +1,8 @@
+export var PropertyStates;
+((PropertyStates) => {
+  PropertyStates[PropertyStates["Declared"] = 0] = "Declared";
+  PropertyStates[PropertyStates["PreHandling"] = 1] = "PreHandling";
+  PropertyStates[PropertyStates["Handling"] = 2] = "Handling";
+  PropertyStates[PropertyStates["AfterHandling"] = 3] = "AfterHandling";
+  PropertyStates[PropertyStates["Done"] = 4] = "Done";
+})(PropertyStates ||= {});

package/dist/core/property/exceptions.js

@@ -0,0 +1,12 @@
+import { ExceptionLayers } from "../exception/enums/exception-layers.js";
+import { exceptionOf } from "../exception/exception.js";
+export const PropertyRequired = exceptionOf({
+  layer: ExceptionLayers.Property,
+  name: "PropertyRequired",
+  message: (_, source) => `Property "${source}" is required.`
+});
+export const InvalidPropertyValue = exceptionOf({
+  layer: ExceptionLayers.Property,
+  name: "InvalidPropertyValue",
+  message: ({ errors }, source) => `Invalid value for property "${source}": ${errors.join("; ")}`
+});

package/dist/core/property/input.js

@@ -0,0 +1,10 @@
+import { fieldOf } from "../blueprint/callable.js";
+import { isProperty } from "./is-property.js";
+export const PropertyInput = Symbol("propertyInput");
+export function propertyInputOf(field) {
+  const property = fieldOf(field);
+  if (!isProperty(property))
+    return;
+  const declared = property[PropertyInput];
+  return typeof declared === "object" && declared !== null && isProperty(declared.accepts) && typeof declared.convert === "function" ? declared : undefined;
+}

package/dist/core/property/is-property.js

@@ -0,0 +1,3 @@
+export function isProperty(value) {
+  return typeof value === "function" && typeof value.type === "object";
+}

package/dist/core/property/lineage.js

@@ -0,0 +1,8 @@
+const lineages = new WeakMap;
+export function recordPropertyLineage(Property, lineage) {
+  if (!lineages.has(Property))
+    lineages.set(Property, lineage);
+}
+export function propertyLineageOf(Property) {
+  return typeof Property === "function" ? lineages.get(Property) : undefined;
+}

package/dist/core/property/property.d.ts

@@ -53,5 +53,32 @@ export interface PropertyClass<SchemaType extends TSchema, Value = Static<Schema
     with<Self extends AnyPropertyConstructor>(this: Self, options: PropertyOptions<SchemaType, Value>): Self;
     demo<Self extends AbstractProperty<any>>(this: new (value: never) => Self): Self;
 }
+/**
+ * Declares a property: a class that holds one value, run through
+ * `preHandle`, the validation against the TypeBox `schema` and
+ * `afterHandle`. `optional`, `sensitive` and `unique` flag it for the
+ * blueprints and records that hold it, and `default` is its `demo()` value.
+ * Extend the class to add behavior, or narrow it with `.with(options)`. A
+ * value its schema rejects makes the constructor throw
+ * {@link InvalidPropertyValue}, and `undefined` for a required one
+ * {@link PropertyRequired}.
+ *
+ * @example
+ * ```ts
+ * import { propertyOf } from "@afora/core";
+ * import { Type } from "typebox";
+ *
+ * const Name = propertyOf({
+ * 	name: "name",
+ * 	schema: Type.String({ minLength: 3 }),
+ * 	preHandle: (value) => value.trim(),
+ * 	default: "Jane", // used by Name.demo()
+ * });
+ *
+ * new Name("  Alice ").value; // "Alice"
+ * Name.demo().value; // "Jane"
+ * // new Name("a") throws InvalidPropertyValue
+ * ```
+ */
 export declare function propertyOf<SchemaType extends TSchema, Optional extends boolean = false, const Unique extends boolean = false, const Sensitive extends boolean = false>({ name, schema, optional, sensitive, unique, default: _default, preHandle: onPreHandle, afterHandle: onAfterHandle, }: PropertyOfArgs<SchemaType, Optional, Unique, Sensitive>): PropertyClass<SchemaValueType<SchemaType, Optional>, Static<SchemaType>> & UniqueMark<Unique> & SensitiveMark<Sensitive>;
 export {};