typeomatica 0.3.39 → 0.3.57

package/README.md

@@ -1,4 +1,4 @@
-# Type ø matica
+# TypeØmatica
 
 [![Coverage Status](https://coveralls.io/repos/github/wentout/typeomatica/badge.svg?branch=main)](https://coveralls.io/github/wentout/typeomatica?branch=main)
 
@@ -8,37 +8,383 @@
 
 [**$ npm install <u>typeomatica</u>**](https://www.npmjs.com/package/typeomatica)
 
-
 This package is a part of [mnemonica](https://www.npmjs.com/package/mnemonica) project.
 
-Strict Types checker for objects which represent Data Types.
+**Strict Runtime Type Checker for JavaScript Objects**
+
+TypeØmatica uses JavaScript Proxies to enforce type safety at runtime, exactly as TypeScript expects at compile time. Once a property is assigned a value, its type is locked and cannot be changed.
+
+---
+
+## Quick Start
+
+```typescript
+import { BaseClass } from 'typeomatica';
+
+class User extends BaseClass {
+  name: string = 'default';
+  age: number = 0;
+}
+
+const user = new User();
+
+// ✓ Valid assignments
+user.name = 'John';
+user.age = 25;
+
+// ✗ Runtime error (even if TypeScript is bypassed with @ts-ignore)
+user.age = '25';  // TypeError: Type Mismatch
+```
+
+---
+
+## Table of Contents
+
+- [What is TypeØmatica?](#what-is-typeomatica)
+- [Installation](#installation)
+- [Core Concepts](#core-concepts)
+- [API Reference](#api-reference)
+- [Usage Patterns](#usage-patterns)
+- [Type Examples](#type-examples)
+- [Working with Wrapped Values](#working-with-wrapped-values)
+- [Error Reference](#error-reference)
+- [Integration with Mnemonica](#integration-with-mnemonica)
+
+---
+
+## What is TypeØmatica?
+
+TypeØmatica provides strict runtime type checking for JavaScript objects using Proxy-based interception. It ensures that once a property is initialized with a type, that type cannot be violated at runtime.
+
+**Key Features:**
+- Runtime type enforcement (complements TypeScript's compile-time checks)
+- Proxy-based property interception
+- Type locking after initial assignment
+- Prevents prototype mutation, property redefinition, and deletion
+
+---
+
+## Installation
+
+```bash
+npm install typeomatica
+```
+
+---
+
+## Core Concepts
+
+### How It Works
+
+TypeØmatica wraps objects with JavaScript Proxies that intercept:
+- `get` - Property reads
+- `set` - Property writes (with type validation)
+- `setPrototypeOf` - Blocks prototype changes
+- `defineProperty` - Blocks property redefinition
+- `deleteProperty` - Blocks property deletion
+
+### Type Categories
+
+| Category | Types | Behavior |
+|----------|-------|----------|
+| `primitives` | string, number, boolean, bigint, symbol, undefined | Type-locked accessors |
+| `nullish` | null | Only null allowed |
+| `objects` | object, arrays, dates | Same constructor type required |
+| `functions` | methods | Restricted on data types |
+
+---
+
+## API Reference
+
+### BaseClass
+
+The primary class for strict-type objects.
+
+```typescript
+import { BaseClass } from 'typeomatica';
+
+class MyClass extends BaseClass {
+  field: string = 'value';
+  constructor() {
+    super();
+  }
+}
+```
+
+### BasePrototype
+
+Functional equivalent of `BaseClass`.
+
+```typescript
+import { BasePrototype } from 'typeomatica';
+
+const Base = BasePrototype({ initialProp: 123 });
+class MyClass extends Base { }
+```
+
+### @Strict() Decorator
+
+Apply strict typing without extending BaseClass.
+
+```typescript
+import { Strict } from 'typeomatica';
+
+@Strict({ deep: true })
+class MyClass {
+  field: number = 0;
+}
+```
+
+**Decorator Arguments:**
+- First argument: Base prototype or options object
+- Second argument: Options object
+
+### Options Interface
+
+```typescript
+interface TypeomaticaOptions {
+  strictAccessCheck?: boolean;  // default: false
+}
+```
+
+**Options:**
+- `strictAccessCheck: true` - Enables strict receiver checking (throws `ACCESS_DENIED` error when property is accessed from wrong context)
+- `deep: true` - Enable recursive property checking (when using BasePrototype with initial values)
+
+### Usage with Options
+
+```typescript
+// With BaseClass - strict access checking enabled
+class SecureData extends BaseClass {
+  secret: string = '';
+  constructor() {
+    super(undefined, { strictAccessCheck: true });
+  }
+}
+
+// With BasePrototype - strict access checking enabled
+const SecureBase = BasePrototype({ data: '' }, { strictAccessCheck: true });
+class User extends SecureBase {
+  name: string = '';
+}
+
+// With @Strict decorator - strict access checking enabled
+@Strict(undefined, { strictAccessCheck: true })
+class Product {
+  price: number = 0;
+}
+```
+
+### Symbol Exports
+
+```typescript
+import { 
+  SymbolTypeomaticaProxyReference,  // Access proxy internals
+  SymbolInitialValue                 // Access original values
+} from 'typeomatica';
+```
+
+---
 
-# how it works
+## Usage Patterns
 
-see `test/index.ts`
+### Pattern 1: Extending BaseClass
 
-```js
+```typescript
+import { BaseClass } from 'typeomatica';
 
-class SimpleBase extends BasePrototype {
-	stringProp = '123';
-};
+class User extends BaseClass {
+  name: string = '';
+  age: number = 0;
+  active: boolean = true;
+}
 
-// nect code line will work properly
-simpleInstance.stringProp = '321';
+const user = new User();
+user.name = 'John';     // ✓ Works
+user.age = 25;          // ✓ Works
 
-// but next code line will throw TypeError('Type Mismatch')
 // @ts-ignore
-simpleInstance.stringProp = 123;
+user.age = '25';        // ✗ TypeError: Type Mismatch
+```
+
+### Pattern 2: @Strict Decorator
+
+```typescript
+import { Strict } from 'typeomatica';
+
+@Strict({ deep: true })
+class Product {
+  id: number = 0;
+  title: string = '';
+  price: number = 0;
+}
 
+const product = new Product();
+product.price = 29.99;      // ✓ Works
+// @ts-ignore
+product.price = '$29.99';   // ✗ TypeError: Type Mismatch
 ```
 
-That is it. It will be impossible to assign anything else except of:
+### Pattern 3: BaseClass as Prototype
+
+```typescript
+import { BaseClass } from 'typeomatica';
+
+class UserData {
+  name: string = 'default';
+  age: number = 0;
+}
+
+// Inject type checking into prototype chain
+Object.setPrototypeOf(UserData.prototype, new BaseClass({ deep: true }));
 
-```js 
-typeof something === 'string'
+const user = new UserData();
+user.name = 'John';     // ✓ Works
+// @ts-ignore
+user.name = 123;        // ✗ TypeError: Type Mismatch
 ```
 
-to `stringProp` in runtime.
+---
+
+## Type Examples
+
+### Primitives
+
+```typescript
+import { BaseClass } from 'typeomatica';
+
+class Primitives extends BaseClass {
+  str: string = 'hello';
+  num: number = 42;
+  bool: boolean = true;
+  bigint: bigint = BigInt(100);
+}
+
+const p = new Primitives();
+p.str = 'world';          // ✓ Works
+p.num = 100;              // ✓ Works
+// @ts-ignore
+p.str = 123;              // ✗ TypeError: Type Mismatch
+```
+
+### Null and Undefined
+
+```typescript
+class Nullable extends BaseClass {
+  nullValue: null = null;
+  undefinedValue: undefined = undefined;
+}
+
+const n = new Nullable();
+n.nullValue = null;              // ✓ Works
+// @ts-ignore
+n.nullValue = undefined;         // ✗ TypeError: Type Mismatch
+```
+
+### Objects
+
+```typescript
+class WithObject extends BaseClass {
+  data: object = {};
+  list: number[] = [];
+}
+
+const w = new WithObject();
+w.data = { a: 1 };              // ✓ Works
+w.list = [1, 2, 3];             // ✓ Works
+// @ts-ignore
+w.data = 123;                   // ✗ TypeError: Type Mismatch
+// @ts-ignore
+w.data = new Set();             // ✗ TypeError: Type Mismatch (Set !== Object)
+```
+
+---
+
+## Working with Wrapped Values
+
+TypeØmatica wraps primitives to enforce type safety. Use `valueOf()` for operations.
+
+### Numeric Operations
+
+```typescript
+class Calc extends BaseClass {
+  count: number = 10;
+}
+
+const calc = new Calc();
+
+// ✗ Direct arithmetic throws
+const result = calc.count + 5;  // ReferenceError: Value Access Denied
+
+// ✓ Use valueOf()
+const result = calc.count.valueOf() + 5;  // 15
+const sum = 3 + +calc.count;               // 13
+```
+
+### String Operations
+
+```typescript
+class Text extends BaseClass {
+  message: string = 'hello';
+}
+
+const text = new Text();
+text.message.valueOf().toUpperCase();  // 'HELLO'
+text.message.valueOf().length;         // 5
+```
+
+---
+
+## Error Reference
+
+| Error Message | Error Type | When Thrown |
+|---------------|------------|-------------|
+| `Type Mismatch` | TypeError | Wrong type assigned to property |
+| `Value Access Denied` | ReferenceError | Property accessed from wrong context (only when `strictAccessCheck: true`) |
+| `Attempt to Access to Undefined Prop` | Error | Reading non-existent property |
+| `Functions are Restricted` | TypeError | Function assigned to data property |
+| `Re-Assirnment is Forbidden` | TypeError | Modifying read-only custom field |
+| `Setting prototype is not allowed` | Error | Calling `Object.setPrototypeOf()` |
+| `Defining new Properties is not allowed` | Error | Calling `Object.defineProperty()` |
+| `Properties Deletion is not allowed` | Error | Calling `delete` on property |
+
+---
+
+## Integration with Mnemonica
+
+TypeØmatica integrates seamlessly with [mnemonica](https://www.npmjs.com/package/mnemonica) for combined prototype inheritance and runtime type safety.
+
+```typescript
+import { decorate } from 'mnemonica';
+import { BaseClass, Strict } from 'typeomatica';
+
+@decorate()
+@Strict()
+class Entity extends BaseClass {
+  id: string = '';
+  createdAt: Date = new Date();
+}
+
+// Works with mnemonica's inheritance system
+const User = Entity.define('User', function(this: { email: string }) {
+  this.email = '';
+});
+
+const user = new User();
+// @ts-ignore
+user.email = 123;  // ✗ TypeError: Type Mismatch
+```
+
+**Decorator Order Matters:**
+- `@Strict()` must come AFTER `@decorate()` (inner decorator)
+- Decorators apply bottom-to-top
+
+For complete integration documentation, see [mnemonica's TypeØmatica guide](https://github.com/wentout/mnemonica/blob/main/core/TypeØmatica.md).
+
+---
+
+## License
+
+MIT
 
-As we describe Data Types &mdash; please take a peek for tests directory:
-[HERE](https://github.com/wentout/typeomatica/blob/main/test/index.ts).
+Copyright (c) 2019-2024 https://github.com/wentout

package/lib/errors.js

@@ -1,11 +1,11 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorsNames = void 0;
 exports.ErrorsNames = {
-	TYPE_MISMATCH: 'Type Mismatch',
-	ACCESS_DENIED: 'Value Access Denied',
-	MISSING_PROP: 'Attempt to Access to Undefined Prop',
-	RIP_FUNCTIONS: 'Functions are Restricted',
-	FORBIDDEN_RE: 'Re-Assirnment is Forbidden'
+    TYPE_MISMATCH: 'Type Mismatch',
+    ACCESS_DENIED: 'Value Access Denied',
+    MISSING_PROP: 'Attempt to Access to Undefined Prop',
+    RIP_FUNCTIONS: 'Functions are Restricted',
+    FORBIDDEN_RE: 'Re-Assirnment is Forbidden'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7OztBQUVBLFFBQUEsV0FBVyxHQUFHO0lBQzFCLGFBQWEsRUFBRSxlQUFlO0lBQzlCLGFBQWEsRUFBRSxxQkFBcUI7SUFDcEMsWUFBWSxFQUFFLHFDQUFxQztJQUNuRCxhQUFhLEVBQUUsMEJBQTBCO0lBQ3pDLFlBQVksRUFBRSw0QkFBNEI7Q0FDMUMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7OztBQUVBLFFBQUEsV0FBVyxHQUFHO0lBQzFCLGFBQWEsRUFBRSxlQUFlO0lBQzlCLGFBQWEsRUFBRSxxQkFBcUI7SUFDcEMsWUFBWSxFQUFFLHFDQUFxQztJQUNuRCxhQUFhLEVBQUUsMEJBQTBCO0lBQ3pDLFlBQVksRUFBRSw0QkFBNEI7Q0FDMUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIid1c2Ugc3RyaWN0JztcblxuZXhwb3J0IGNvbnN0IEVycm9yc05hbWVzID0ge1xuXHRUWVBFX01JU01BVENIOiAnVHlwZSBNaXNtYXRjaCcsXG5cdEFDQ0VTU19ERU5JRUQ6ICdWYWx1ZSBBY2Nlc3MgRGVuaWVkJyxcblx0TUlTU0lOR19QUk9QOiAnQXR0ZW1wdCB0byBBY2Nlc3MgdG8gVW5kZWZpbmVkIFByb3AnLFxuXHRSSVBfRlVOQ1RJT05TOiAnRnVuY3Rpb25zIGFyZSBSZXN0cmljdGVkJyxcblx0Rk9SQklEREVOX1JFOiAnUmUtQXNzaXJubWVudCBpcyBGb3JiaWRkZW4nXG59OyJdfQ==

package/lib/fields.d.ts

@@ -3,10 +3,10 @@ interface FieldDefinition {
     [SymbolInitialValue]: unknown;
 }
 export declare class FieldConstructor implements FieldDefinition {
-	[SymbolInitialValue]: unknown;
-	get get(): () => unknown;
-	get set(): () => never;
-	constructor(value: unknown);
-	static get SymbolInitialValue(): symbol;
+    [SymbolInitialValue]: unknown;
+    get get(): () => unknown;
+    get set(): () => never;
+    constructor(value: unknown);
+    static get SymbolInitialValue(): symbol;
 }
 export {};

package/lib/fields.js

@@ -1,28 +1,29 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.FieldConstructor = void 0;
-const errors_1 = require('./errors');
+const errors_1 = require("./errors");
 const SymbolInitialValue = Symbol('Initial Value');
 class FieldConstructor {
-	get get() {
-		const self = this;
-		return function () {
-			return self[SymbolInitialValue];
-		};
-	}
-	get set() {
-		return function () {
-			throw new TypeError(errors_1.ErrorsNames.FORBIDDEN_RE);
-		};
-	}
-	constructor(value) {
-		this[SymbolInitialValue] = value;
-	}
-	static get SymbolInitialValue() {
-		return SymbolInitialValue;
-	}
+    [SymbolInitialValue];
+    get get() {
+        const self = this;
+        return function () {
+            return self[SymbolInitialValue];
+        };
+    }
+    get set() {
+        return function () {
+            throw new TypeError(errors_1.ErrorsNames.FORBIDDEN_RE);
+        };
+    }
+    constructor(value) {
+        this[SymbolInitialValue] = value;
+    }
+    static get SymbolInitialValue() {
+        return SymbolInitialValue;
+    }
 }
 exports.FieldConstructor = FieldConstructor;
 Object.freeze(FieldConstructor.prototype);
 Object.seal(FieldConstructor.prototype);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2ZpZWxkcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7OztBQUViLHFDQUF1QztBQUV2QyxNQUFNLGtCQUFrQixHQUFHLE1BQU0sQ0FBQyxlQUFlLENBQUMsQ0FBQztBQWVuRCxNQUFhLGdCQUFnQjtJQUU1QixJQUFXLEdBQUc7UUFDYixNQUFNLElBQUksR0FBRyxJQUFJLENBQUM7UUFDbEIsT0FBTztZQUNOLE9BQU8sSUFBSSxDQUFDLGtCQUFrQixDQUFDLENBQUM7UUFDakMsQ0FBQyxDQUFDO0lBQ0gsQ0FBQztJQUNELElBQVcsR0FBRztRQUNiLE9BQU87WUFDTixNQUFNLElBQUksU0FBUyxDQUFDLG9CQUFXLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDL0MsQ0FBQyxDQUFDO0lBQ0gsQ0FBQztJQUNELFlBQWEsS0FBYztRQUMxQixJQUFJLENBQUMsa0JBQWtCLENBQUMsR0FBRyxLQUFLLENBQUM7SUFDbEMsQ0FBQztJQUNELE1BQU0sS0FBSyxrQkFBa0I7UUFDNUIsT0FBTyxrQkFBa0IsQ0FBQztJQUMzQixDQUFDO0NBQ0Q7QUFuQkQsNENBbUJDO0FBb0NELE1BQU0sQ0FBQyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsU0FBUyxDQUFDLENBQUM7QUFDMUMsTUFBTSxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxTQUFTLENBQUMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2ZpZWxkcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7OztBQUViLHFDQUF1QztBQUV2QyxNQUFNLGtCQUFrQixHQUFHLE1BQU0sQ0FBQyxlQUFlLENBQUMsQ0FBQztBQWVuRCxNQUFhLGdCQUFnQjtJQUM1QixDQUFDLGtCQUFrQixDQUFDLENBQVU7SUFDOUIsSUFBVyxHQUFHO1FBQ2IsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQ2xCLE9BQU87WUFDTixPQUFPLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO1FBQ2pDLENBQUMsQ0FBQztJQUNILENBQUM7SUFDRCxJQUFXLEdBQUc7UUFDYixPQUFPO1lBQ04sTUFBTSxJQUFJLFNBQVMsQ0FBQyxvQkFBVyxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQy9DLENBQUMsQ0FBQztJQUNILENBQUM7SUFDRCxZQUFhLEtBQWM7UUFDMUIsSUFBSSxDQUFDLGtCQUFrQixDQUFDLEdBQUcsS0FBSyxDQUFDO0lBQ2xDLENBQUM7SUFDRCxNQUFNLEtBQUssa0JBQWtCO1FBQzVCLE9BQU8sa0JBQWtCLENBQUM7SUFDM0IsQ0FBQztDQUNEO0FBbkJELDRDQW1CQztBQW9DRCxNQUFNLENBQUMsTUFBTSxDQUFDLGdCQUFnQixDQUFDLFNBQVMsQ0FBQyxDQUFDO0FBQzFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsU0FBUyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIHN0cmljdCc7XG5cbmltcG9ydCB7IEVycm9yc05hbWVzIH0gZnJvbSAnLi9lcnJvcnMnO1xuXG5jb25zdCBTeW1ib2xJbml0aWFsVmFsdWUgPSBTeW1ib2woJ0luaXRpYWwgVmFsdWUnKTtcblxuaW50ZXJmYWNlIEZpZWxkRGVmaW5pdGlvbiAge1xuXHRbU3ltYm9sSW5pdGlhbFZhbHVlXTogdW5rbm93blxuXHQvLyBnZXQ/OiB1bmtub3duXG5cdC8vIHNldD86IHVua25vd25cblx0Ly8gY29uZmlndXJhYmxlOiBib29sZWFuLFxuXHQvLyBlbnVtZXJhYmxlOiBib29sZWFuLFxuXHQvLyB3cml0YWJsZTogYm9vbGVhblxufVxuXG4vLyBleHBvcnQgY29uc3QgRmllbGRDb25zdHJ1Y3RvciA9IGZ1bmN0aW9uICh0aGlzOiBGaWVsZERlZmluaXRpb24sIHZhbHVlOiB1bmtub3duKSB7XG4vLyBcdHRoaXNbU3ltYm9sSW5pdGlhbFZhbHVlXSA9IHZhbHVlO1xuLy8gfSBhcyBPYmplY3RDb25zdHJ1Y3RvcjtcblxuZXhwb3J0IGNsYXNzIEZpZWxkQ29uc3RydWN0b3IgaW1wbGVtZW50cyBGaWVsZERlZmluaXRpb24ge1xuXHRbU3ltYm9sSW5pdGlhbFZhbHVlXTogdW5rbm93bjtcblx0cHVibGljIGdldCBnZXQgKCkge1xuXHRcdGNvbnN0IHNlbGYgPSB0aGlzO1xuXHRcdHJldHVybiBmdW5jdGlvbiAoLyogdGhpczogRmllbGREZWZpbml0aW9uICovKSB7XG5cdFx0XHRyZXR1cm4gc2VsZltTeW1ib2xJbml0aWFsVmFsdWVdO1xuXHRcdH07XG5cdH1cblx0cHVibGljIGdldCBzZXQgKCkge1xuXHRcdHJldHVybiBmdW5jdGlvbiAoKSB7XG5cdFx0XHR0aHJvdyBuZXcgVHlwZUVycm9yKEVycm9yc05hbWVzLkZPUkJJRERFTl9SRSk7XG5cdFx0fTtcblx0fVxuXHRjb25zdHJ1Y3RvciAodmFsdWU6IHVua25vd24pIHtcblx0XHR0aGlzW1N5bWJvbEluaXRpYWxWYWx1ZV0gPSB2YWx1ZTtcblx0fVxuXHRzdGF0aWMgZ2V0IFN5bWJvbEluaXRpYWxWYWx1ZSAoKSB7XG5cdFx0cmV0dXJuIFN5bWJvbEluaXRpYWxWYWx1ZTtcblx0fVxufVxuXG4vLyBPYmplY3QuYXNzaWduKEZpZWxkQ29uc3RydWN0b3IucHJvdG90eXBlLCB7XG4vLyBcdGNvbmZpZ3VyYWJsZTogZmFsc2UsXG4vLyBcdGVudW1lcmFibGU6IGZhbHNlLFxuLy8gXHQvLyB3cml0YWJsZTogZmFsc2Vcbi8vIH0pXG5cbi8vIE9iamVjdC5kZWZpbmVQcm9wZXJ0eShGaWVsZENvbnN0cnVjdG9yLnByb3RvdHlwZSwgJ2dldCcsIHtcbi8vIFx0Z2V0KCkge1xuLy8gXHRcdHJldHVybiB0aGlzW3N5bWJvbFZhbHVlXTtcbi8vIFx0fSxcbi8vIFx0Ly8gQHRzLWlnbm9yZVxuLy8gXHRzZXQodmFsdWU6IHVua25vd24pIHtcbi8vIFx0XHR0aHJvdyBuZXcgRXJyb3IoJ2Jyb2tlbiBiZWhhdmlvdXI6IGFzc2lnbm1lbnQgdG8gZ2V0dGVyJyk7XG4vLyBcdH0sXG4vLyBcdGNvbmZpZ3VyYWJsZTogZmFsc2UsXG4vLyBcdGVudW1lcmFibGU6IHRydWUsXG4vLyBcdC8vIHdyaXRhYmxlOiBmYWxzZVxuLy8gfSk7XG5cbi8vIE9iamVjdC5kZWZpbmVQcm9wZXJ0eShGaWVsZENvbnN0cnVjdG9yLnByb3RvdHlwZSwgJ3NldCcsIHtcbi8vIFx0Z2V0KCkge1xuLy8gXHRcdHJldHVybiBmdW5jdGlvbiAodGhpczogRmllbGREZWZpbml0aW9uLCB2YWx1ZTogdW5rbm93bikge1xuLy8gXHRcdFx0dGhpc1tzeW1ib2xWYWx1ZV0gPSB2YWx1ZTtcbi8vIFx0XHR9XG4vLyBcdH0sXG4vLyBcdC8vIEB0cy1pZ25vcmVcbi8vIFx0c2V0KHZhbHVlOiB1bmtub3duKSB7XG4vLyBcdFx0dGhyb3cgbmV3IEVycm9yKCdicm9rZW4gYmVoYXZpb3VyOiBhc3NpZ25tZW50IHRvIHNldHRlcicpO1xuLy8gXHR9LFxuLy8gXHRjb25maWd1cmFibGU6IGZhbHNlLFxuLy8gXHRlbnVtZXJhYmxlOiB0cnVlLFxuLy8gXHQvLyB3cml0YWJsZTogZmFsc2Vcbi8vIH0pO1xuXG5PYmplY3QuZnJlZXplKEZpZWxkQ29uc3RydWN0b3IucHJvdG90eXBlKTtcbk9iamVjdC5zZWFsKEZpZWxkQ29uc3RydWN0b3IucHJvdG90eXBlKTtcbiJdfQ==

package/lib/index.d.ts

@@ -1,12 +1,14 @@
+export interface TypeomaticaOptions {
+    strictAccessCheck?: boolean;
+}
+export declare const baseTarget: (_proto?: object) => any;
+export declare const SymbolTypeomaticaProxyReference: unique symbol;
 export declare const BaseConstructorPrototype: {
-    new (): unknown;
-    (): void;
+    new <T extends object | {}>(_target?: T, options?: TypeomaticaOptions): T;
+    <T extends object | {}, S extends T>(_target?: S extends infer S_1 ? S_1 : {}, options?: TypeomaticaOptions): S;
 };
-export declare class BaseClass extends BaseConstructorPrototype {
+export declare class BaseClass {
+    constructor(_target?: object, options?: TypeomaticaOptions);
 }
-export { FieldConstructor } from './fields';
 export declare const SymbolInitialValue: symbol;
-type StrictRuntime = {
-    <T extends object>(...args: unknown[]): T;
-};
-export declare const Strict: StrictRuntime;
+export declare const Strict: (_target?: object, options?: TypeomaticaOptions) => <T>(cstr: T) => T;