dataiku-sdk 0.2.0 → 0.2.1

package/node_modules/@sinclair/typebox/build/cjs/type/partial/partial-from-mapped-result.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartialFromMappedResult = PartialFromMappedResult;
+const index_1 = require("../mapped/index");
+const partial_1 = require("./partial");
+const value_1 = require("../clone/value");
+// prettier-ignore
+function FromProperties(K, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = (0, partial_1.Partial)(K[K2], (0, value_1.Clone)(options));
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult(R, options) {
+    return FromProperties(R.properties, options);
+}
+// prettier-ignore
+function PartialFromMappedResult(R, options) {
+    const P = FromMappedResult(R, options);
+    return (0, index_1.MappedResult)(P);
+}

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

@@ -0,0 +1,35 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Evaluate, Ensure } from '../helpers/index';
+import type { TMappedResult } from '../mapped/index';
+import { type TReadonlyOptional } from '../readonly-optional/index';
+import { type TComputed } from '../computed/index';
+import { type TOptional } from '../optional/index';
+import { type TReadonly } from '../readonly/index';
+import { type TRecursive } from '../recursive/index';
+import { type TObject, type TProperties } from '../object/index';
+import { type TIntersect } from '../intersect/index';
+import { type TUnion } from '../union/index';
+import { type TRef } from '../ref/index';
+import { type TBigInt } from '../bigint/index';
+import { type TBoolean } from '../boolean/index';
+import { type TInteger } from '../integer/index';
+import { type TLiteral } from '../literal/index';
+import { type TNull } from '../null/index';
+import { type TNumber } from '../number/index';
+import { type TString } from '../string/index';
+import { type TSymbol } from '../symbol/index';
+import { type TUndefined } from '../undefined/index';
+import { type TPartialFromMappedResult } from './partial-from-mapped-result';
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<'Partial', [TComputed<Target, Parameters>]>>;
+type TFromRef<Ref extends string> = Ensure<TComputed<'Partial', [TRef<Ref>]>>;
+type TFromProperties<Properties extends TProperties> = Evaluate<{
+    [K in keyof Properties]: Properties[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : Properties[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : Properties[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<Properties[K]>;
+}>;
+type TFromObject<_Type extends TObject, Properties extends TProperties, MappedProperties extends TProperties = TFromProperties<Properties>, Result extends TSchema = TObject<MappedProperties>> = Result;
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Result, TPartial<L>]> : Result);
+export type TPartial<Type extends TSchema> = (Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TPartial<Type>> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<TObject, Properties> : Type extends TBigInt ? Type : Type extends TBoolean ? Type : Type extends TInteger ? Type : Type extends TLiteral ? Type : Type extends TNull ? Type : Type extends TNumber ? Type : Type extends TString ? Type : Type extends TSymbol ? Type : Type extends TUndefined ? Type : TObject<{}>);
+/** `[Json]` Constructs a type where all properties are optional */
+export declare function Partial<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>;
+/** `[Json]` Constructs a type where all properties are optional */
+export declare function Partial<Type extends TSchema>(type: Type, options?: SchemaOptions): TPartial<Type>;
+export {};

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

@@ -0,0 +1,111 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Partial = Partial;
+const type_1 = require("../create/type");
+const index_1 = require("../computed/index");
+const index_2 = require("../optional/index");
+const index_3 = require("../object/index");
+const index_4 = require("../intersect/index");
+const index_5 = require("../union/index");
+const index_6 = require("../ref/index");
+const index_7 = require("../discard/index");
+const index_8 = require("../symbols/index");
+const partial_from_mapped_result_1 = require("./partial-from-mapped-result");
+// ------------------------------------------------------------------
+// KindGuard
+// ------------------------------------------------------------------
+const KindGuard = __importStar(require("../guard/kind"));
+// prettier-ignore
+function FromComputed(target, parameters) {
+    return (0, index_1.Computed)('Partial', [(0, index_1.Computed)(target, parameters)]);
+}
+// prettier-ignore
+function FromRef($ref) {
+    return (0, index_1.Computed)('Partial', [(0, index_6.Ref)($ref)]);
+}
+// prettier-ignore
+function FromProperties(properties) {
+    const partialProperties = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(properties))
+        partialProperties[K] = (0, index_2.Optional)(properties[K]);
+    return partialProperties;
+}
+// prettier-ignore
+function FromObject(type, properties) {
+    const options = (0, index_7.Discard)(type, [index_8.TransformKind, '$id', 'required', 'properties']);
+    const mappedProperties = FromProperties(properties);
+    return (0, index_3.Object)(mappedProperties, options);
+}
+// prettier-ignore
+function FromRest(types) {
+    return types.map(type => PartialResolve(type));
+}
+// ------------------------------------------------------------------
+// PartialResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+function PartialResolve(type) {
+    return (
+    // Mappable
+    KindGuard.IsComputed(type) ? FromComputed(type.target, type.parameters) :
+        KindGuard.IsRef(type) ? FromRef(type.$ref) :
+            KindGuard.IsIntersect(type) ? (0, index_4.Intersect)(FromRest(type.allOf)) :
+                KindGuard.IsUnion(type) ? (0, index_5.Union)(FromRest(type.anyOf)) :
+                    KindGuard.IsObject(type) ? FromObject(type, type.properties) :
+                        // Intrinsic
+                        KindGuard.IsBigInt(type) ? type :
+                            KindGuard.IsBoolean(type) ? type :
+                                KindGuard.IsInteger(type) ? type :
+                                    KindGuard.IsLiteral(type) ? type :
+                                        KindGuard.IsNull(type) ? type :
+                                            KindGuard.IsNumber(type) ? type :
+                                                KindGuard.IsString(type) ? type :
+                                                    KindGuard.IsSymbol(type) ? type :
+                                                        KindGuard.IsUndefined(type) ? type :
+                                                            // Passthrough
+                                                            (0, index_3.Object)({}));
+}
+/** `[Json]` Constructs a type where all properties are optional */
+function Partial(type, options) {
+    if (KindGuard.IsMappedResult(type)) {
+        return (0, partial_from_mapped_result_1.PartialFromMappedResult)(type, options);
+    }
+    else {
+        // special: mapping types require overridable options
+        return (0, type_1.CreateType)({ ...PartialResolve(type), ...options });
+    }
+}

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

