@sinclair/typebox 0.27.7 → 0.28.0

package/typebox.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.TemplateLiteralGenerator = exports.TemplateLiteralFinite = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.KeyResolver = exports.ObjectMap = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Modifier = void 0;
+exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.TemplateLiteralGenerator = exports.TemplateLiteralFinite = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.KeyArrayResolver = exports.KeyResolver = exports.ObjectMap = exports.IndexedAccessor = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Modifier = void 0;
 // --------------------------------------------------------------------------
 // Symbols
 // --------------------------------------------------------------------------
@@ -142,6 +142,9 @@ var TypeGuard;
         }
         return true;
     }
+    function IsAdditionalProperties(value) {
+        return IsOptionalBoolean(value) || TSchema(value);
+    }
     function IsBigInt(value) {
         return typeof value === 'bigint';
     }
@@ -306,16 +309,29 @@ var TypeGuard;
         return IsObject(schema) && exports.Kind in schema && typeof schema[exports.Kind] === 'string'; // TS 4.1.5: any required for symbol indexer
     }
     TypeGuard.TKind = TKind;
+    /** Returns true if the given schema is TLiteral<string> */
+    function TLiteralString(schema) {
+        return TKind(schema) && schema[exports.Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'string';
+    }
+    TypeGuard.TLiteralString = TLiteralString;
+    /** Returns true if the given schema is TLiteral<number> */
+    function TLiteralNumber(schema) {
+        return TKind(schema) && schema[exports.Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'number';
+    }
+    TypeGuard.TLiteralNumber = TLiteralNumber;
+    /** Returns true if the given schema is TLiteral<boolean> */
+    function TLiteralBoolean(schema) {
+        return TKind(schema) && schema[exports.Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'boolean';
+    }
+    TypeGuard.TLiteralBoolean = TLiteralBoolean;
+    /** Returns true if the given schema is TUnion<Literal<string>[]> */
+    function TLiteralUnion(schema) {
+        return TUnion(schema) && schema.anyOf.every((schema) => TLiteral(schema));
+    }
+    TypeGuard.TLiteralUnion = TLiteralUnion;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Literal' &&
-            IsOptionalString(schema.$id) &&
-            (IsString(schema.const) ||
-                IsNumber(schema.const) ||
-                IsBoolean(schema.const) ||
-                IsBigInt(schema.const)));
+        return TLiteralString(schema) || TLiteralNumber(schema) || TLiteralBoolean(schema);
     }
     TypeGuard.TLiteral = TLiteral;
     /** Returns true if the given schema is TNever */
@@ -364,7 +380,7 @@ var TypeGuard;
             schema.type === 'object' &&
             IsOptionalString(schema.$id) &&
             IsObject(schema.properties) &&
-            (IsOptionalBoolean(schema.additionalProperties) || IsOptionalSchema(schema.additionalProperties)) &&
+            IsAdditionalProperties(schema.additionalProperties) &&
             IsOptionalNumber(schema.minProperties) &&
             IsOptionalNumber(schema.maxProperties))) {
             return false;
@@ -396,7 +412,7 @@ var TypeGuard;
             schema[exports.Kind] === 'Record' &&
             schema.type === 'object' &&
             IsOptionalString(schema.$id) &&
-            schema.additionalProperties === false &&
+            IsAdditionalProperties(schema.additionalProperties) &&
             IsObject(schema.patternProperties))) {
             return false;
         }
@@ -515,11 +531,6 @@ var TypeGuard;
         return true;
     }
     TypeGuard.TUnion = TUnion;
-    /** Returns true if the given schema is TUnion<Literal<string>[]> */
-    function TUnionLiteral(schema) {
-        return TUnion(schema) && schema.anyOf.every((schema) => TLiteral(schema) && typeof schema.const === 'string');
-    }
-    TypeGuard.TUnionLiteral = TUnionLiteral;
     /** Returns true if the given schema is TUint8Array */
     function TUint8Array(schema) {
         return TKind(schema) && schema[exports.Kind] === 'Uint8Array' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.instanceOf === 'Uint8Array' && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength);
