dataiku-sdk 0.12.4 → 0.12.5

package/node_modules/@sinclair/typebox/build/cjs/system/index.js

@@ -15,5 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./evaluate"), exports);
 __exportStar(require("./policy"), exports);
 __exportStar(require("./system"), exports);

package/node_modules/@sinclair/typebox/build/cjs/type/object/object.d.ts

@@ -45,7 +45,7 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
     required: TRequiredArray<T>;
 }
 /** `[Json]` Creates an Object type */
-declare function _Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+declare function _Object_<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
 /** `[Json]` Creates an Object type */
-export declare var Object: typeof _Object;
+export declare var Object: typeof _Object_;
 export {};

package/node_modules/@sinclair/typebox/build/cjs/type/object/object.js

@@ -13,10 +13,26 @@ function RequiredArray(properties) {
     return globalThis.Object.keys(properties).filter((key) => !(0, kind_1.IsOptional)(properties[key]));
 }
 /** `[Json]` Creates an Object type */
-function _Object(properties, options) {
+function _Object_(properties, options) {
     const required = RequiredArray(properties);
     const schema = required.length > 0 ? { [index_1.Kind]: 'Object', type: 'object', required, properties } : { [index_1.Kind]: 'Object', type: 'object', properties };
     return (0, type_1.CreateType)(schema, options);
 }
+// ------------------------------------------------------------------
+// TypeScript 7: CommonJS TS2441
+//
+// TypeScript generates a CommonJS shim that patches local variables
+// via an unqualified reference to Object (e.g. the __esModule shim's
+// Object.defineProperty call). Other compiler tools have been
+// observed patching in the same way, but TypeScript 7 has correctly
+// begun flagging variables named Object in CommonJS, since they
+// conflict with the shim and can cause "used before definition"
+// errors. This is CommonJS-specific; no such shim exists for ESM.
+//
+// TypeBox works around this using a `var` declaration, which is
+// known to avoid use-before-definition errors. TypeBox 1.x employs
+// a similar strategy.
+// ------------------------------------------------------------------
 /** `[Json]` Creates an Object type */
-exports.Object = _Object;
+// @ts-ignore - error TS2441: Duplicate identifier 'Object'. Compiler reserves name 'Object' in top level scope of a module.
+exports.Object = _Object_;

package/node_modules/@sinclair/typebox/build/cjs/value/parse/parse.d.ts

@@ -11,7 +11,7 @@ export declare namespace ParseRegistry {
     function Set(key: string, callback: TParseFunction): void;
     function Get(key: string): TParseFunction | undefined;
 }
-export declare const ParseDefault: readonly ["Clone", "Clean", "Default", "Convert", "Assert", "Decode"];
+export declare const ParseDefault: readonly ['Clone', 'Clean', 'Default', 'Convert', 'Assert', 'Decode'];
 /** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
 export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, references: TSchema[], value: unknown): Result;
 /** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */

package/node_modules/@sinclair/typebox/build/esm/compiler/compiler.mjs

@@ -1,6 +1,6 @@
 import { TransformEncode, TransformDecode, HasTransform, TransformDecodeCheckError, TransformEncodeCheckError } from '../value/transform/index.mjs';
 import { Errors } from '../errors/index.mjs';
-import { TypeSystemPolicy } from '../system/index.mjs';
+import { TypeSystemPolicy, Evaluate } from '../system/index.mjs';
 import { TypeBoxError } from '../type/error/index.mjs';
 import { Deref } from '../value/deref/index.mjs';
 import { Hash } from '../value/hash/index.mjs';
@@ -86,35 +86,6 @@ var Character;
     Character.IsNumeric = IsNumeric;
 })(Character || (Character = {}));
 // ------------------------------------------------------------------
