@directus/api 34.0.1 → 35.0.0

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/extract/extract.js

@@ -0,0 +1,25 @@
+import { CreateType } from "../create/type.js";
+import { IsMappedResult, IsTemplateLiteral, IsUnion } from "../guard/kind.js";
+import { Never } from "../never/never.js";
+import "../never/index.js";
+import { Union } from "../union/union.js";
+import "../union/index.js";
+import { ExtendsCheck, ExtendsResult } from "../extends/extends-check.js";
+import "../extends/index.js";
+import { ExtractFromTemplateLiteral } from "./extract-from-template-literal.js";
+import { ExtractFromMappedResult } from "./extract-from-mapped-result.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/extract/extract.mjs
+function ExtractRest(L, R) {
+	const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
+	return extracted.length === 1 ? extracted[0] : Union(extracted);
+}
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+function Extract(L, R, options) {
+	if (IsTemplateLiteral(L)) return CreateType(ExtractFromTemplateLiteral(L, R), options);
+	if (IsMappedResult(L)) return CreateType(ExtractFromMappedResult(L, R), options);
+	return CreateType(IsUnion(L) ? ExtractRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
+}
+
+//#endregion
+export { Extract };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/extract/index.js

@@ -0,0 +1,5 @@
+import { ExtractFromTemplateLiteral } from "./extract-from-template-literal.js";
+import { Extract } from "./extract.js";
+import { ExtractFromMappedResult } from "./extract-from-mapped-result.js";
+
+export {  };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/function/function.js

@@ -0,0 +1,17 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+import "../symbols/index.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/function/function.mjs
+/** `[JavaScript]` Creates a Function type */
+function Function(parameters, returns, options) {
+	return CreateType({
+		[Kind]: "Function",
+		type: "Function",
+		parameters,
+		returns
+	}, options);
+}
+
+//#endregion
+export { Function };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/function/index.js

@@ -0,0 +1,3 @@
+import { Function } from "./function.js";
+
+export {  };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/guard/index.js

@@ -0,0 +1,5 @@
+import "./value.js";
+import "./kind.js";
+import "./type.js";
+
+export {  };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/guard/kind.js

@@ -0,0 +1,204 @@
+import { IsBoolean as IsBoolean$1, IsNumber as IsNumber$1, IsObject as IsObject$1, IsString as IsString$1 } from "./value.js";
+import { Hint, Kind, OptionalKind, ReadonlyKind, TransformKind } from "../symbols/symbols.js";
+import "../symbols/index.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
+/** `[Kind-Only]` Returns true if this value has a Readonly symbol */
+function IsReadonly(value) {
+	return IsObject$1(value) && value[ReadonlyKind] === "Readonly";
+}
+/** `[Kind-Only]` Returns true if this value has a Optional symbol */
+function IsOptional(value) {
+	return IsObject$1(value) && value[OptionalKind] === "Optional";
+}
+/** `[Kind-Only]` Returns true if the given value is TAny */
+function IsAny(value) {
+	return IsKindOf(value, "Any");
+}
+/** `[Kind-Only]` Returns true if the given value is TArgument */
+function IsArgument(value) {
+	return IsKindOf(value, "Argument");
+}
+/** `[Kind-Only]` Returns true if the given value is TArray */
+function IsArray(value) {
+	return IsKindOf(value, "Array");
+}
+/** `[Kind-Only]` Returns true if the given value is TAsyncIterator */
+function IsAsyncIterator(value) {
+	return IsKindOf(value, "AsyncIterator");
+}
+/** `[Kind-Only]` Returns true if the given value is TBigInt */
+function IsBigInt(value) {
+	return IsKindOf(value, "BigInt");
+}
+/** `[Kind-Only]` Returns true if the given value is TBoolean */
+function IsBoolean(value) {
+	return IsKindOf(value, "Boolean");
+}
+/** `[Kind-Only]` Returns true if the given value is TComputed */
+function IsComputed(value) {
+	return IsKindOf(value, "Computed");
+}
+/** `[Kind-Only]` Returns true if the given value is TConstructor */
+function IsConstructor(value) {
+	return IsKindOf(value, "Constructor");
+}
+/** `[Kind-Only]` Returns true if the given value is TDate */
+function IsDate(value) {
+	return IsKindOf(value, "Date");
+}
+/** `[Kind-Only]` Returns true if the given value is TFunction */
+function IsFunction(value) {
+	return IsKindOf(value, "Function");
+}
+/** `[Kind-Only]` Returns true if the given value is TInteger */
+function IsImport(value) {
+	return IsKindOf(value, "Import");
+}
+/** `[Kind-Only]` Returns true if the given value is TInteger */
+function IsInteger(value) {
+	return IsKindOf(value, "Integer");
+}
+/** `[Kind-Only]` Returns true if the given schema is TProperties */
+function IsProperties(value) {
+	return IsObject$1(value);
+}
+/** `[Kind-Only]` Returns true if the given value is TIntersect */
+function IsIntersect(value) {
+	return IsKindOf(value, "Intersect");
+}
+/** `[Kind-Only]` Returns true if the given value is TIterator */
+function IsIterator(value) {
+	return IsKindOf(value, "Iterator");
+}
+/** `[Kind-Only]` Returns true if the given value is a TKind with the given name. */
+function IsKindOf(value, kind) {
+	return IsObject$1(value) && Kind in value && value[Kind] === kind;
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral<string> */
+function IsLiteralString(value) {
+	return IsLiteral(value) && IsString$1(value.const);
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral<number> */
+function IsLiteralNumber(value) {
+	return IsLiteral(value) && IsNumber$1(value.const);
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral<boolean> */
+function IsLiteralBoolean(value) {
+	return IsLiteral(value) && IsBoolean$1(value.const);
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteralValue */
+function IsLiteralValue(value) {
+	return IsBoolean$1(value) || IsNumber$1(value) || IsString$1(value);
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral */
+function IsLiteral(value) {
+	return IsKindOf(value, "Literal");
+}
+/** `[Kind-Only]` Returns true if the given value is a TMappedKey */
+function IsMappedKey(value) {
+	return IsKindOf(value, "MappedKey");
+}
+/** `[Kind-Only]` Returns true if the given value is TMappedResult */
+function IsMappedResult(value) {
+	return IsKindOf(value, "MappedResult");
+}
+/** `[Kind-Only]` Returns true if the given value is TNever */
+function IsNever(value) {
+	return IsKindOf(value, "Never");
+}
+/** `[Kind-Only]` Returns true if the given value is TNot */
+function IsNot(value) {
+	return IsKindOf(value, "Not");
+}
+/** `[Kind-Only]` Returns true if the given value is TNull */
+function IsNull(value) {
+	return IsKindOf(value, "Null");
+}
+/** `[Kind-Only]` Returns true if the given value is TNumber */
+function IsNumber(value) {
+	return IsKindOf(value, "Number");
+}
+/** `[Kind-Only]` Returns true if the given value is TObject */
+function IsObject(value) {
+	return IsKindOf(value, "Object");
+}
+/** `[Kind-Only]` Returns true if the given value is TPromise */
+function IsPromise(value) {
+	return IsKindOf(value, "Promise");
+}
+/** `[Kind-Only]` Returns true if the given value is TRecord */
+function IsRecord(value) {
+	return IsKindOf(value, "Record");
+}
+/** `[Kind-Only]` Returns true if this value is TRecursive */
+function IsRecursive(value) {
+	return IsObject$1(value) && Hint in value && value[Hint] === "Recursive";
+}
+/** `[Kind-Only]` Returns true if the given value is TRef */
+function IsRef(value) {
+	return IsKindOf(value, "Ref");
+}
+/** `[Kind-Only]` Returns true if the given value is TRegExp */
+function IsRegExp(value) {
+	return IsKindOf(value, "RegExp");
+}
+/** `[Kind-Only]` Returns true if the given value is TString */
+function IsString(value) {
+	return IsKindOf(value, "String");
+}
+/** `[Kind-Only]` Returns true if the given value is TSymbol */
+function IsSymbol(value) {
+	return IsKindOf(value, "Symbol");
+}
+/** `[Kind-Only]` Returns true if the given value is TTemplateLiteral */
+function IsTemplateLiteral(value) {
+	return IsKindOf(value, "TemplateLiteral");
+}
+/** `[Kind-Only]` Returns true if the given value is TThis */
+function IsThis(value) {
+	return IsKindOf(value, "This");
+}
+/** `[Kind-Only]` Returns true of this value is TTransform */
+function IsTransform(value) {
+	return IsObject$1(value) && TransformKind in value;
+}
+/** `[Kind-Only]` Returns true if the given value is TTuple */
+function IsTuple(value) {
+	return IsKindOf(value, "Tuple");
+}
+/** `[Kind-Only]` Returns true if the given value is TUndefined */
+function IsUndefined(value) {
+	return IsKindOf(value, "Undefined");
+}
+/** `[Kind-Only]` Returns true if the given value is TUnion */
+function IsUnion(value) {
+	return IsKindOf(value, "Union");
+}
+/** `[Kind-Only]` Returns true if the given value is TUint8Array */
+function IsUint8Array(value) {
+	return IsKindOf(value, "Uint8Array");
+}
+/** `[Kind-Only]` Returns true if the given value is TUnknown */
+function IsUnknown(value) {
+	return IsKindOf(value, "Unknown");
+}
+/** `[Kind-Only]` Returns true if the given value is a raw TUnsafe */
+function IsUnsafe(value) {
+	return IsKindOf(value, "Unsafe");
+}
+/** `[Kind-Only]` Returns true if the given value is TVoid */
+function IsVoid(value) {
+	return IsKindOf(value, "Void");
+}
+/** `[Kind-Only]` Returns true if the given value is TKind */
+function IsKind(value) {
+	return IsObject$1(value) && Kind in value && IsString$1(value[Kind]);
+}
+/** `[Kind-Only]` Returns true if the given value is TSchema */
+function IsSchema(value) {
+	return IsAny(value) || IsArgument(value) || IsArray(value) || IsBoolean(value) || IsBigInt(value) || IsAsyncIterator(value) || IsComputed(value) || IsConstructor(value) || IsDate(value) || IsFunction(value) || IsInteger(value) || IsIntersect(value) || IsIterator(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull(value) || IsNumber(value) || IsObject(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp(value) || IsString(value) || IsSymbol(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined(value) || IsUnion(value) || IsUint8Array(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
+}
+
+//#endregion
+export { IsAny, IsArgument, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsComputed, IsConstructor, IsFunction, IsInteger, IsIntersect, IsIterator, IsLiteral, IsLiteralValue, IsMappedKey, IsMappedResult, IsNever, IsNull, IsNumber, IsObject, IsOptional, IsPromise, IsReadonly, IsRecord, IsRef, IsRegExp, IsSchema, IsString, IsSymbol, IsTemplateLiteral, IsTransform, IsTuple, IsUndefined, IsUnion };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/guard/type.js

@@ -0,0 +1,293 @@
+import { HasPropertyKey, IsArray as IsArray$1, IsBigInt as IsBigInt$1, IsBoolean as IsBoolean$1, IsNumber as IsNumber$1, IsObject as IsObject$1, IsString as IsString$1, IsUndefined as IsUndefined$1 } from "./value.js";
+import { TypeBoxError } from "../error/error.js";
+import "../error/index.js";
+import { Hint, Kind, OptionalKind, ReadonlyKind, TransformKind } from "../symbols/symbols.js";
+import "../symbols/index.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
+var TypeGuardUnknownTypeError = class extends TypeBoxError {};
+const KnownTypes = [
+	"Argument",
+	"Any",
+	"Array",
+	"AsyncIterator",
+	"BigInt",
+	"Boolean",
+	"Computed",
+	"Constructor",
+	"Date",
+	"Enum",
+	"Function",
+	"Integer",
+	"Intersect",
+	"Iterator",
+	"Literal",
+	"MappedKey",
+	"MappedResult",
+	"Not",
+	"Null",
+	"Number",
+	"Object",
+	"Promise",
+	"Record",
+	"Ref",
+	"RegExp",
+	"String",
+	"Symbol",
+	"TemplateLiteral",
+	"This",
+	"Tuple",
+	"Undefined",
+	"Union",
+	"Uint8Array",
+	"Unknown",
+	"Void"
+];
+function IsPattern(value) {
+	try {
+		new RegExp(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function IsControlCharacterFree(value) {
+	if (!IsString$1(value)) return false;
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (code >= 7 && code <= 13 || code === 27 || code === 127) {
+			return false;
+		}
+	}
+	return true;
+}
+function IsAdditionalProperties(value) {
+	return IsOptionalBoolean(value) || IsSchema(value);
+}
+function IsOptionalBigInt(value) {
+	return IsUndefined$1(value) || IsBigInt$1(value);
+}
+function IsOptionalNumber(value) {
+	return IsUndefined$1(value) || IsNumber$1(value);
+}
+function IsOptionalBoolean(value) {
+	return IsUndefined$1(value) || IsBoolean$1(value);
+}
+function IsOptionalString(value) {
+	return IsUndefined$1(value) || IsString$1(value);
+}
+function IsOptionalPattern(value) {
+	return IsUndefined$1(value) || IsString$1(value) && IsControlCharacterFree(value) && IsPattern(value);
+}
+function IsOptionalFormat(value) {
+	return IsUndefined$1(value) || IsString$1(value) && IsControlCharacterFree(value);
+}
+function IsOptionalSchema(value) {
+	return IsUndefined$1(value) || IsSchema(value);
+}
+/** Returns true if this value has a Readonly symbol */
+function IsReadonly(value) {
+	return IsObject$1(value) && value[ReadonlyKind] === "Readonly";
+}
+/** Returns true if this value has a Optional symbol */
+function IsOptional(value) {
+	return IsObject$1(value) && value[OptionalKind] === "Optional";
+}
+/** Returns true if the given value is TAny */
+function IsAny(value) {
+	return IsKindOf(value, "Any") && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TArgument */
+function IsArgument(value) {
+	return IsKindOf(value, "Argument") && IsNumber$1(value.index);
+}
+/** Returns true if the given value is TArray */
+function IsArray(value) {
+	return IsKindOf(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
+}
+/** Returns true if the given value is TAsyncIterator */
+function IsAsyncIterator(value) {
+	return IsKindOf(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema(value.items);
+}
+/** Returns true if the given value is TBigInt */
+function IsBigInt(value) {
+	return IsKindOf(value, "BigInt") && value.type === "bigint" && IsOptionalString(value.$id) && IsOptionalBigInt(value.exclusiveMaximum) && IsOptionalBigInt(value.exclusiveMinimum) && IsOptionalBigInt(value.maximum) && IsOptionalBigInt(value.minimum) && IsOptionalBigInt(value.multipleOf);
+}
+/** Returns true if the given value is TBoolean */
+function IsBoolean(value) {
+	return IsKindOf(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TComputed */
+function IsComputed(value) {
+	return IsKindOf(value, "Computed") && IsString$1(value.target) && IsArray$1(value.parameters) && value.parameters.every((schema) => IsSchema(schema));
+}
+/** Returns true if the given value is TConstructor */
+function IsConstructor(value) {
+	return IsKindOf(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray$1(value.parameters) && value.parameters.every((schema) => IsSchema(schema)) && IsSchema(value.returns);
+}
+/** Returns true if the given value is TDate */
+function IsDate(value) {
+	return IsKindOf(value, "Date") && value.type === "Date" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximumTimestamp) && IsOptionalNumber(value.exclusiveMinimumTimestamp) && IsOptionalNumber(value.maximumTimestamp) && IsOptionalNumber(value.minimumTimestamp) && IsOptionalNumber(value.multipleOfTimestamp);
+}
+/** Returns true if the given value is TFunction */
+function IsFunction(value) {
+	return IsKindOf(value, "Function") && value.type === "Function" && IsOptionalString(value.$id) && IsArray$1(value.parameters) && value.parameters.every((schema) => IsSchema(schema)) && IsSchema(value.returns);
+}
+/** Returns true if the given value is TImport */
+function IsImport(value) {
+	return IsKindOf(value, "Import") && HasPropertyKey(value, "$defs") && IsObject$1(value.$defs) && IsProperties(value.$defs) && HasPropertyKey(value, "$ref") && IsString$1(value.$ref) && value.$ref in value.$defs;
+}
+/** Returns true if the given value is TInteger */
+function IsInteger(value) {
+	return IsKindOf(value, "Integer") && value.type === "integer" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+}
+/** Returns true if the given schema is TProperties */
+function IsProperties(value) {
+	return IsObject$1(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema(schema));
+}
+/** Returns true if the given value is TIntersect */
+function IsIntersect(value) {
+	return IsKindOf(value, "Intersect") && (IsString$1(value.type) && value.type !== "object" ? false : true) && IsArray$1(value.allOf) && value.allOf.every((schema) => IsSchema(schema) && !IsTransform(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TIterator */
+function IsIterator(value) {
+	return IsKindOf(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema(value.items);
+}
+/** Returns true if the given value is a TKind with the given name. */
+function IsKindOf(value, kind) {
+	return IsObject$1(value) && Kind in value && value[Kind] === kind;
+}
+/** Returns true if the given value is TLiteral<string> */
+function IsLiteralString(value) {
+	return IsLiteral(value) && IsString$1(value.const);
+}
+/** Returns true if the given value is TLiteral<number> */
+function IsLiteralNumber(value) {
+	return IsLiteral(value) && IsNumber$1(value.const);
+}
+/** Returns true if the given value is TLiteral<boolean> */
+function IsLiteralBoolean(value) {
+	return IsLiteral(value) && IsBoolean$1(value.const);
+}
+/** Returns true if the given value is TLiteral */
+function IsLiteral(value) {
+	return IsKindOf(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue(value.const);
+}
+/** Returns true if the given value is a TLiteralValue */
+function IsLiteralValue(value) {
+	return IsBoolean$1(value) || IsNumber$1(value) || IsString$1(value);
+}
+/** Returns true if the given value is a TMappedKey */
+function IsMappedKey(value) {
+	return IsKindOf(value, "MappedKey") && IsArray$1(value.keys) && value.keys.every((key) => IsNumber$1(key) || IsString$1(key));
+}
+/** Returns true if the given value is TMappedResult */
+function IsMappedResult(value) {
+	return IsKindOf(value, "MappedResult") && IsProperties(value.properties);
+}
+/** Returns true if the given value is TNever */
+function IsNever(value) {
+	return IsKindOf(value, "Never") && IsObject$1(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
+}
+/** Returns true if the given value is TNot */
+function IsNot(value) {
+	return IsKindOf(value, "Not") && IsSchema(value.not);
+}
+/** Returns true if the given value is TNull */
+function IsNull(value) {
+	return IsKindOf(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TNumber */
+function IsNumber(value) {
+	return IsKindOf(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+}
+/** Returns true if the given value is TObject */
+function IsObject(value) {
+	return IsKindOf(value, "Object") && value.type === "object" && IsOptionalString(value.$id) && IsProperties(value.properties) && IsAdditionalProperties(value.additionalProperties) && IsOptionalNumber(value.minProperties) && IsOptionalNumber(value.maxProperties);
+}
+/** Returns true if the given value is TPromise */
+function IsPromise(value) {
+	return IsKindOf(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema(value.item);
+}
+/** Returns true if the given value is TRecord */
+function IsRecord(value) {
+	return IsKindOf(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject$1(value.patternProperties) && ((schema) => {
+		const keys = Object.getOwnPropertyNames(schema.patternProperties);
+		return keys.length === 1 && IsPattern(keys[0]) && IsObject$1(schema.patternProperties) && IsSchema(schema.patternProperties[keys[0]]);
+	})(value);
+}
+/** Returns true if this value is TRecursive */
+function IsRecursive(value) {
+	return IsObject$1(value) && Hint in value && value[Hint] === "Recursive";
+}
+/** Returns true if the given value is TRef */
+function IsRef(value) {
+	return IsKindOf(value, "Ref") && IsOptionalString(value.$id) && IsString$1(value.$ref);
+}
+/** Returns true if the given value is TRegExp */
+function IsRegExp(value) {
+	return IsKindOf(value, "RegExp") && IsOptionalString(value.$id) && IsString$1(value.source) && IsString$1(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
+}
+/** Returns true if the given value is TString */
+function IsString(value) {
+	return IsKindOf(value, "String") && value.type === "string" && IsOptionalString(value.$id) && IsOptionalNumber(value.minLength) && IsOptionalNumber(value.maxLength) && IsOptionalPattern(value.pattern) && IsOptionalFormat(value.format);
+}
+/** Returns true if the given value is TSymbol */
+function IsSymbol(value) {
+	return IsKindOf(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TTemplateLiteral */
+function IsTemplateLiteral(value) {
+	return IsKindOf(value, "TemplateLiteral") && value.type === "string" && IsString$1(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
+}
+/** Returns true if the given value is TThis */
+function IsThis(value) {
+	return IsKindOf(value, "This") && IsOptionalString(value.$id) && IsString$1(value.$ref);
+}
+/** Returns true of this value is TTransform */
+function IsTransform(value) {
+	return IsObject$1(value) && TransformKind in value;
+}
+/** Returns true if the given value is TTuple */
+function IsTuple(value) {
+	return IsKindOf(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber$1(value.minItems) && IsNumber$1(value.maxItems) && value.minItems === value.maxItems && (IsUndefined$1(value.items) && IsUndefined$1(value.additionalItems) && value.minItems === 0 || IsArray$1(value.items) && value.items.every((schema) => IsSchema(schema)));
+}
+/** Returns true if the given value is TUndefined */
+function IsUndefined(value) {
+	return IsKindOf(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TUnion<Literal<string | number>[]> */
+function IsUnionLiteral(value) {
+	return IsUnion(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
+}
+/** Returns true if the given value is TUnion */
+function IsUnion(value) {
+	return IsKindOf(value, "Union") && IsOptionalString(value.$id) && IsObject$1(value) && IsArray$1(value.anyOf) && value.anyOf.every((schema) => IsSchema(schema));
+}
+/** Returns true if the given value is TUint8Array */
+function IsUint8Array(value) {
+	return IsKindOf(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
+}
+/** Returns true if the given value is TUnknown */
+function IsUnknown(value) {
+	return IsKindOf(value, "Unknown") && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is a raw TUnsafe */
+function IsUnsafe(value) {
+	return IsKindOf(value, "Unsafe");
+}
+/** Returns true if the given value is TVoid */
+function IsVoid(value) {
+	return IsKindOf(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
+}
+/** Returns true if the given value is TKind */
+function IsKind(value) {
+	return IsObject$1(value) && Kind in value && IsString$1(value[Kind]) && !KnownTypes.includes(value[Kind]);
+}
+/** Returns true if the given value is TSchema */
+function IsSchema(value) {
+	return IsObject$1(value) && (IsAny(value) || IsArgument(value) || IsArray(value) || IsBoolean(value) || IsBigInt(value) || IsAsyncIterator(value) || IsComputed(value) || IsConstructor(value) || IsDate(value) || IsFunction(value) || IsInteger(value) || IsIntersect(value) || IsIterator(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull(value) || IsNumber(value) || IsObject(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp(value) || IsString(value) || IsSymbol(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined(value) || IsUnion(value) || IsUint8Array(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value));
+}
+
+//#endregion
+export { IsAny, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsConstructor, IsDate, IsFunction, IsInteger, IsIntersect, IsIterator, IsLiteral, IsLiteralBoolean, IsLiteralNumber, IsLiteralString, IsNever, IsNot, IsNull, IsNumber, IsObject, IsOptional, IsPromise, IsRecord, IsRegExp, IsString, IsSymbol, IsTemplateLiteral, IsTuple, IsUint8Array, IsUndefined, IsUnion, IsUnknown, IsVoid };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/guard/value.js

@@ -0,0 +1,68 @@
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
+/** Returns true if this value has this property key */
+function HasPropertyKey(value, key) {
+	return key in value;
+}
+/** Returns true if this value is an async iterator */
+function IsAsyncIterator(value) {
+	return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
+}
+/** Returns true if this value is an array */
+function IsArray(value) {
+	return Array.isArray(value);
+}
+/** Returns true if this value is bigint */
+function IsBigInt(value) {
+	return typeof value === "bigint";
+}
+/** Returns true if this value is a boolean */
+function IsBoolean(value) {
+	return typeof value === "boolean";
+}
+/** Returns true if this value is a Date object */
+function IsDate(value) {
+	return value instanceof globalThis.Date;
+}
+/** Returns true if this value is a function */
+function IsFunction(value) {
+	return typeof value === "function";
+}
+/** Returns true if this value is an iterator */
+function IsIterator(value) {
+	return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
+}
+/** Returns true if this value is null */
+function IsNull(value) {
+	return value === null;
+}
+/** Returns true if this value is number */
+function IsNumber(value) {
+	return typeof value === "number";
+}
+/** Returns true if this value is an object */
+function IsObject(value) {
+	return typeof value === "object" && value !== null;
+}
+/** Returns true if this value is RegExp */
+function IsRegExp(value) {
+	return value instanceof globalThis.RegExp;
+}
+/** Returns true if this value is string */
+function IsString(value) {
+	return typeof value === "string";
+}
+/** Returns true if this value is symbol */
+function IsSymbol(value) {
+	return typeof value === "symbol";
+}
+/** Returns true if this value is a Uint8Array */
+function IsUint8Array(value) {
+	return value instanceof globalThis.Uint8Array;
+}
+/** Returns true if this value is undefined */
+function IsUndefined(value) {
+	return value === undefined;
+}
+
+//#endregion
+export { HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsIterator, IsNull, IsNumber, IsObject, IsRegExp, IsString, IsSymbol, IsUint8Array, IsUndefined };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/helpers/helpers.js

@@ -0,0 +1,8 @@
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/helpers/helpers.mjs
+/** Increments the given string value + 1 */
+function Increment(T) {
+	return (parseInt(T) + 1).toString();
+}
+
+//#endregion
+export {  };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/helpers/index.js

@@ -0,0 +1,3 @@
+import "./helpers.js";
+
+export {  };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/indexed/index.js

@@ -0,0 +1,6 @@
+import { IndexPropertyKeys } from "./indexed-property-keys.js";
+import { IndexFromMappedResult } from "./indexed-from-mapped-result.js";
+import { Index, IndexFromPropertyKey, IndexFromPropertyKeys } from "./indexed.js";
+import { IndexFromMappedKey } from "./indexed-from-mapped-key.js";
+
+export {  };