@@ -1290,12 +1301,12 @@ var TypeExtends;
         return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     function Visit(left, right) {
-        // template union remap
+        // Template Literal Union Unwrap
         if (TypeGuard.TTemplateLiteral(left))
             return Visit(TemplateLiteralResolver.Resolve(left), right);
         if (TypeGuard.TTemplateLiteral(right))
             return Visit(left, TemplateLiteralResolver.Resolve(right));
-        // standard extends
+        // Standard Extends
         if (TypeGuard.TAny(left))
             return Any(left, right);
         if (TypeGuard.TArray(left))
@@ -1389,25 +1400,66 @@ var TypeClone;
     TypeClone.Clone = Clone;
 })(TypeClone = exports.TypeClone || (exports.TypeClone = {}));
 // --------------------------------------------------------------------------
+// IndexedAccessor
+// --------------------------------------------------------------------------
+var IndexedAccessor;
+(function (IndexedAccessor) {
+    function Intersect(schema, key) {
+        return schema.allOf.reduce((acc, schema) => [...acc, ...Visit(schema, key)], []);
+    }
+    function Union(schema, key) {
+        return schema.anyOf.reduce((acc, schema) => [...acc, ...Visit(schema, key)], []);
+    }
+    function Object(schema, key) {
+        const keys = globalThis.Object.getOwnPropertyNames(schema.properties).filter((k) => k === key);
+        return keys.map((key) => schema.properties[key]);
+    }
+    function Tuple(schema, key) {
+        const items = schema.items === undefined ? [] : schema.items;
+        return items.filter((_, index) => index.toString() === key.toString());
+    }
+    function Visit(schema, key) {
+        if (schema[exports.Kind] === 'Intersect')
+            return Intersect(schema, key);
+        if (schema[exports.Kind] === 'Union')
+            return Union(schema, key);
+        if (schema[exports.Kind] === 'Object')
+            return Object(schema, key);
+        if (schema[exports.Kind] === 'Tuple')
+            return Tuple(schema, key);
+        return [];
+    }
+    function Resolve(schema, keys) {
+        return keys.reduce((acc, key) => [...acc, ...Visit(schema, key)], []);
+    }
+    IndexedAccessor.Resolve = Resolve;
+})(IndexedAccessor = exports.IndexedAccessor || (exports.IndexedAccessor = {}));
+// --------------------------------------------------------------------------
 // ObjectMap
 // --------------------------------------------------------------------------
 var ObjectMap;
 (function (ObjectMap) {
     function Intersect(schema, callback) {
+        // prettier-ignore
         return exports.Type.Intersect(schema.allOf.map((inner) => Visit(inner, callback)), { ...schema });
     }
     function Union(schema, callback) {
+        // prettier-ignore
         return exports.Type.Union(schema.anyOf.map((inner) => Visit(inner, callback)), { ...schema });
     }
     function Object(schema, callback) {
         return callback(schema);
     }
     function Visit(schema, callback) {
-        if (TypeGuard.TIntersect(schema))
+        // There are cases where users need to map objects with unregistered kinds. Using a TypeGuard here would
+        // prevent sub schema mapping as unregistered kinds will not pass TSchema checks. This is notable in the
+        // case of TObject where unregistered property kinds cause the TObject check to fail. As mapping is only
+        // used for composition, we use explicit checks instead.
+        if (schema[exports.Kind] === 'Intersect')
             return Intersect(schema, callback);
-        if (TypeGuard.TUnion(schema))
+        if (schema[exports.Kind] === 'Union')
             return Union(schema, callback);
-        if (TypeGuard.TObject(schema))
+        if (schema[exports.Kind] === 'Object')
             return Object(schema, callback);
         return schema;
     }
@@ -1416,39 +1468,72 @@ var ObjectMap;
     }
     ObjectMap.Map = Map;
 })(ObjectMap = exports.ObjectMap || (exports.ObjectMap = {}));
