dataiku-sdk 0.2.0 → 0.2.1

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

@@ -0,0 +1,10 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TNot<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Not';
+    static: T extends TNot<infer U> ? Static<U> : unknown;
+    not: T;
+}
+/** `[Json]` Creates a Not type */
+export declare function Not<Type extends TSchema>(type: Type, options?: SchemaOptions): TNot<Type>;

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

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates a Not type */
+export function Not(type, options) {
+    return CreateType({ [Kind]: 'Not', not: type }, options);
+}

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

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

package/node_modules/@sinclair/typebox/build/esm/type/null/index.mjs

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

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

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TNull extends TSchema {
+    [Kind]: 'Null';
+    static: null;
+    type: 'null';
+}
+/** `[Json]` Creates a Null type */
+export declare function Null(options?: SchemaOptions): TNull;

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

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates a Null type */
+export function Null(options) {
+    return CreateType({ [Kind]: 'Null', type: 'null' }, options);
+}

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

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

package/node_modules/@sinclair/typebox/build/esm/type/number/index.mjs

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

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

@@ -0,0 +1,16 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface NumberOptions extends SchemaOptions {
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    minimum?: number;
+    multipleOf?: number;
+}
+export interface TNumber extends TSchema, NumberOptions {
+    [Kind]: 'Number';
+    static: number;
+    type: 'number';
+}
+/** `[Json]` Creates a Number type */
+export declare function Number(options?: NumberOptions): TNumber;

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

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates a Number type */
+export function Number(options) {
+    return CreateType({ [Kind]: 'Number', type: 'number' }, options);
+}

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

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

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

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

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

@@ -0,0 +1,51 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import type { Evaluate, UnionToTuple } from '../helpers/index.mjs';
+import type { TReadonly } from '../readonly/index.mjs';
+import type { TOptional } from '../optional/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
+}[keyof T];
+type ReadonlyPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never;
+}[keyof T];
+type OptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never;
+}[keyof T];
+type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
+type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
+type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
+    [K in keyof T]: Static<T[K], P>;
+}>;
+export type TPropertyKey = string | number;
+export type TProperties = Record<TPropertyKey, TSchema>;
+type TIsLiteralString<Type extends string> = ([
+    Type
+] extends [string] ? [string] extends [Type] ? false : true : false);
+type IsRequiredArrayLiteralConstant<RequiredTuple extends string[]> = (RequiredTuple extends [infer Left extends string, ...infer _ extends string[]] ? TIsLiteralString<Left> : false);
+type TRequiredArray<Properties extends TProperties, RequiredProperties extends TProperties = {
+    [Key in keyof Properties as Properties[Key] extends TOptional<Properties[Key]> ? never : Key]: Properties[Key];
+}, RequiredUnion extends string = Extract<keyof RequiredProperties, string>, RequiredTuple extends string[] = UnionToTuple<RequiredUnion>, Result extends string[] | undefined = (IsRequiredArrayLiteralConstant<RequiredTuple> extends true ? RequiredTuple : string[] | undefined)> = Result;
+export type TAdditionalProperties = undefined | TSchema | boolean;
+export interface ObjectOptions extends SchemaOptions {
+    /** Additional property constraints for this object */
+    additionalProperties?: TAdditionalProperties;
+    /** The minimum number of properties allowed on this object */
+    minProperties?: number;
+    /** The maximum number of properties allowed on this object */
+    maxProperties?: number;
+}
+export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+    [Kind]: 'Object';
+    static: ObjectStatic<T, this['params']>;
+    additionalProperties?: TAdditionalProperties;
+    type: 'object';
+    properties: T;
+    required: TRequiredArray<T>;
+}
+/** `[Json]` Creates an Object type */
+declare function _Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+/** `[Json]` Creates an Object type */
+export declare var Object: typeof _Object;
+export {};

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

