dataiku-sdk 0.2.0 → 0.2.1

package/node_modules/@sinclair/typebox/build/cjs/type/instance-type/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("./instance-type"), exports);

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

@@ -0,0 +1,6 @@
+import { type TSchema, SchemaOptions } from '../schema/index';
+import { type TConstructor } from '../constructor/index';
+import { type TNever } from '../never/index';
+export type TInstanceType<Type extends TSchema, Result extends TSchema = Type extends TConstructor<infer _Parameters extends TSchema[], infer InstanceType extends TSchema> ? InstanceType : TNever> = Result;
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+export declare function InstanceType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TInstanceType<Type>;

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

@@ -0,0 +1,44 @@
+"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.InstanceType = InstanceType;
+const type_1 = require("../create/type");
+const index_1 = require("../never/index");
+const KindGuard = __importStar(require("../guard/kind"));
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+function InstanceType(schema, options) {
+    return (KindGuard.IsConstructor(schema) ? (0, type_1.CreateType)(schema.returns, options) : (0, index_1.Never)(options));
+}

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

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

package/node_modules/@sinclair/typebox/build/cjs/type/instantiate/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("./instantiate"), exports);

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

@@ -0,0 +1,50 @@
+import { type TSchema } from '../schema/index';
+import { type TArgument } from '../argument/index';
+import { type TUnknown } from '../unknown/index';
+import { type TReadonlyOptional } from '../readonly-optional/index';
+import { type TReadonly } from '../readonly/index';
+import { type TOptional } from '../optional/index';
+import { type TConstructor } from '../constructor/index';
+import { type TFunction } from '../function/index';
+import { type TIntersect } from '../intersect/index';
+import { type TUnion } from '../union/index';
+import { type TTuple } from '../tuple/index';
+import { type TArray } from '../array/index';
+import { type TAsyncIterator } from '../async-iterator/index';
+import { type TIterator } from '../iterator/index';
+import { type TPromise } from '../promise/index';
+import { type TObject, type TProperties } from '../object/index';
+import { type TRecordOrObject, type TRecord } from '../record/index';
+type TFromConstructor<Args extends TSchema[], Parameters extends TSchema[], InstanceType extends TSchema, Result extends TConstructor = TConstructor<TFromTypes<Args, Parameters>, TFromType<Args, InstanceType>>> = Result;
+type TFromFunction<Args extends TSchema[], Parameters extends TSchema[], ReturnType extends TSchema, Result extends TFunction = TFunction<TFromTypes<Args, Parameters>, TFromType<Args, ReturnType>>> = Result;
+type TFromIntersect<Args extends TSchema[], Types extends TSchema[], Result extends TIntersect = TIntersect<TFromTypes<Args, Types>>> = Result;
+type TFromUnion<Args extends TSchema[], Types extends TSchema[], Result extends TUnion = TUnion<TFromTypes<Args, Types>>> = Result;
+type TFromTuple<Args extends TSchema[], Types extends TSchema[], Result extends TTuple = TTuple<TFromTypes<Args, Types>>> = Result;
+type TFromArray<Args extends TSchema[], Type extends TSchema, Result extends TArray = TArray<TFromType<Args, Type>>> = Result;
+type TFromAsyncIterator<Args extends TSchema[], Type extends TSchema, Result extends TAsyncIterator = TAsyncIterator<TFromType<Args, Type>>> = Result;
+type TFromIterator<Args extends TSchema[], Type extends TSchema, Result extends TIterator = TIterator<TFromType<Args, Type>>> = Result;
+type TFromPromise<Args extends TSchema[], Type extends TSchema, Result extends TPromise = TPromise<TFromType<Args, Type>>> = Result;
+type TFromObject<Args extends TSchema[], Properties extends TProperties, MappedProperties extends TProperties = TFromProperties<Args, Properties>, Result extends TSchema = TObject<MappedProperties>> = Result;
+type TFromRecord<Args extends TSchema[], Key extends TSchema, Value extends TSchema, MappedKey extends TSchema = TFromType<Args, Key>, MappedValue extends TSchema = TFromType<Args, Value>, Result extends TSchema = TRecordOrObject<MappedKey, MappedValue>> = Result;
+type TFromArgument<Args extends TSchema[], Index extends number, Result extends TSchema = Index extends keyof Args[Index] ? Args[Index] : TUnknown> = Result;
+type TFromProperty<Args extends TSchema[], Type extends TSchema, IsReadonly extends boolean = Type extends TReadonly<Type> ? true : false, IsOptional extends boolean = Type extends TOptional<Type> ? true : false, Mapped extends TSchema = TFromType<Args, Type>, Result extends TSchema = ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? TReadonlyOptional<Mapped> : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? TReadonly<Mapped> : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? TOptional<Mapped> : Mapped)> = Result;
+type TFromProperties<Args extends TSchema[], Properties extends TProperties, Result extends TProperties = {
+    [Key in keyof Properties]: TFromProperty<Args, Properties[Key]>;
+}> = Result;
+export type TFromTypes<Args extends TSchema[], Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Args, Right, [...Result, TFromType<Args, Left>]> : Result);
+export declare function FromTypes<Args extends TSchema[], Types extends TSchema[]>(args: [...Args], types: [...Types]): TFromTypes<Args, Types>;
+export type TFromType<Args extends TSchema[], Type extends TSchema> = (Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<Args, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<Args, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Args, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Args, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Args, Types> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Args, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<Args, Type> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<Args, Type> : Type extends TPromise<infer Type extends TSchema> ? TFromPromise<Args, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Args, Properties> : Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TFromRecord<Args, Key, Value> : Type extends TArgument<infer Index extends number> ? TFromArgument<Args, Index> : Type);
+/** `[JavaScript]` Instantiates a type with the given parameters */
+export type TInstantiate<Type extends TSchema, Args extends TSchema[], Result extends TSchema = TFromType<Args, Type>> = Result;
+/** `[JavaScript]` Instantiates a type with the given parameters */
+export declare function Instantiate<Type extends TSchema, Args extends TSchema[]>(type: Type, args: [...Args]): TInstantiate<Type, Args>;
+export {};

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