-// --------------------------------------------------------------------------
-// KeyResolver
-// --------------------------------------------------------------------------
 var KeyResolver;
 (function (KeyResolver) {
-    function IsKeyable(schema) {
-        return TypeGuard.TIntersect(schema) || TypeGuard.TUnion(schema) || (TypeGuard.TObject(schema) && globalThis.Object.getOwnPropertyNames(schema.properties).length > 0);
+    function UnwrapPattern(key) {
+        return key[0] === '^' && key[key.length - 1] === '$' ? key.slice(1, key.length - 1) : key;
     }
-    function Intersect(schema) {
-        return [...schema.allOf.filter((schema) => IsKeyable(schema)).reduce((set, schema) => Visit(schema).map((key) => set.add(key))[0], new Set())];
+    function Intersect(schema, options) {
+        return schema.allOf.reduce((acc, schema) => [...acc, ...Visit(schema, options)], []);
     }
-    function Union(schema) {
-        const sets = schema.anyOf.filter((schema) => IsKeyable(schema)).map((inner) => Visit(inner));
+    function Union(schema, options) {
+        const sets = schema.anyOf.map((inner) => Visit(inner, options));
         return [...sets.reduce((set, outer) => outer.map((key) => (sets.every((inner) => inner.includes(key)) ? set.add(key) : set))[0], new Set())];
     }
-    function Object(schema) {
+    function Object(schema, options) {
         return globalThis.Object.keys(schema.properties);
     }
-    function Visit(schema) {
+    function Record(schema, options) {
+        return options.includePatterns ? globalThis.Object.keys(schema.patternProperties) : [];
+    }
+    function Visit(schema, options) {
         if (TypeGuard.TIntersect(schema))
-            return Intersect(schema);
+            return Intersect(schema, options);
         if (TypeGuard.TUnion(schema))
-            return Union(schema);
+            return Union(schema, options);
         if (TypeGuard.TObject(schema))
-            return Object(schema);
+            return Object(schema, options);
+        if (TypeGuard.TRecord(schema))
+            return Record(schema, options);
         return [];
     }
-    function Resolve(schema) {
-        return Visit(schema);
+    /** Resolves an array of keys in this schema */
+    function ResolveKeys(schema, options) {
+        return [...new Set(Visit(schema, options))];
+    }
+    KeyResolver.ResolveKeys = ResolveKeys;
+    /** Resolves a regular expression pattern matching all keys in this schema */
+    function ResolvePattern(schema) {
+        const keys = ResolveKeys(schema, { includePatterns: true });
+        const pattern = keys.map((key) => `(${UnwrapPattern(key)})`);
+        return `^(${pattern.join('|')})$`;
     }
-    KeyResolver.Resolve = Resolve;
+    KeyResolver.ResolvePattern = ResolvePattern;
 })(KeyResolver = exports.KeyResolver || (exports.KeyResolver = {}));
 // --------------------------------------------------------------------------
+// KeyArrayResolver
+// --------------------------------------------------------------------------
+var KeyArrayResolver;
+(function (KeyArrayResolver) {
+    /** Resolves an array of string[] keys from the given schema or array type. */
+    function Resolve(schema) {
+        if (globalThis.Array.isArray(schema))
+            return schema;
+        if (TypeGuard.TLiteralUnion(schema))
+            return schema.anyOf.map((schema) => schema.const);
+        if (TypeGuard.TLiteral(schema))
+            return [schema.const];
+        if (TypeGuard.TTemplateLiteral(schema)) {
+            const expression = TemplateLiteralParser.ParseExact(schema.pattern);
+            if (!TemplateLiteralFinite.Check(expression))
+                throw Error('KeyArrayResolver: Cannot resolve keys from infinite template expression');
+            return [...TemplateLiteralGenerator.Generate(expression)];
+        }
+        return [];
+    }
+    KeyArrayResolver.Resolve = Resolve;
+})(KeyArrayResolver = exports.KeyArrayResolver || (exports.KeyArrayResolver = {}));
+// --------------------------------------------------------------------------
 // TemplateLiteralPattern
 // --------------------------------------------------------------------------
 var TemplateLiteralPattern;
@@ -1500,6 +1585,7 @@ var TemplateLiteralPattern;
 // --------------------------------------------------------------------------------------
 var TemplateLiteralResolver;
 (function (TemplateLiteralResolver) {
+    /** Resolves a template literal as a TUnion */
     function Resolve(template) {
         const expression = TemplateLiteralParser.ParseExact(template.pattern);
         if (!TemplateLiteralFinite.Check(expression))
@@ -1805,23 +1891,21 @@ class StandardTypeBuilder extends TypeBuilder {
                 if (!optional.has(key))
                     delete property[exports.Modifier];
                 if (key in properties) {
-                    const left = TypeExtends.Extends(properties[key], property) !== TypeExtendsResult.False;
-                    const right = TypeExtends.Extends(property, properties[key]) !== TypeExtendsResult.False;
-                    if (!left && !right)
-                        properties[key] = exports.Type.Never();
-                    if (!left && right)
-                        properties[key] = property;
+                    properties[key] = TypeGuard.TIntersect(properties[key]) ? this.Intersect([...properties[key].allOf, property]) : this.Intersect([properties[key], property]);
                 }
                 else {
                     properties[key] = property;
                 }
             }
         }
+        for (const key of globalThis.Object.getOwnPropertyNames(properties)) {
+            properties[key] = optional.has(key) ? this.Optional(properties[key]) : properties[key];
+        }
         if (required.size > 0) {
-            return this.Create({ ...options, [exports.Kind]: 'Object', [exports.Hint]: 'Composite', type: 'object', properties, required: [...required] });
+            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties, required: [...required] });
         }
         else {
-            return this.Create({ ...options, [exports.Kind]: 'Object', [exports.Hint]: 'Composite', type: 'object', properties });
+            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties });
         }
     }
     /** `[Standard]` Creates a Enum type */
@@ -1870,6 +1954,16 @@ class StandardTypeBuilder extends TypeBuilder {
             return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? TypeClone.Clone(left, options) : this.Never(options));
         }
     }
+    /** `[Standard]` Returns indexed property types for the given keys */
+    Index(schema, unresolved, options = {}) {
+        const keys = KeyArrayResolver.Resolve(unresolved);
+        if (TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved)) {
+            return TypeClone.Clone(schema.items, options);
+        }
+        const resolved = IndexedAccessor.Resolve(schema, keys);
+        const cloned = resolved.map((schema) => TypeClone.Clone(schema, {}));
+        return this.Union(cloned, options);
+    }
     /** `[Standard]` Creates an Integer type */
     Integer(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Integer', type: 'integer' });
@@ -1899,11 +1993,19 @@ class StandardTypeBuilder extends TypeBuilder {
                 return this.String(options);
             throw Error('StandardTypeBuilder: Unable to resolve key type from Record key pattern');
         }
+        else if (TypeGuard.TTuple(schema)) {
+            const items = schema.items === undefined ? [] : schema.items;
+            const literals = items.map((_, index) => exports.Type.Literal(index));
+            return this.Union(literals, options);
+        }
+        else if (TypeGuard.TArray(schema)) {
+            return this.Number(options);
+        }
         else {
-            const resolved = KeyResolver.Resolve(schema);
-            if (resolved.length === 0)
+            const keys = KeyResolver.ResolveKeys(schema, { includePatterns: false });
+            if (keys.length === 0)
                 return this.Never(options);
-            const literals = resolved.map((key) => this.Literal(key));
+            const literals = keys.map((key) => this.Literal(key));
             return this.Union(literals, options);
         }
     }