@@ -0,0 +1 @@
+export * from './patterns';

package/node_modules/@sinclair/typebox/build/cjs/type/patterns/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./patterns"), exports);

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

@@ -0,0 +1,8 @@
+export declare const PatternBoolean = "(true|false)";
+export declare const PatternNumber = "(0|[1-9][0-9]*)";
+export declare const PatternString = "(.*)";
+export declare const PatternNever = "(?!.*)";
+export declare const PatternBooleanExact = "^(true|false)$";
+export declare const PatternNumberExact = "^(0|[1-9][0-9]*)$";
+export declare const PatternStringExact = "^(.*)$";
+export declare const PatternNeverExact = "^(?!.*)$";

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternNeverExact = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternNever = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = void 0;
+exports.PatternBoolean = '(true|false)';
+exports.PatternNumber = '(0|[1-9][0-9]*)';
+exports.PatternString = '(.*)';
+exports.PatternNever = '(?!.*)';
+exports.PatternBooleanExact = `^${exports.PatternBoolean}$`;
+exports.PatternNumberExact = `^${exports.PatternNumber}$`;
+exports.PatternStringExact = `^${exports.PatternString}$`;
+exports.PatternNeverExact = `^${exports.PatternNever}$`;

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

@@ -0,0 +1,3 @@
+export * from './pick-from-mapped-key';
+export * from './pick-from-mapped-result';
+export * from './pick';

package/node_modules/@sinclair/typebox/build/cjs/type/pick/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./pick-from-mapped-key"), exports);
+__exportStar(require("./pick-from-mapped-result"), exports);
+__exportStar(require("./pick"), exports);