@@ -0,0 +1,153 @@
+"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.FromTypes = FromTypes;
+exports.Instantiate = Instantiate;
+const type_1 = require("../clone/type");
+const index_1 = require("../unknown/index");
+const index_2 = require("../readonly-optional/index");
+const index_3 = require("../readonly/index");
+const index_4 = require("../optional/index");
+const index_5 = require("../object/index");
+const index_6 = require("../record/index");
+const ValueGuard = __importStar(require("../guard/value"));
+const KindGuard = __importStar(require("../guard/kind"));
+// prettier-ignore
+function FromConstructor(args, type) {
+    type.parameters = FromTypes(args, type.parameters);
+    type.returns = FromType(args, type.returns);
+    return type;
+}
+// prettier-ignore
+function FromFunction(args, type) {
+    type.parameters = FromTypes(args, type.parameters);
+    type.returns = FromType(args, type.returns);
+    return type;
+}
+// prettier-ignore
+function FromIntersect(args, type) {
+    type.allOf = FromTypes(args, type.allOf);
+    return type;
+}
+// prettier-ignore
+function FromUnion(args, type) {
+    type.anyOf = FromTypes(args, type.anyOf);
+    return type;
+}
+// prettier-ignore
+function FromTuple(args, type) {
+    if (ValueGuard.IsUndefined(type.items))
+        return type;
+    type.items = FromTypes(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromArray(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromAsyncIterator(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromIterator(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromPromise(args, type) {
+    type.item = FromType(args, type.item);
+    return type;
+}
+// prettier-ignore
+function FromObject(args, type) {
+    const mappedProperties = FromProperties(args, type.properties);
+    return { ...type, ...(0, index_5.Object)(mappedProperties) }; // retain options
+}
+// prettier-ignore
+function FromRecord(args, type) {
+    const mappedKey = FromType(args, (0, index_6.RecordKey)(type));
+    const mappedValue = FromType(args, (0, index_6.RecordValue)(type));
+    const result = (0, index_6.Record)(mappedKey, mappedValue);
+    return { ...type, ...result }; // retain options
+}
+// prettier-ignore
+function FromArgument(args, argument) {
+    return argument.index in args ? args[argument.index] : (0, index_1.Unknown)();
+}
+// prettier-ignore
+function FromProperty(args, type) {
+    const isReadonly = KindGuard.IsReadonly(type);
+    const isOptional = KindGuard.IsOptional(type);
+    const mapped = FromType(args, type);
+    return (isReadonly && isOptional ? (0, index_2.ReadonlyOptional)(mapped) :
+        isReadonly && !isOptional ? (0, index_3.Readonly)(mapped) :
+            !isReadonly && isOptional ? (0, index_4.Optional)(mapped) :
+                mapped);
+}
+// prettier-ignore
+function FromProperties(args, properties) {
+    return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+        return { ...result, [key]: FromProperty(args, properties[key]) };
+    }, {});
+}
+// prettier-ignore
+function FromTypes(args, types) {
+    return types.map(type => FromType(args, type));
+}
+// prettier-ignore
+function FromType(args, type) {
+    return (KindGuard.IsConstructor(type) ? FromConstructor(args, type) :
+        KindGuard.IsFunction(type) ? FromFunction(args, type) :
+            KindGuard.IsIntersect(type) ? FromIntersect(args, type) :
+                KindGuard.IsUnion(type) ? FromUnion(args, type) :
+                    KindGuard.IsTuple(type) ? FromTuple(args, type) :
+                        KindGuard.IsArray(type) ? FromArray(args, type) :
+                            KindGuard.IsAsyncIterator(type) ? FromAsyncIterator(args, type) :
+                                KindGuard.IsIterator(type) ? FromIterator(args, type) :
+                                    KindGuard.IsPromise(type) ? FromPromise(args, type) :
+                                        KindGuard.IsObject(type) ? FromObject(args, type) :
+                                            KindGuard.IsRecord(type) ? FromRecord(args, type) :
+                                                KindGuard.IsArgument(type) ? FromArgument(args, type) :
+                                                    type);
+}
+/** `[JavaScript]` Instantiates a type with the given parameters */
+// prettier-ignore
+function Instantiate(type, args) {
+    return FromType(args, (0, type_1.CloneType)(type));
+}

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

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

package/node_modules/@sinclair/typebox/build/cjs/type/integer/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("./integer"), exports);

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

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

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

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

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

@@ -0,0 +1,3 @@
+export * from './intersect-evaluated';
+export * from './intersect-type';
+export * from './intersect';

package/node_modules/@sinclair/typebox/build/cjs/type/intersect/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("./intersect-evaluated"), exports);
+__exportStar(require("./intersect-type"), exports);
+__exportStar(require("./intersect"), exports);

package/node_modules/@sinclair/typebox/build/cjs/type/intersect/intersect-create.d.ts

@@ -0,0 +1,3 @@
+import type { TSchema } from '../schema/index';
+import type { TIntersect, IntersectOptions } from './intersect-type';
+export declare function IntersectCreate<T extends TSchema[]>(T: [...T], options?: IntersectOptions): TIntersect<T>;

package/node_modules/@sinclair/typebox/build/cjs/type/intersect/intersect-create.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntersectCreate = IntersectCreate;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../guard/kind");
+// ------------------------------------------------------------------
+// IntersectCreate
+// ------------------------------------------------------------------
+// prettier-ignore
+function IntersectCreate(T, options = {}) {
+    const allObjects = T.every((schema) => (0, kind_1.IsObject)(schema));
+    const clonedUnevaluatedProperties = (0, kind_1.IsSchema)(options.unevaluatedProperties)
+        ? { unevaluatedProperties: options.unevaluatedProperties }
+        : {};
+    return (0, type_1.CreateType)((options.unevaluatedProperties === false || (0, kind_1.IsSchema)(options.unevaluatedProperties) || allObjects
+        ? { ...clonedUnevaluatedProperties, [index_1.Kind]: 'Intersect', type: 'object', allOf: T }
+        : { ...clonedUnevaluatedProperties, [index_1.Kind]: 'Intersect', allOf: T }), options);
+}

package/node_modules/@sinclair/typebox/build/cjs/type/intersect/intersect-evaluated.d.ts

@@ -0,0 +1,13 @@
+import type { TSchema } from '../schema/index';
+import { type TNever } from '../never/index';
+import { type TOptional } from '../optional/index';
+import type { TReadonly } from '../readonly/index';
+import { TIntersect, IntersectOptions } from './intersect-type';
+type TIsIntersectOptional<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<TSchema> ? TIsIntersectOptional<Right> : false : true);
+type TRemoveOptionalFromType<Type extends TSchema> = (Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType<Type>> : Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType<Type> : Type);
+type TRemoveOptionalFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromRest<Right, [...Result, TRemoveOptionalFromType<Type>]> : TRemoveOptionalFromRest<Right, [...Result, Left]> : Result);
+type TResolveIntersect<Types extends TSchema[]> = (TIsIntersectOptional<Types> extends true ? TOptional<TIntersect<TRemoveOptionalFromRest<Types>>> : TIntersect<TRemoveOptionalFromRest<Types>>);
+export type TIntersectEvaluated<Types extends TSchema[]> = (Types extends [TSchema] ? Types[0] : Types extends [] ? TNever : TResolveIntersect<Types>);
+/** `[Json]` Creates an evaluated Intersect type */
+export declare function IntersectEvaluated<Types extends TSchema[], Result extends TSchema = TIntersectEvaluated<Types>>(types: [...Types], options?: IntersectOptions): Result;
+export {};