-// MemberExpression
-// ------------------------------------------------------------------
-var MemberExpression;
-(function (MemberExpression) {
-    function IsFirstCharacterNumeric(value) {
-        if (value.length === 0)
-            return false;
-        return Character.IsNumeric(value.charCodeAt(0));
-    }
-    function IsAccessor(value) {
-        if (IsFirstCharacterNumeric(value))
-            return false;
-        for (let i = 0; i < value.length; i++) {
-            const code = value.charCodeAt(i);
-            const check = Character.IsAlpha(code) || Character.IsNumeric(code) || Character.DollarSign(code) || Character.IsUnderscore(code);
-            if (!check)
-                return false;
-        }
-        return true;
-    }
-    function EscapeHyphen(key) {
-        return key.replace(/'/g, "\\'");
-    }
-    function Encode(object, key) {
-        return IsAccessor(key) ? `${object}.${key}` : `${object}['${EscapeHyphen(key)}']`;
-    }
-    MemberExpression.Encode = Encode;
-})(MemberExpression || (MemberExpression = {}));
-// ------------------------------------------------------------------
 // Identifier
 // ------------------------------------------------------------------
 var Identifier;
@@ -135,15 +106,21 @@ var Identifier;
     Identifier.Encode = Encode;
 })(Identifier || (Identifier = {}));
 // ------------------------------------------------------------------
-// LiteralString
+// StringConstant
 // ------------------------------------------------------------------