@@ -0,0 +1,18 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsOptional } from '../guard/kind.mjs';
+/** Creates a RequiredArray derived from the given TProperties value. */
+function RequiredArray(properties) {
+    return globalThis.Object.keys(properties).filter((key) => !IsOptional(properties[key]));
+}
+/** `[Json]` Creates an Object type */
+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);
+}
+/** `[Json]` Creates an Object type */
+export var Object = _Object;

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

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

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

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

package/node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-key.d.mts

@@ -0,0 +1,12 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { type TOmit } from './omit.mjs';
+type TFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+    [_ in Key]: TOmit<Type, [Key]>;
+};
+type TFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (PropertyKeys extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? TFromPropertyKeys<Type, RK, Result & TFromPropertyKey<Type, LK>> : Result);
+type TFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey> = (TFromPropertyKeys<Type, MappedKey['keys']>);
+export type TOmitFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TFromMappedKey<Type, MappedKey>> = (TMappedResult<Properties>);
+export declare function OmitFromMappedKey<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/esm/type/omit/omit-from-mapped-key.mjs

@@ -0,0 +1,22 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Omit } from './omit.mjs';
+import { Clone } from '../clone/value.mjs';
+// prettier-ignore
+function FromPropertyKey(type, key, options) {
+    return { [key]: Omit(type, [key], Clone(options)) };
+}
+// prettier-ignore
+function FromPropertyKeys(type, propertyKeys, options) {
+    return propertyKeys.reduce((Acc, LK) => {
+        return { ...Acc, ...FromPropertyKey(type, LK, options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedKey(type, mappedKey, options) {
+    return FromPropertyKeys(type, mappedKey.keys, options);
+}
+// prettier-ignore
+export function OmitFromMappedKey(type, mappedKey, options) {
+    const properties = FromMappedKey(type, mappedKey, options);
+    return MappedResult(properties);
+}

package/node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-result.d.mts

@@ -0,0 +1,12 @@
+import type { SchemaOptions } from '../schema/index.mjs';
+import type { Ensure, Evaluate } from '../helpers/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TOmit } from './omit.mjs';
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = ({
+    [K2 in keyof Properties]: TOmit<Properties[K2], PropertyKeys>;
+});
+type TFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[]> = (Evaluate<TFromProperties<MappedResult['properties'], PropertyKeys>>);
+export type TOmitFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[], Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>> = (Ensure<TMappedResult<Properties>>);
+export declare function OmitFromMappedResult<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/esm/type/omit/omit-from-mapped-result.mjs

@@ -0,0 +1,19 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Omit } from './omit.mjs';
+import { Clone } from '../clone/value.mjs';
+// prettier-ignore
+function FromProperties(properties, propertyKeys, options) {
+    const result = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+        result[K2] = Omit(properties[K2], propertyKeys, Clone(options));
+    return result;
+}
+// prettier-ignore
+function FromMappedResult(mappedResult, propertyKeys, options) {
+    return FromProperties(mappedResult.properties, propertyKeys, options);
+}
+// prettier-ignore
+export function OmitFromMappedResult(mappedResult, propertyKeys, options) {
+    const properties = FromMappedResult(mappedResult, propertyKeys, options);
+    return MappedResult(properties);
+}

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

@@ -0,0 +1,36 @@
+import type { SchemaOptions, TSchema } from '../schema/index.mjs';
+import type { TupleToUnion, Evaluate } from '../helpers/index.mjs';
+import { type TRecursive } from '../recursive/index.mjs';
+import type { TMappedKey, TMappedResult } from '../mapped/index.mjs';
+import { TComputed } from '../computed/index.mjs';
+import { TLiteral, TLiteralValue } from '../literal/index.mjs';
+import { type TIndexPropertyKeys } from '../indexed/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
+import { type TRef } from '../ref/index.mjs';
+import { type TOmitFromMappedKey } from './omit-from-mapped-key.mjs';
+import { type TOmitFromMappedResult } from './omit-from-mapped-result.mjs';
+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, TOmit<L, PropertyKeys>]> : Result);
+type TFromUnion<T extends TSchema[], K extends PropertyKey[], Result extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, K, [...Result, TOmit<L, K>]> : Result);
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[], UnionKey extends PropertyKey = TupleToUnion<PropertyKeys>> = (Evaluate<Omit<Properties, UnionKey>>);
+type TFromObject<_Type extends TObject, PropertyKeys extends PropertyKey[], Properties extends TProperties, MappedProperties extends TProperties = TFromProperties<Properties, PropertyKeys>, 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 TOmitResolve<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = (Properties extends TRecursive<infer Types extends TSchema> ? TRecursive<TOmitResolve<Types, PropertyKeys>> : Properties extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromIntersect<Types, PropertyKeys>> : Properties extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromUnion<Types, PropertyKeys>> : Properties 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 TOmit<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 ? TOmitFromMappedResult<Type, TResolvePropertyKeys<Key>> : Key extends TMappedKey ? TOmitFromMappedKey<Type, Key> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, true] ? TComputed<'Omit', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [false, true] ? TComputed<'Omit', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, false] ? TComputed<'Omit', [Type, TResolveTypeKey<Key>]> : TOmitResolve<Type, TResolvePropertyKeys<Key>>);
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export declare function Omit<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TOmit<Type, Key>;
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export declare function Omit<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TOmit<Type, Key>;
+export {};

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