package/node_modules/@sinclair/typebox/build/cjs/type/intersect/intersect-evaluated.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntersectEvaluated = IntersectEvaluated;
+const index_1 = require("../symbols/index");
+const type_1 = require("../create/type");
+const index_2 = require("../discard/index");
+const index_3 = require("../never/index");
+const index_4 = require("../optional/index");
+const intersect_create_1 = require("./intersect-create");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../guard/kind");
+// prettier-ignore
+function IsIntersectOptional(types) {
+    return types.every(left => (0, kind_1.IsOptional)(left));
+}
+// prettier-ignore
+function RemoveOptionalFromType(type) {
+    return ((0, index_2.Discard)(type, [index_1.OptionalKind]));
+}
+// prettier-ignore
+function RemoveOptionalFromRest(types) {
+    return types.map(left => (0, kind_1.IsOptional)(left) ? RemoveOptionalFromType(left) : left);
+}
+// prettier-ignore
+function ResolveIntersect(types, options) {
+    return (IsIntersectOptional(types)
+        ? (0, index_4.Optional)((0, intersect_create_1.IntersectCreate)(RemoveOptionalFromRest(types), options))
+        : (0, intersect_create_1.IntersectCreate)(RemoveOptionalFromRest(types), options));
+}
+/** `[Json]` Creates an evaluated Intersect type */
+function IntersectEvaluated(types, options = {}) {
+    if (types.length === 1)
+        return (0, type_1.CreateType)(types[0], options);
+    if (types.length === 0)
+        return (0, index_3.Never)(options);
+    if (types.some((schema) => (0, kind_1.IsTransform)(schema)))
+        throw new Error('Cannot intersect transform types');
+    return ResolveIntersect(types, options);
+}

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

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+type TIntersectStatic<T extends TSchema[], P extends unknown[], Acc extends unknown = unknown> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TIntersectStatic<R, P, Acc & Static<L, P>> : Acc;
+export type TUnevaluatedProperties = undefined | TSchema | boolean;
+export interface IntersectOptions extends SchemaOptions {
+    unevaluatedProperties?: TUnevaluatedProperties;
+}
+export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
+    [Kind]: 'Intersect';
+    static: TIntersectStatic<T, this['params']>;
+    type?: 'object';
+    allOf: [...T];
+}
+export {};

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