package/node_modules/@sinclair/typebox/build/cjs/type/pick/pick-from-mapped-key.d.ts

@@ -0,0 +1,12 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+import { type TPick } from './pick';
+type TFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+    [_ in Key]: TPick<Type, [Key]>;
+};
+type TFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (PropertyKeys extends [infer LeftKey extends PropertyKey, ...infer RightKeys extends PropertyKey[]] ? TFromPropertyKeys<Type, RightKeys, Result & TFromPropertyKey<Type, LeftKey>> : Result);
+type TFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey> = (TFromPropertyKeys<Type, MappedKey['keys']>);
+export type TPickFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TFromMappedKey<Type, MappedKey>> = (TMappedResult<Properties>);
+export declare function PickFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TFromMappedKey<Type, MappedKey>>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedResult<Properties>;
+export {};

package/node_modules/@sinclair/typebox/build/cjs/type/pick/pick-from-mapped-key.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PickFromMappedKey = PickFromMappedKey;
+const index_1 = require("../mapped/index");
+const pick_1 = require("./pick");
+const value_1 = require("../clone/value");
+// prettier-ignore
+function FromPropertyKey(type, key, options) {
+    return {
+        [key]: (0, pick_1.Pick)(type, [key], (0, value_1.Clone)(options))
+    };
+}
+// prettier-ignore
+function FromPropertyKeys(type, propertyKeys, options) {
+    return propertyKeys.reduce((result, leftKey) => {
+        return { ...result, ...FromPropertyKey(type, leftKey, options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedKey(type, mappedKey, options) {
+    return FromPropertyKeys(type, mappedKey.keys, options);
+}
+// prettier-ignore
+function PickFromMappedKey(type, mappedKey, options) {
+    const properties = FromMappedKey(type, mappedKey, options);
+    return (0, index_1.MappedResult)(properties);
+}

package/node_modules/@sinclair/typebox/build/cjs/type/pick/pick-from-mapped-result.d.ts

@@ -0,0 +1,12 @@
+import type { SchemaOptions } from '../schema/index';
+import type { Ensure, Evaluate } from '../helpers/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TPick } from './pick';
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = ({
+    [K2 in keyof Properties]: TPick<Properties[K2], PropertyKeys>;
+});
+type TFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[]> = (Evaluate<TFromProperties<MappedResult['properties'], PropertyKeys>>);
+export type TPickFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[], Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>> = (Ensure<TMappedResult<Properties>>);
+export declare function PickFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[], Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>>(mappedResult: MappedResult, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TMappedResult<Properties>;
+export {};

package/node_modules/@sinclair/typebox/build/cjs/type/pick/pick-from-mapped-result.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PickFromMappedResult = PickFromMappedResult;
+const index_1 = require("../mapped/index");
+const pick_1 = require("./pick");
+const value_1 = require("../clone/value");
+// prettier-ignore
+function FromProperties(properties, propertyKeys, options) {
+    const result = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+        result[K2] = (0, pick_1.Pick)(properties[K2], propertyKeys, (0, value_1.Clone)(options));
+    return result;
+}
+// prettier-ignore
+function FromMappedResult(mappedResult, propertyKeys, options) {
+    return FromProperties(mappedResult.properties, propertyKeys, options);
+}
+// prettier-ignore
+function PickFromMappedResult(mappedResult, propertyKeys, options) {
+    const properties = FromMappedResult(mappedResult, propertyKeys, options);
+    return (0, index_1.MappedResult)(properties);
+}

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

@@ -0,0 +1,36 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TupleToUnion, Evaluate } from '../helpers/index';
+import { type TRecursive } from '../recursive/index';
+import { type TComputed } from '../computed/index';
+import { type TIntersect } from '../intersect/index';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
+import { type TObject, type TProperties } from '../object/index';
+import { type TUnion } from '../union/index';
+import { type TMappedKey, type TMappedResult } from '../mapped/index';
+import { type TRef } from '../ref/index';
+import { type TIndexPropertyKeys } from '../indexed/index';
+import { type TPickFromMappedKey } from './pick-from-mapped-key';
+import { type TPickFromMappedResult } from './pick-from-mapped-result';
+type TFromIntersect<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, PropertyKeys, [...Result, TPick<L, PropertyKeys>]> : Result;
+type TFromUnion<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, PropertyKeys, [...Result, TPick<L, PropertyKeys>]> : Result;
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[], UnionKeys extends PropertyKey = TupleToUnion<PropertyKeys>> = (Evaluate<Pick<Properties, UnionKeys & keyof Properties>>);
+type TFromObject<_Type extends TObject, Keys extends PropertyKey[], Properties extends TProperties, MappedProperties extends TProperties = TFromProperties<Properties, Keys>, Result extends TSchema = TObject<MappedProperties>> = Result;
+type TUnionFromPropertyKeys<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = []> = (PropertyKeys extends [infer Key extends PropertyKey, ...infer Rest extends PropertyKey[]] ? Key extends TLiteralValue ? TUnionFromPropertyKeys<Rest, [...Result, TLiteral<Key>]> : TUnionFromPropertyKeys<Rest, [...Result]> : TUnion<Result>);
+export type TPickResolve<Type extends TProperties, PropertyKeys extends PropertyKey[]> = (Type extends TRecursive<infer Types extends TSchema> ? TRecursive<TPickResolve<Types, PropertyKeys>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromIntersect<Types, PropertyKeys>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromUnion<Types, PropertyKeys>> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<TObject, PropertyKeys, Properties> : TObject<{}>);
+type TResolvePropertyKeys<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key;
+type TResolveTypeKey<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key;
+export type TPick<Type extends TSchema, Key extends TSchema | PropertyKey[], IsTypeRef extends boolean = Type extends TRef ? true : false, IsKeyRef extends boolean = Key extends TRef ? true : false> = (Type extends TMappedResult ? TPickFromMappedResult<Type, TResolvePropertyKeys<Key>> : Key extends TMappedKey ? TPickFromMappedKey<Type, Key> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, true] ? TComputed<'Pick', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [false, true] ? TComputed<'Pick', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, false] ? TComputed<'Pick', [Type, TResolveTypeKey<Key>]> : TPickResolve<Type, TResolvePropertyKeys<Key>>);
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export declare function Pick<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TPick<Type, Key>;
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export declare function Pick<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TPick<Type, Key>;
+export {};

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

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pick = Pick;
+const type_1 = require("../create/type");
+const discard_1 = require("../discard/discard");
+const index_1 = require("../computed/index");
+const index_2 = require("../intersect/index");
+const index_3 = require("../literal/index");
+const index_4 = require("../object/index");
+const index_5 = require("../union/index");
+const index_6 = require("../indexed/index");
+const symbols_1 = require("../symbols/symbols");
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+const kind_1 = require("../guard/kind");
+const value_1 = require("../guard/value");
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+const pick_from_mapped_key_1 = require("./pick-from-mapped-key");
+const pick_from_mapped_result_1 = require("./pick-from-mapped-result");
+function FromIntersect(types, propertyKeys) {
+    return types.map((type) => PickResolve(type, propertyKeys));
+}
+// prettier-ignore
+function FromUnion(types, propertyKeys) {
+    return types.map((type) => PickResolve(type, propertyKeys));
+}
+// prettier-ignore
+function FromProperties(properties, propertyKeys) {
+    const result = {};
+    for (const K2 of propertyKeys)
+        if (K2 in properties)
+            result[K2] = properties[K2];
+    return result;
+}
+// prettier-ignore
+function FromObject(Type, keys, properties) {
+    const options = (0, discard_1.Discard)(Type, [symbols_1.TransformKind, '$id', 'required', 'properties']);
+    const mappedProperties = FromProperties(properties, keys);
+    return (0, index_4.Object)(mappedProperties, options);
+}
+// prettier-ignore
+function UnionFromPropertyKeys(propertyKeys) {
+    const result = propertyKeys.reduce((result, key) => (0, kind_1.IsLiteralValue)(key) ? [...result, (0, index_3.Literal)(key)] : result, []);
+    return (0, index_5.Union)(result);
+}
+// prettier-ignore
+function PickResolve(type, propertyKeys) {
+    return ((0, kind_1.IsIntersect)(type) ? (0, index_2.Intersect)(FromIntersect(type.allOf, propertyKeys)) :
+        (0, kind_1.IsUnion)(type) ? (0, index_5.Union)(FromUnion(type.anyOf, propertyKeys)) :
+            (0, kind_1.IsObject)(type) ? FromObject(type, propertyKeys, type.properties) :
+                (0, index_4.Object)({}));
+}
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+// prettier-ignore
+function Pick(type, key, options) {
+    const typeKey = (0, value_1.IsArray)(key) ? UnionFromPropertyKeys(key) : key;
+    const propertyKeys = (0, kind_1.IsSchema)(key) ? (0, index_6.IndexPropertyKeys)(key) : key;
+    const isTypeRef = (0, kind_1.IsRef)(type);
+    const isKeyRef = (0, kind_1.IsRef)(key);
+    return ((0, kind_1.IsMappedResult)(type) ? (0, pick_from_mapped_result_1.PickFromMappedResult)(type, propertyKeys, options) :
+        (0, kind_1.IsMappedKey)(key) ? (0, pick_from_mapped_key_1.PickFromMappedKey)(type, key, options) :
+            (isTypeRef && isKeyRef) ? (0, index_1.Computed)('Pick', [type, typeKey], options) :
+                (!isTypeRef && isKeyRef) ? (0, index_1.Computed)('Pick', [type, typeKey], options) :
+                    (isTypeRef && !isKeyRef) ? (0, index_1.Computed)('Pick', [type, typeKey], options) :
+                        (0, type_1.CreateType)({ ...PickResolve(type, propertyKeys), ...options }));
+}

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

@@ -0,0 +1 @@
+export * from './promise';

package/node_modules/@sinclair/typebox/build/cjs/type/promise/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./promise"), exports);

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

@@ -0,0 +1,11 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+export interface TPromise<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Promise';
+    static: Promise<Static<T, this['params']>>;
+    type: 'Promise';
+    item: TSchema;
+}
+/** `[JavaScript]` Creates a Promise type */
+export declare function Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;

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

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Promise = Promise;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+/** `[JavaScript]` Creates a Promise type */
+function Promise(item, options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Promise', type: 'Promise', item }, options);
+}

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

@@ -0,0 +1,2 @@
+export * from './readonly-from-mapped-result';
+export * from './readonly';

package/node_modules/@sinclair/typebox/build/cjs/type/readonly/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./readonly-from-mapped-result"), exports);
+__exportStar(require("./readonly"), exports);

package/node_modules/@sinclair/typebox/build/cjs/type/readonly/readonly-from-mapped-result.d.ts

@@ -0,0 +1,10 @@
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TReadonlyWithFlag } from './readonly';
+type TFromProperties<P extends TProperties, F extends boolean> = ({
+    [K2 in keyof P]: TReadonlyWithFlag<P[K2], F>;
+});
+type TFromMappedResult<R extends TMappedResult, F extends boolean> = (TFromProperties<R['properties'], F>);
+export type TReadonlyFromMappedResult<R extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<R, F>> = (TMappedResult<P>);
+export declare function ReadonlyFromMappedResult<R extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<R, F>>(R: R, F: F): TMappedResult<P>;
+export {};

package/node_modules/@sinclair/typebox/build/cjs/type/readonly/readonly-from-mapped-result.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadonlyFromMappedResult = ReadonlyFromMappedResult;
+const index_1 = require("../mapped/index");
+const readonly_1 = require("./readonly");
+// prettier-ignore
+function FromProperties(K, F) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = (0, readonly_1.Readonly)(K[K2], F);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult(R, F) {
+    return FromProperties(R.properties, F);
+}
+// prettier-ignore
+function ReadonlyFromMappedResult(R, F) {
+    const P = FromMappedResult(R, F);
+    return (0, index_1.MappedResult)(P);
+}

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

@@ -0,0 +1,20 @@
+import type { TSchema } from '../schema/index';
+import type { Ensure } from '../helpers/index';
+import { ReadonlyKind } from '../symbols/index';
+import type { TMappedResult } from '../mapped/index';
+import { type TReadonlyFromMappedResult } from './readonly-from-mapped-result';
+type TRemoveReadonly<T extends TSchema> = T extends TReadonly<infer S> ? S : T;
+type TAddReadonly<T extends TSchema> = T extends TReadonly<infer S> ? TReadonly<S> : Ensure<TReadonly<T>>;
+export type TReadonlyWithFlag<T extends TSchema, F extends boolean> = F extends false ? TRemoveReadonly<T> : TAddReadonly<T>;
+export type TReadonly<T extends TSchema> = T & {
+    [ReadonlyKind]: 'Readonly';
+};
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TReadonlyFromMappedResult<T, F>;
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TSchema, F extends boolean>(schema: T, enable: F): TReadonlyWithFlag<T, F>;
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TMappedResult>(schema: T): TReadonlyFromMappedResult<T, true>;
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TSchema>(schema: T): TReadonlyWithFlag<T, true>;
+export {};

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Readonly = Readonly;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+const index_2 = require("../discard/index");
+const readonly_from_mapped_result_1 = require("./readonly-from-mapped-result");
+const kind_1 = require("../guard/kind");
+function RemoveReadonly(schema) {
+    return (0, type_1.CreateType)((0, index_2.Discard)(schema, [index_1.ReadonlyKind]));
+}
+function AddReadonly(schema) {
+    return (0, type_1.CreateType)({ ...schema, [index_1.ReadonlyKind]: 'Readonly' });
+}
+// prettier-ignore
+function ReadonlyWithFlag(schema, F) {
+    return (F === false
+        ? RemoveReadonly(schema)
+        : AddReadonly(schema));
+}
+/** `[Json]` Creates a Readonly property */
+function Readonly(schema, enable) {
+    const F = enable ?? true;
+    return (0, kind_1.IsMappedResult)(schema) ? (0, readonly_from_mapped_result_1.ReadonlyFromMappedResult)(schema, F) : ReadonlyWithFlag(schema, F);
+}

package/node_modules/@sinclair/typebox/build/cjs/type/readonly-optional/index.d.ts

@@ -0,0 +1 @@
+export * from './readonly-optional';

package/node_modules/@sinclair/typebox/build/cjs/type/readonly-optional/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./readonly-optional"), exports);

package/node_modules/@sinclair/typebox/build/cjs/type/readonly-optional/readonly-optional.d.ts

@@ -0,0 +1,6 @@
+import type { TSchema } from '../schema/index';
+import { type TReadonly } from '../readonly/index';
+import { type TOptional } from '../optional/index';
+export type TReadonlyOptional<T extends TSchema> = TOptional<T> & TReadonly<T>;
+/** `[Json]` Creates a Readonly and Optional property */
+export declare function ReadonlyOptional<T extends TSchema>(schema: T): TReadonly<TOptional<T>>;

package/node_modules/@sinclair/typebox/build/cjs/type/readonly-optional/readonly-optional.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadonlyOptional = ReadonlyOptional;
+const index_1 = require("../readonly/index");
+const index_2 = require("../optional/index");
+/** `[Json]` Creates a Readonly and Optional property */
+function ReadonlyOptional(schema) {
+    return (0, index_1.Readonly)((0, index_2.Optional)(schema));
+}