@@ -0,0 +1,71 @@
+import { CreateType } from '../create/type.mjs';
+import { Discard } from '../discard/discard.mjs';
+import { TransformKind } from '../symbols/symbols.mjs';
+import { Computed } from '../computed/index.mjs';
+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';
+// ------------------------------------------------------------------
+// Mapped
+// ------------------------------------------------------------------
+import { OmitFromMappedKey } from './omit-from-mapped-key.mjs';
+import { OmitFromMappedResult } from './omit-from-mapped-result.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema, IsMappedResult, IsLiteralValue, IsRef } from '../guard/kind.mjs';
+import { IsArray as IsArrayValue } from '../guard/value.mjs';
+// prettier-ignore
+function FromIntersect(types, propertyKeys) {
+    return types.map((type) => OmitResolve(type, propertyKeys));
+}
+// prettier-ignore
+function FromUnion(types, propertyKeys) {
+    return types.map((type) => OmitResolve(type, propertyKeys));
+}
+// ------------------------------------------------------------------
+// FromProperty
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromProperty(properties, key) {
+    const { [key]: _, ...R } = properties;
+    return R;
+}
+// prettier-ignore
+function FromProperties(properties, propertyKeys) {
+    return propertyKeys.reduce((T, K2) => FromProperty(T, K2), properties);
+}
+// prettier-ignore
+function FromObject(type, propertyKeys, properties) {
+    const options = Discard(type, [TransformKind, '$id', 'required', 'properties']);
+    const mappedProperties = FromProperties(properties, propertyKeys);
+    return Object(mappedProperties, options);
+}
+// prettier-ignore
+function UnionFromPropertyKeys(propertyKeys) {
+    const result = propertyKeys.reduce((result, key) => IsLiteralValue(key) ? [...result, Literal(key)] : result, []);
+    return Union(result);
+}
+// prettier-ignore
+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({}));
+}
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+// prettier-ignore
+export function Omit(type, key, options) {
+    const typeKey = IsArrayValue(key) ? UnionFromPropertyKeys(key) : key;
+    const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
+    const isTypeRef = IsRef(type);
+    const isKeyRef = IsRef(key);
+    return (IsMappedResult(type) ? OmitFromMappedResult(type, propertyKeys, options) :
+        IsMappedKey(key) ? OmitFromMappedKey(type, key, options) :
+            (isTypeRef && isKeyRef) ? Computed('Omit', [type, typeKey], options) :
+                (!isTypeRef && isKeyRef) ? Computed('Omit', [type, typeKey], options) :
+                    (isTypeRef && !isKeyRef) ? Computed('Omit', [type, typeKey], options) :
+                        CreateType({ ...OmitResolve(type, propertyKeys), ...options }));
+}

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

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