@@ -0,0 +1,4 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../symbols/index");

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

@@ -0,0 +1,6 @@
+import type { TSchema } from '../schema/index';
+import { type TNever } from '../never/index';
+import { TIntersect, IntersectOptions } from './intersect-type';
+export type Intersect<Types extends TSchema[]> = (Types extends [TSchema] ? Types[0] : Types extends [] ? TNever : TIntersect<Types>);
+/** `[Json]` Creates an evaluated Intersect type */
+export declare function Intersect<Types extends TSchema[]>(types: [...Types], options?: IntersectOptions): Intersect<Types>;

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

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Intersect = Intersect;
+const type_1 = require("../create/type");
+const index_1 = require("../never/index");
+const intersect_create_1 = require("./intersect-create");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../guard/kind");
+/** `[Json]` Creates an evaluated Intersect type */
+function Intersect(types, options) {
+    if (types.length === 1)
+        return (0, type_1.CreateType)(types[0], options);
+    if (types.length === 0)
+        return (0, index_1.Never)(options);
+    if (types.some((schema) => (0, kind_1.IsTransform)(schema)))
+        throw new Error('Cannot intersect transform types');
+    return (0, intersect_create_1.IntersectCreate)(types, options);
+}

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

@@ -0,0 +1,5 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { type TIntrinsic } from './intrinsic';
+export type TCapitalize<T extends TSchema> = TIntrinsic<T, 'Capitalize'>;
+/** `[Json]` Intrinsic function to Capitalize LiteralString types */
+export declare function Capitalize<T extends TSchema>(T: T, options?: SchemaOptions): TCapitalize<T>;