@@ -1942,11 +2044,7 @@ class StandardTypeBuilder extends TypeBuilder {
         }
     }
     Omit(schema, unresolved, options = {}) {
-        // prettier-ignore
-        const keys = TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema) => schema.const) :
-            TypeGuard.TLiteral(unresolved) ? [unresolved.const] :
-                TypeGuard.TNever(unresolved) ? [] :
-                    unresolved;
+        const keys = KeyArrayResolver.Resolve(unresolved);
         // prettier-ignore
         return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
             if (schema.required) {
@@ -1988,11 +2086,7 @@ class StandardTypeBuilder extends TypeBuilder {
         }, options);
     }
     Pick(schema, unresolved, options = {}) {
-        // prettier-ignore
-        const keys = TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema) => schema.const) :
-            TypeGuard.TLiteral(unresolved) ? [unresolved.const] :
-                TypeGuard.TNever(unresolved) ? [] :
-                    unresolved;
+        const keys = KeyArrayResolver.Resolve(unresolved);
         // prettier-ignore
         return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
             if (schema.required) {
@@ -2014,9 +2108,9 @@ class StandardTypeBuilder extends TypeBuilder {
             // prettier-ignore
             return TemplateLiteralFinite.Check(expression)
                 ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema, {}) }), {}), options))
-                : this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false });
+                : this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) } });
         }