package/node_modules/@sinclair/typebox/build/esm/type/optional/index.mjs

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

package/node_modules/@sinclair/typebox/build/esm/type/optional/optional-from-mapped-result.d.mts

@@ -0,0 +1,10 @@
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TOptionalWithFlag } from './optional.mjs';
+type TFromProperties<P extends TProperties, F extends boolean> = ({
+    [K2 in keyof P]: TOptionalWithFlag<P[K2], F>;
+});
+type TFromMappedResult<R extends TMappedResult, F extends boolean> = (TFromProperties<R['properties'], F>);
+export type TOptionalFromMappedResult<R extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<R, F>> = (TMappedResult<P>);
+export declare function OptionalFromMappedResult<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/esm/type/optional/optional-from-mapped-result.mjs

@@ -0,0 +1,18 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Optional } from './optional.mjs';
+// prettier-ignore
+function FromProperties(P, F) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Optional(P[K2], F);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult(R, F) {
+    return FromProperties(R.properties, F);
+}
+// prettier-ignore
+export function OptionalFromMappedResult(R, F) {
+    const P = FromMappedResult(R, F);
+    return MappedResult(P);
+}

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

@@ -0,0 +1,20 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { Ensure } from '../helpers/index.mjs';
+import { OptionalKind } from '../symbols/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
+import { type TOptionalFromMappedResult } from './optional-from-mapped-result.mjs';
+type TRemoveOptional<T extends TSchema> = T extends TOptional<infer S> ? S : T;
+type TAddOptional<T extends TSchema> = T extends TOptional<infer S> ? TOptional<S> : Ensure<TOptional<T>>;
+export type TOptionalWithFlag<T extends TSchema, F extends boolean> = F extends false ? TRemoveOptional<T> : TAddOptional<T>;
+export type TOptional<T extends TSchema> = T & {
+    [OptionalKind]: 'Optional';
+};
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TOptionalFromMappedResult<T, F>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TSchema, F extends boolean>(schema: T, enable: F): TOptionalWithFlag<T, F>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TMappedResult>(schema: T): TOptionalFromMappedResult<T, true>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TSchema>(schema: T): TOptionalWithFlag<T, true>;
+export {};

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

@@ -0,0 +1,22 @@
+import { CreateType } from '../create/type.mjs';
+import { OptionalKind } from '../symbols/index.mjs';
+import { Discard } from '../discard/index.mjs';
+import { OptionalFromMappedResult } from './optional-from-mapped-result.mjs';
+import { IsMappedResult } from '../guard/kind.mjs';
+function RemoveOptional(schema) {
+    return CreateType(Discard(schema, [OptionalKind]));
+}
+function AddOptional(schema) {
+    return CreateType({ ...schema, [OptionalKind]: 'Optional' });
+}
+// prettier-ignore
+function OptionalWithFlag(schema, F) {
+    return (F === false
+        ? RemoveOptional(schema)
+        : AddOptional(schema));
+}
+/** `[Json]` Creates a Optional property */
+export function Optional(schema, enable) {
+    const F = enable ?? true;
+    return IsMappedResult(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
+}

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

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

package/node_modules/@sinclair/typebox/build/esm/type/parameters/index.mjs

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

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

@@ -0,0 +1,7 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TFunction } from '../function/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
+import { type TNever } from '../never/index.mjs';
+export type TParameters<Type extends TSchema> = (Type extends TFunction<infer Parameters extends TSchema[], infer _ReturnType extends TSchema> ? TTuple<Parameters> : TNever);
+/** `[JavaScript]` Extracts the Parameters from the given Function type */
+export declare function Parameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TParameters<Type>;

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