-var LiteralString;
-(function (LiteralString) {
-    function Escape(content) {
-        return content.replace(/'/g, "\\'");
-    }
-    LiteralString.Escape = Escape;
-})(LiteralString || (LiteralString = {}));
+function StringConstant(value) {
+    if (!IsString(value))
+        throw Error('ConstantString: Not a String');
+    const canonical = JSON.stringify(value).slice(1, -1);
+    const escaped = canonical.replace(/'/g, "\\'");
+    return `'${escaped}'`;
+}
+// ------------------------------------------------------------------
+// MemberExpression
+// ------------------------------------------------------------------
+function MemberExpression(value, key) {
+    return `${value}[${StringConstant(key)}]`;
+}
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -165,7 +142,7 @@ export class TypeCompilerTypeGuardError extends TypeBoxError {
 export var Policy;
 (function (Policy) {
     function IsExactOptionalProperty(value, key, expression) {
-        return TypeSystemPolicy.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`;
+        return TypeSystemPolicy.ExactOptionalPropertyTypes ? `(${StringConstant(key)} in ${value} ? ${expression} : true)` : `(${MemberExpression(value, key)} !== undefined ? ${expression} : true)`;
     }
     Policy.IsExactOptionalProperty = IsExactOptionalProperty;
     function IsObjectLike(value) {
@@ -310,8 +287,11 @@ export var TypeCompiler;
         if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
             yield `(${value} === ${schema.const})`;
         }
+        else if (typeof schema.const === 'string') {
+            yield `(${value} === ${StringConstant(schema.const)})`;
+        }
         else {
-            yield `(${value} === '${LiteralString.Escape(schema.const)}')`;
+            throw Error('Invalid Literal Value');
         }
     }
     function* FromNever(schema, references, value) {
@@ -345,12 +325,12 @@ export var TypeCompiler;
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const knownKeys = Object.getOwnPropertyNames(schema.properties);
         for (const knownKey of knownKeys) {
-            const memberExpression = MemberExpression.Encode(value, knownKey);
+            const memberExpression = MemberExpression(value, knownKey);
             const property = schema.properties[knownKey];
             if (schema.required && schema.required.includes(knownKey)) {
                 yield* Visit(property, references, memberExpression);
                 if (ExtendsUndefinedCheck(property) || IsAnyOrUnknown(property))
-                    yield `('${knownKey}' in ${value})`;
+                    yield `(${StringConstant(knownKey)} in ${value})`;
             }
             else {
                 const expression = CreateExpression(property, references, memberExpression);
@@ -362,13 +342,13 @@ export var TypeCompiler;
                 yield `Object.getOwnPropertyNames(${value}).length === ${knownKeys.length}`;
             }
             else {
-                const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`;
+                const keys = `[${knownKeys.map((key) => `${StringConstant(key)}`).join(', ')}]`;
                 yield `Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key))`;
             }
         }
         if (typeof schema.additionalProperties === 'object') {
             const expression = CreateExpression(schema.additionalProperties, references, `${value}[key]`);
-            const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`;
+            const keys = `[${knownKeys.map((key) => `${StringConstant(key)}`).join(', ')}]`;
             yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
         }
     }
@@ -416,7 +396,7 @@ export var TypeCompiler;
             yield `${variable}.test(${value})`;
         }
         if (schema.format !== undefined) {
-            yield `format('${schema.format}', ${value})`;
+            yield `format(${StringConstant(schema.format)}, ${value})`;
         }
     }
     function* FromSymbol(schema, references, value) {
@@ -464,7 +444,7 @@ export var TypeCompiler;
     function* FromKind(schema, references, value) {
         const instance = state.instances.size;
         state.instances.set(instance, schema);
-        yield `kind('${schema[Kind]}', ${instance}, ${value})`;
+        yield `kind(${StringConstant(schema[Kind])}, ${instance}, ${value})`;
     }
     function* Visit(schema, references, value, useHoisting = true) {
         const references_ = IsString(schema.$id) ? [...references, schema] : references;
@@ -638,7 +618,7 @@ export var TypeCompiler;
     /** Compiles a TypeBox type for optimal runtime type checking. Types must be valid TypeBox types of TSchema */
     function Compile(schema, references = []) {
         const generatedCode = Code(schema, references, { language: 'javascript' });
-        const compiledFunction = globalThis.Function('kind', 'format', 'hash', generatedCode);
+        const compiledFunction = Evaluate('kind', 'format', 'hash', generatedCode);
         const instances = new Map(state.instances);
         function typeRegistryFunction(kind, instance, value) {
             if (!TypeRegistry.Has(kind) || !instances.has(instance))

package/node_modules/@sinclair/typebox/build/esm/parser/runtime/guard.d.mts

@@ -20,4 +20,4 @@ export declare function IsTuple(value: unknown): value is ITuple;
 /** Returns true if the value is a Union Parser */
 export declare function IsUnion(value: unknown): value is IUnion;
 /** Returns true if the value is a Parser */
-export declare function IsParser(value: unknown): value is IContext<unknown> | IUnion<unknown> | IArray<unknown> | IConst<unknown> | IIdent<unknown> | INumber<unknown> | IOptional<unknown> | IRef<unknown> | IString<unknown> | ITuple<unknown>;
+export declare function IsParser(value: unknown): value is IArray<unknown> | IConst<unknown> | IContext<unknown> | IIdent<unknown> | INumber<unknown> | IOptional<unknown> | IRef<unknown> | IString<unknown> | ITuple<unknown> | IUnion<unknown>;

package/node_modules/@sinclair/typebox/build/esm/parser/runtime/token.d.mts

@@ -3,6 +3,6 @@ export declare function Const(value: string, code: string): [] | [string, string
 /** Scans for the next Ident token */
 export declare function Ident(code: string): [] | [string, string];
 /** Scans for the next number token */
-export declare function Number(code: string): [string, string] | [];
+export declare function Number(code: string): [] | [string, string];
 /** Scans the next Literal String value */
-export declare function String(options: string[], code: string): [string, string] | [];
+export declare function String(options: string[], code: string): [] | [string, string];

package/node_modules/@sinclair/typebox/build/esm/syntax/mapping.d.mts

@@ -121,7 +121,7 @@ export declare function AsyncIteratorMapping(input: [unknown, unknown, unknown,
 export type TIteratorMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Iterator', '<', infer Type extends T.TSchema, '>'] ? T.TIterator<Type> : never;
 export declare function IteratorMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TIterator<T.TSchema>;
 export type TArgumentMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Argument', '<', infer Type extends T.TSchema, '>'] ? Type extends T.TLiteral<infer Index extends number> ? T.TArgument<Index> : T.TNever : never;
-export declare function ArgumentMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TNever | T.TArgument<number>;
+export declare function ArgumentMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TArgument<number> | T.TNever;
 export type TAwaitedMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Awaited', '<', infer Type extends T.TSchema, '>'] ? T.TAwaited<Type> : never;
 export declare function AwaitedMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TSchema;
 export type TArrayMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Array', '<', infer Type extends T.TSchema, '>'] ? T.TArray<Type> : never;

package/node_modules/@sinclair/typebox/build/esm/system/evaluate.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Evaluates code in the current environment. This function matches centralized
+ * evaluation as implemented in TypeBox 1.x.
+ */
+export declare function Evaluate(...args: string[]): globalThis.Function;

package/node_modules/@sinclair/typebox/build/esm/system/evaluate.mjs

@@ -0,0 +1,7 @@
+/**
+ * Evaluates code in the current environment. This function matches centralized
+ * evaluation as implemented in TypeBox 1.x.
+ */
+export function Evaluate(...args) {
+    return new globalThis.Function(...args);
+}

package/node_modules/@sinclair/typebox/build/esm/system/index.d.mts

@@ -1,2 +1,3 @@
+export * from './evaluate.mjs';
 export * from './policy.mjs';
 export * from './system.mjs';

package/node_modules/@sinclair/typebox/build/esm/system/index.mjs

@@ -1,2 +1,3 @@
+export * from './evaluate.mjs';
 export * from './policy.mjs';
 export * from './system.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/composite/composite.mjs

@@ -1,7 +1,7 @@
 import { IntersectEvaluated } from '../intersect/index.mjs';
 import { IndexFromPropertyKeys } from '../indexed/index.mjs';
 import { KeyOfPropertyKeys } from '../keyof/index.mjs';
-import { Object } from '../object/index.mjs';
+import { Object as _Object_ } from '../object/index.mjs';
 import { SetDistinct } from '../sets/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
@@ -37,6 +37,6 @@ function CompositeProperties(T, K) {
 export function Composite(T, options) {
     const K = CompositeKeys(T);
     const P = CompositeProperties(T, K);
-    const R = Object(P, options);
+    const R = _Object_(P, options);
     return R;
 }

package/node_modules/@sinclair/typebox/build/esm/type/const/const.mjs

@@ -4,7 +4,7 @@ import { Date } from '../date/index.mjs';
 import { Function as FunctionType } from '../function/index.mjs';
 import { Literal } from '../literal/index.mjs';
 import { Null } from '../null/index.mjs';
-import { Object } from '../object/index.mjs';
+import { Object as _Object_ } from '../object/index.mjs';
 import { Symbol } from '../symbol/index.mjs';
 import { Tuple } from '../tuple/index.mjs';
 import { Readonly } from '../readonly/index.mjs';
@@ -37,7 +37,7 @@ function FromValue(value, root) {
             IsArray(value) ? Readonly(Tuple(FromArray(value))) :
                 IsUint8Array(value) ? Uint8Array() :
                     IsDate(value) ? Date() :
-                        IsObject(value) ? ConditionalReadonly(Object(FromProperties(value)), root) :
+                        IsObject(value) ? ConditionalReadonly(_Object_(FromProperties(value)), root) :
                             IsFunction(value) ? ConditionalReadonly(FunctionType([], Unknown()), root) :
                                 IsUndefined(value) ? Undefined() :
                                     IsNull(value) ? Null() :
@@ -46,7 +46,7 @@ function FromValue(value, root) {
                                                 IsNumber(value) ? Literal(value) :
                                                     IsBoolean(value) ? Literal(value) :
                                                         IsString(value) ? Literal(value) :
-                                                            Object({}));
+                                                            _Object_({}));
 }
 /** `[JavaScript]` Creates a readonly const type from the given value. */
 export function Const(T, options) {

package/node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.mjs

@@ -3,7 +3,7 @@ import { Unknown } from '../unknown/index.mjs';
 import { ReadonlyOptional } from '../readonly-optional/index.mjs';
 import { Readonly } from '../readonly/index.mjs';
 import { Optional } from '../optional/index.mjs';
-import { Object } from '../object/index.mjs';
+import { Object as _Object_ } from '../object/index.mjs';
 import { Record, RecordKey, RecordValue } from '../record/index.mjs';
 import * as ValueGuard from '../guard/value.mjs';
 import * as KindGuard from '../guard/kind.mjs';
@@ -59,7 +59,7 @@ function FromPromise(args, type) {
 // prettier-ignore
 function FromObject(args, type) {
     const mappedProperties = FromProperties(args, type.properties);
-    return { ...type, ...Object(mappedProperties) }; // retain options
+    return { ...type, ..._Object_(mappedProperties) }; // retain options
 }
 // prettier-ignore
 function FromRecord(args, type) {

package/node_modules/@sinclair/typebox/build/esm/type/mapped/mapped.mjs

@@ -9,7 +9,7 @@ import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Iterator } from '../iterator/index.mjs';
 import { Literal } from '../literal/index.mjs';
-import { Object } from '../object/index.mjs';
+import { Object as _Object_ } from '../object/index.mjs';
 import { Optional } from '../optional/index.mjs';
 import { Promise } from '../promise/index.mjs';
 import { Readonly } from '../readonly/index.mjs';
@@ -81,7 +81,7 @@ function FromSchemaType(K, T) {
                                     IsIntersect(T) ? Intersect(FromRest(K, T.allOf), options) :
                                         IsUnion(T) ? Union(FromRest(K, T.anyOf), options) :
                                             IsTuple(T) ? Tuple(FromRest(K, T.items ?? []), options) :
-                                                IsObject(T) ? Object(FromProperties(K, T.properties), options) :
+                                                IsObject(T) ? _Object_(FromProperties(K, T.properties), options) :
                                                     IsArray(T) ? Array(FromSchemaType(K, T.items), options) :
                                                         IsPromise(T) ? Promise(FromSchemaType(K, T.item), options) :
                                                             T);
@@ -98,5 +98,5 @@ export function Mapped(key, map, options) {
     const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
     const RT = map({ [Kind]: 'MappedKey', keys: K });
     const R = MappedFunctionReturnType(K, RT);
-    return Object(R, options);
+    return _Object_(R, options);
 }

package/node_modules/@sinclair/typebox/build/esm/type/module/compute.mjs

@@ -10,7 +10,7 @@ import { Function as FunctionType } from '../function/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Iterator } from '../iterator/index.mjs';
 import { KeyOf } from '../keyof/index.mjs';
-import { Object } from '../object/index.mjs';
+import { Object as _Object_ } from '../object/index.mjs';
 import { Omit } from '../omit/index.mjs';
 import { Pick } from '../pick/index.mjs';
 import { Never } from '../never/index.mjs';
@@ -104,7 +104,7 @@ function FromIterator(moduleProperties, type) {
     return Iterator(FromType(moduleProperties, type));
 }
 function FromObject(moduleProperties, properties) {
-    return Object(globalThis.Object.keys(properties).reduce((result, key) => {
+    return _Object_(globalThis.Object.keys(properties).reduce((result, key) => {
         return { ...result, [key]: FromType(moduleProperties, properties[key]) };
     }, {}));
 }

package/node_modules/@sinclair/typebox/build/esm/type/object/object.d.mts

@@ -45,7 +45,7 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
     required: TRequiredArray<T>;
 }
 /** `[Json]` Creates an Object type */
-declare function _Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+declare function _Object_<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
 /** `[Json]` Creates an Object type */
-export declare var Object: typeof _Object;
+export declare var Object: typeof _Object_;
 export {};

package/node_modules/@sinclair/typebox/build/esm/type/object/object.mjs

@@ -9,10 +9,26 @@ function RequiredArray(properties) {
     return globalThis.Object.keys(properties).filter((key) => !IsOptional(properties[key]));
 }
 /** `[Json]` Creates an Object type */
-function _Object(properties, options) {
+function _Object_(properties, options) {
     const required = RequiredArray(properties);
     const schema = required.length > 0 ? { [Kind]: 'Object', type: 'object', required, properties } : { [Kind]: 'Object', type: 'object', properties };
     return CreateType(schema, options);
 }
+// ------------------------------------------------------------------
+// TypeScript 7: CommonJS TS2441
+//
+// TypeScript generates a CommonJS shim that patches local variables
+// via an unqualified reference to Object (e.g. the __esModule shim's
+// Object.defineProperty call). Other compiler tools have been
+// observed patching in the same way, but TypeScript 7 has correctly
+// begun flagging variables named Object in CommonJS, since they
+// conflict with the shim and can cause "used before definition"
+// errors. This is CommonJS-specific; no such shim exists for ESM.
+//
+// TypeBox works around this using a `var` declaration, which is
+// known to avoid use-before-definition errors. TypeBox 1.x employs
+// a similar strategy.
+// ------------------------------------------------------------------
 /** `[Json]` Creates an Object type */
-export var Object = _Object;
+// @ts-ignore - error TS2441: Duplicate identifier 'Object'. Compiler reserves name 'Object' in top level scope of a module.
+export var Object = _Object_;

package/node_modules/@sinclair/typebox/build/esm/type/omit/omit.mjs

@@ -6,7 +6,7 @@ import { Literal } from '../literal/index.mjs';
 import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
-import { Object } from '../object/index.mjs';
+import { Object as _Object_ } from '../object/index.mjs';
 // ------------------------------------------------------------------
 // Mapped
 // ------------------------------------------------------------------
@@ -41,7 +41,7 @@ function FromProperties(properties, propertyKeys) {
 function FromObject(type, propertyKeys, properties) {
     const options = Discard(type, [TransformKind, '$id', 'required', 'properties']);
     const mappedProperties = FromProperties(properties, propertyKeys);
-    return Object(mappedProperties, options);
+    return _Object_(mappedProperties, options);
 }
 // prettier-ignore
 function UnionFromPropertyKeys(propertyKeys) {
@@ -53,7 +53,7 @@ function OmitResolve(type, propertyKeys) {
     return (IsIntersect(type) ? Intersect(FromIntersect(type.allOf, propertyKeys)) :
         IsUnion(type) ? Union(FromUnion(type.anyOf, propertyKeys)) :
             IsObject(type) ? FromObject(type, propertyKeys, type.properties) :
-                Object({}));
+                _Object_({}));
 }
 /** `[Json]` Constructs a type whose keys are picked from the given type */
 // prettier-ignore

package/node_modules/@sinclair/typebox/build/esm/type/partial/partial.mjs

@@ -1,7 +1,7 @@
 import { CreateType } from '../create/type.mjs';
 import { Computed } from '../computed/index.mjs';
 import { Optional } from '../optional/index.mjs';
-import { Object } from '../object/index.mjs';
+import { Object as _Object_ } from '../object/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Ref } from '../ref/index.mjs';
@@ -31,7 +31,7 @@ function FromProperties(properties) {
 function FromObject(type, properties) {
     const options = Discard(type, [TransformKind, '$id', 'required', 'properties']);
     const mappedProperties = FromProperties(properties);
-    return Object(mappedProperties, options);
+    return _Object_(mappedProperties, options);
 }
 // prettier-ignore
 function FromRest(types) {
@@ -60,7 +60,7 @@ function PartialResolve(type) {
                                                     KindGuard.IsSymbol(type) ? type :
                                                         KindGuard.IsUndefined(type) ? type :
                                                             // Passthrough
-                                                            Object({}));
+                                                            _Object_({}));
 }
 /** `[Json]` Constructs a type where all properties are optional */
 export function Partial(type, options) {

package/node_modules/@sinclair/typebox/build/esm/type/pick/pick.mjs

@@ -3,7 +3,7 @@ import { Discard } from '../discard/discard.mjs';
 import { Computed } from '../computed/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Literal } from '../literal/index.mjs';
-import { Object } from '../object/index.mjs';
+import { Object as _Object_ } from '../object/index.mjs';
 import { Union } from '../union/index.mjs';
 import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { TransformKind } from '../symbols/symbols.mjs';
@@ -36,7 +36,7 @@ function FromProperties(properties, propertyKeys) {
 function FromObject(Type, keys, properties) {
     const options = Discard(Type, [TransformKind, '$id', 'required', 'properties']);
     const mappedProperties = FromProperties(properties, keys);
-    return Object(mappedProperties, options);
+    return _Object_(mappedProperties, options);
 }
 // prettier-ignore
 function UnionFromPropertyKeys(propertyKeys) {
@@ -48,7 +48,7 @@ function PickResolve(type, propertyKeys) {
     return (IsIntersect(type) ? Intersect(FromIntersect(type.allOf, propertyKeys)) :
         IsUnion(type) ? Union(FromUnion(type.anyOf, propertyKeys)) :
             IsObject(type) ? FromObject(type, propertyKeys, type.properties) :
-                Object({}));
+                _Object_({}));
 }
 /** `[Json]` Constructs a type whose keys are picked from the given type */
 // prettier-ignore

package/node_modules/@sinclair/typebox/build/esm/type/record/record.mjs

@@ -2,7 +2,7 @@ import { CreateType } from '../create/type.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
 import { Never } from '../never/index.mjs';
 import { Number } from '../number/index.mjs';
-import { Object } from '../object/index.mjs';
+import { Object as _Object_ } from '../object/index.mjs';
 import { String } from '../string/index.mjs';
 import { Union } from '../union/index.mjs';
 import { IsTemplateLiteralFinite } from '../template-literal/index.mjs';
@@ -31,7 +31,7 @@ function RecordCreateFromKeys(K, T, options) {
     const result = {};
     for (const K2 of K)
         result[K2] = T;
-    return Object(result, { ...options, [Hint]: 'Record' });
+    return _Object_(result, { ...options, [Hint]: 'Record' });
 }
 // prettier-ignore
 function FromTemplateLiteralKey(K, T, options) {
@@ -66,7 +66,7 @@ function FromNeverKey(_key, type, options) {
 }
 // prettier-ignore
 function FromBooleanKey(_key, type, options) {
-    return Object({ true: type, false: type }, options);
+    return _Object_({ true: type, false: type }, options);
 }
 // prettier-ignore
 function FromIntegerKey(_key, type, options) {

package/node_modules/@sinclair/typebox/build/esm/type/required/required.mjs

@@ -1,6 +1,6 @@
 import { CreateType } from '../create/type.mjs';
 import { Computed } from '../computed/index.mjs';
-import { Object } from '../object/index.mjs';
+import { Object as _Object_ } from '../object/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Ref } from '../ref/index.mjs';
@@ -30,7 +30,7 @@ function FromProperties(properties) {
 function FromObject(type, properties) {
     const options = Discard(type, [TransformKind, '$id', 'required', 'properties']);
     const mappedProperties = FromProperties(properties);
-    return Object(mappedProperties, options);
+    return _Object_(mappedProperties, options);
 }
 // prettier-ignore
 function FromRest(types) {
@@ -59,7 +59,7 @@ function RequiredResolve(type) {
                                                     KindGuard.IsSymbol(type) ? type :
                                                         KindGuard.IsUndefined(type) ? type :
                                                             // Passthrough
-                                                            Object({}));
+                                                            _Object_({}));
 }
 /** `[Json]` Constructs a type where all properties are required */
 export function Required(type, options) {

package/node_modules/@sinclair/typebox/build/esm/type/type/json.mjs

@@ -19,7 +19,7 @@ import { Not } from '../not/index.mjs';
 import { Null } from '../null/index.mjs';
 import { Module } from '../module/index.mjs';
 import { Number } from '../number/index.mjs';
-import { Object } from '../object/index.mjs';
+import { Object as _Object_ } from '../object/index.mjs';
 import { Omit } from '../omit/index.mjs';
 import { Optional } from '../optional/index.mjs';
 import { Partial } from '../partial/index.mjs';
@@ -148,7 +148,7 @@ export class JsonTypeBuilder {
     }
     /** `[Json]` Creates an Object type */
     Object(properties, options) {
-        return Object(properties, options);
+        return _Object_(properties, options);
     }
     /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit(schema, selector, options) {

package/node_modules/@sinclair/typebox/build/esm/value/delta/delta.mjs

@@ -4,21 +4,21 @@ import { Clone } from '../clone/index.mjs';
 import { Equal } from '../equal/equal.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 import { Literal } from '../../type/literal/index.mjs';
-import { Object } from '../../type/object/index.mjs';
+import { Object as _Object_ } from '../../type/object/index.mjs';
 import { String } from '../../type/string/index.mjs';
 import { Unknown } from '../../type/unknown/index.mjs';
 import { Union } from '../../type/union/index.mjs';
-export const Insert = Object({
+export const Insert = _Object_({
     type: Literal('insert'),
     path: String(),
     value: Unknown(),
 });
-export const Update = Object({
+export const Update = _Object_({
     type: Literal('update'),
     path: String(),
     value: Unknown(),
 });
-export const Delete = Object({
+export const Delete = _Object_({
     type: Literal('delete'),
     path: String(),
 });

package/node_modules/@sinclair/typebox/build/esm/value/parse/parse.d.mts

@@ -11,7 +11,7 @@ export declare namespace ParseRegistry {
     function Set(key: string, callback: TParseFunction): void;
     function Get(key: string): TParseFunction | undefined;
 }
-export declare const ParseDefault: readonly ["Clone", "Clean", "Default", "Convert", "Assert", "Decode"];
+export declare const ParseDefault: readonly ['Clone', 'Clean', 'Default', 'Convert', 'Assert', 'Decode'];
 /** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
 export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, references: TSchema[], value: unknown): Result;
 /** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */

package/node_modules/@sinclair/typebox/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.49",
+  "version": "0.34.52",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",