-        else if (TypeGuard.TUnionLiteral(key)) {
+        else if (TypeGuard.TLiteralUnion(key)) {
             if (key.anyOf.every((schema) => TypeGuard.TLiteral(schema) && (typeof schema.const === 'string' || typeof schema.const === 'number'))) {
                 const properties = key.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {});
                 return this.Object(properties, { ...options, [exports.Hint]: 'Record' });
@@ -2033,11 +2127,11 @@ class StandardTypeBuilder extends TypeBuilder {
         }
         else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
             const pattern = exports.PatternNumberExact;
-            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false });
+            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } });
         }
         else if (TypeGuard.TString(key)) {
             const pattern = key.pattern === undefined ? exports.PatternStringExact : key.pattern;
-            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false });
+            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } });
         }
         else {
             throw Error(`StandardTypeBuilder: Invalid Record Key`);

package/value/check.js

@@ -189,21 +189,19 @@ var ValueCheck;
         return true;
     }
     function Intersect(schema, references, value) {
-        if (!schema.allOf.every((schema) => Visit(schema, references, value))) {
-            return false;
-        }
-        else if (schema.unevaluatedProperties === false) {
-            const schemaKeys = Types.KeyResolver.Resolve(schema);
-            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
-            return valueKeys.every((key) => schemaKeys.includes(key));
+        const check1 = schema.allOf.every((schema) => Visit(schema, references, value));
+        if (schema.unevaluatedProperties === false) {
+            const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema));
+            const check2 = globalThis.Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key));
+            return check1 && check2;
         }
         else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
-            const schemaKeys = Types.KeyResolver.Resolve(schema);
-            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
-            return valueKeys.every((key) => schemaKeys.includes(key) || Visit(schema.unevaluatedProperties, references, value[key]));
+            const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema));
+            const check2 = globalThis.Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit(schema.unevaluatedProperties, references, value[key]));
+            return check1 && check2;
         }
         else {
-            return true;
+            return check1;
         }
     }
     function Literal(schema, references, value) {
@@ -297,16 +295,20 @@ var ValueCheck;
         if (IsDefined(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
             return false;
         }
-        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
-        const regex = new RegExp(keyPattern);
-        if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
-            return false;
-        }
-        for (const propValue of globalThis.Object.values(value)) {
-            if (!Visit(valueSchema, references, propValue))
+        const [patternKey, patternSchema] = globalThis.Object.entries(schema.patternProperties)[0];
+        const regex = new RegExp(patternKey);
+        return globalThis.Object.entries(value).every(([key, value]) => {
+            if (regex.test(key)) {
+                return Visit(patternSchema, references, value);
+            }
+            if (typeof schema.additionalProperties === 'object') {
+                return Visit(schema.additionalProperties, references, value);
+            }
+            if (schema.additionalProperties === false) {
                 return false;
-        }
-        return true;
+            }
+            return true;
+        });
     }
     function Ref(schema, references, value) {
         const index = references.findIndex((foreign) => foreign.$id === schema.$ref);

package/value/delta.d.ts

@@ -2,32 +2,32 @@ import { Static } from '../typebox';
 export type Insert = Static<typeof Insert>;
 export declare const Insert: import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"insert">;
-    path: import("../typebox").TString<string>;
+    path: import("../typebox").TString;
     value: import("../typebox").TUnknown;
 }>;
 export type Update = Static<typeof Update>;
 export declare const Update: import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"update">;
-    path: import("../typebox").TString<string>;
+    path: import("../typebox").TString;
     value: import("../typebox").TUnknown;
 }>;
 export type Delete = Static<typeof Delete>;
 export declare const Delete: import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"delete">;
-    path: import("../typebox").TString<string>;
+    path: import("../typebox").TString;
 }>;
 export type Edit = Static<typeof Edit>;
 export declare const Edit: import("../typebox").TUnion<[import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"insert">;
-    path: import("../typebox").TString<string>;
+    path: import("../typebox").TString;
     value: import("../typebox").TUnknown;
 }>, import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"update">;
-    path: import("../typebox").TString<string>;
+    path: import("../typebox").TString;
     value: import("../typebox").TUnknown;
 }>, import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"delete">;
-    path: import("../typebox").TString<string>;
+    path: import("../typebox").TString;
 }>]>;
 export declare class ValueDeltaObjectWithSymbolKeyError extends Error {
     readonly key: unknown;