@@ -0,0 +1,7 @@
+import { Tuple } from '../tuple/index.mjs';
+import { Never } from '../never/index.mjs';
+import * as KindGuard from '../guard/kind.mjs';
+/** `[JavaScript]` Extracts the Parameters from the given Function type */
+export function Parameters(schema, options) {
+    return (KindGuard.IsFunction(schema) ? Tuple(schema.parameters, options) : Never());
+}

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

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

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

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

package/node_modules/@sinclair/typebox/build/esm/type/partial/partial-from-mapped-result.d.mts

@@ -0,0 +1,12 @@
+import type { SchemaOptions } from '../schema/index.mjs';
+import type { Ensure, Evaluate } from '../helpers/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TPartial } from './partial.mjs';
+type TFromProperties<P extends TProperties> = ({
+    [K2 in keyof P]: TPartial<P[K2]>;
+});
+type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
+export type TPartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
+export declare function PartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options?: SchemaOptions): TMappedResult<P>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/partial/partial-from-mapped-result.mjs

@@ -0,0 +1,19 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Partial } from './partial.mjs';
+import { Clone } from '../clone/value.mjs';
+// prettier-ignore
+function FromProperties(K, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = Partial(K[K2], Clone(options));
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult(R, options) {
+    return FromProperties(R.properties, options);
+}
+// prettier-ignore
+export function PartialFromMappedResult(R, options) {
+    const P = FromMappedResult(R, options);
+    return MappedResult(P);
+}

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

@@ -0,0 +1,35 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Evaluate, Ensure } from '../helpers/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
+import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
+import { type TComputed } from '../computed/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
+import { type TReadonly } from '../readonly/index.mjs';
+import { type TRecursive } from '../recursive/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TRef } from '../ref/index.mjs';
+import { type TBigInt } from '../bigint/index.mjs';
+import { type TBoolean } from '../boolean/index.mjs';
+import { type TInteger } from '../integer/index.mjs';
+import { type TLiteral } from '../literal/index.mjs';
+import { type TNull } from '../null/index.mjs';
+import { type TNumber } from '../number/index.mjs';
+import { type TString } from '../string/index.mjs';
+import { type TSymbol } from '../symbol/index.mjs';
+import { type TUndefined } from '../undefined/index.mjs';
+import { type TPartialFromMappedResult } from './partial-from-mapped-result.mjs';
+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/esm/type/partial/partial.mjs

@@ -0,0 +1,74 @@
+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 { Intersect } from '../intersect/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Ref } from '../ref/index.mjs';
+import { Discard } from '../discard/index.mjs';
+import { TransformKind } from '../symbols/index.mjs';
+import { PartialFromMappedResult } from './partial-from-mapped-result.mjs';
+// ------------------------------------------------------------------
+// KindGuard
+// ------------------------------------------------------------------
+import * as KindGuard from '../guard/kind.mjs';
+// prettier-ignore
+function FromComputed(target, parameters) {
+    return Computed('Partial', [Computed(target, parameters)]);
+}
+// prettier-ignore
+function FromRef($ref) {
+    return Computed('Partial', [Ref($ref)]);
+}
+// prettier-ignore
+function FromProperties(properties) {
+    const partialProperties = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(properties))
+        partialProperties[K] = Optional(properties[K]);
+    return partialProperties;
+}
+// prettier-ignore
+function FromObject(type, properties) {
+    const options = Discard(type, [TransformKind, '$id', 'required', 'properties']);
+    const mappedProperties = FromProperties(properties);
+    return 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) ? Intersect(FromRest(type.allOf)) :
+                KindGuard.IsUnion(type) ? 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
+                                                            Object({}));
+}
+/** `[Json]` Constructs a type where all properties are optional */
+export function Partial(type, options) {
+    if (KindGuard.IsMappedResult(type)) {
+        return PartialFromMappedResult(type, options);
+    }
+    else {
+        // special: mapping types require overridable options
+        return CreateType({ ...PartialResolve(type), ...options });
+    }
+}

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

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

package/node_modules/@sinclair/typebox/build/esm/type/patterns/index.mjs

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