package/node_modules/@sinclair/typebox/build/cjs/type/intrinsic/capitalize.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Capitalize = Capitalize;
+const intrinsic_1 = require("./intrinsic");
+/** `[Json]` Intrinsic function to Capitalize LiteralString types */
+function Capitalize(T, options = {}) {
+    return (0, intrinsic_1.Intrinsic)(T, 'Capitalize', options);
+}

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

@@ -0,0 +1,6 @@
+export * from './capitalize';
+export * from './intrinsic-from-mapped-key';
+export * from './intrinsic';
+export * from './lowercase';
+export * from './uncapitalize';
+export * from './uppercase';

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

@@ -0,0 +1,23 @@
+"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("./capitalize"), exports);
+__exportStar(require("./intrinsic-from-mapped-key"), exports);
+__exportStar(require("./intrinsic"), exports);
+__exportStar(require("./lowercase"), exports);
+__exportStar(require("./uncapitalize"), exports);
+__exportStar(require("./uppercase"), exports);

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

@@ -0,0 +1,14 @@
+import type { SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { Assert } from '../helpers/index';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+import { type TIntrinsic, type IntrinsicMode } from './intrinsic';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
+type TMappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode> = {
+    [_ in K]: TIntrinsic<TLiteral<Assert<K, TLiteralValue>>, M>;
+};
+type TMappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode, Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedIntrinsicPropertyKeys<R, M, Acc & TMappedIntrinsicPropertyKey<L, M>> : Acc);
+type TMappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode> = (TMappedIntrinsicPropertyKeys<K['keys'], M>);
+export type TIntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = TMappedIntrinsicProperties<K, M>> = (TMappedResult<P>);
+export declare function IntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = TMappedIntrinsicProperties<K, M>>(T: K, M: M, options: SchemaOptions): TMappedResult<P>;
+export {};

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

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntrinsicFromMappedKey = IntrinsicFromMappedKey;
+const index_1 = require("../mapped/index");
+const intrinsic_1 = require("./intrinsic");
+const index_2 = require("../literal/index");
+const value_1 = require("../clone/value");
+// prettier-ignore
+function MappedIntrinsicPropertyKey(K, M, options) {
+    return {
+        [K]: (0, intrinsic_1.Intrinsic)((0, index_2.Literal)(K), M, (0, value_1.Clone)(options))
+    };
+}
+// prettier-ignore
+function MappedIntrinsicPropertyKeys(K, M, options) {
+    const result = K.reduce((Acc, L) => {
+        return { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) };
+    }, {});
+    return result;
+}
+// prettier-ignore
+function MappedIntrinsicProperties(T, M, options) {
+    return MappedIntrinsicPropertyKeys(T['keys'], M, options);
+}
+// prettier-ignore
+function IntrinsicFromMappedKey(T, M, options) {
+    const P = MappedIntrinsicProperties(T, M, options);
+    return (0, index_1.MappedResult)(P);
+}

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

@@ -0,0 +1,16 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { type TTemplateLiteral, type TTemplateLiteralKind } from '../template-literal/index';
+import { type TIntrinsicFromMappedKey } from './intrinsic-from-mapped-key';
+import { type TLiteral } from '../literal/index';
+import { type TUnion } from '../union/index';
+import { type TMappedKey } from '../mapped/index';
+export type IntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize';
+type TFromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode> = M extends IntrinsicMode ? T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? [TIntrinsic<L, M>, ...TFromTemplateLiteral<R, M>] : T : T;
+type TFromLiteralValue<T, M extends IntrinsicMode> = (T extends string ? M extends 'Uncapitalize' ? Uncapitalize<T> : M extends 'Capitalize' ? Capitalize<T> : M extends 'Uppercase' ? Uppercase<T> : M extends 'Lowercase' ? Lowercase<T> : string : T);
+type TFromRest<T extends TSchema[], M extends IntrinsicMode, Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, M, [...Acc, TIntrinsic<L, M>]> : Acc;
+export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicFromMappedKey<T, M> : T extends TTemplateLiteral<infer S> ? TTemplateLiteral<TFromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<TFromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<TFromLiteralValue<S, M>> : T;
+/** Applies an intrinsic string manipulation to the given type. */
+export declare function Intrinsic<T extends TMappedKey, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsicFromMappedKey<T, M>;
+/** Applies an intrinsic string manipulation to the given type. */
+export declare function Intrinsic<T extends TSchema, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsic<T, M>;
+export {};