@openclaw/lobster 2026.5.20-beta.2 → 2026.5.22

package/node_modules/typebox/build/error/errors.d.mts

@@ -0,0 +1,214 @@
+export type TValidationError = TAdditionalPropertiesError | TAnyOfError | TBooleanError | TConstError | TContainsError | TDependenciesError | TDependentRequiredError | TEnumError | TExclusiveMaximumError | TExclusiveMinimumError | TFormatError | TGuardError | TIfError | TMaximumError | TMaxItemsError | TMaxLengthError | TMaxPropertiesError | TMinimumError | TMinItemsError | TMinLengthError | TMinPropertiesError | TMultipleOfError | TNotError | TOneOfError | TPatternError | TPropertyNamesError | TRefineError | TRequiredError | TTypeError | TUnevaluatedItemsError | TUnevaluatedPropertiesError | TUniqueItemsError;
+export declare function IsValidationError(value: unknown): value is TValidationError;
+export type TLocalizedValidationError = TValidationError & {
+    message: string;
+};
+export declare function IsLocalizedValidationError(value: unknown): value is TLocalizedValidationError;
+export type TLocalizedValidationMessageCallback = (error: TValidationError) => string;
+export interface TValidationErrorBase {
+    keyword: string;
+    schemaPath: string;
+    instancePath: string;
+    params: object;
+}
+export interface TAdditionalPropertiesError extends TValidationErrorBase {
+    keyword: 'additionalProperties';
+    params: {
+        additionalProperties: string[];
+    };
+}
+export interface TAnyOfError extends TValidationErrorBase {
+    keyword: 'anyOf';
+    params: {};
+}
+export interface TBooleanError extends TValidationErrorBase {
+    keyword: 'boolean';
+    params: {};
+}
+export interface TConstError extends TValidationErrorBase {
+    keyword: 'const';
+    params: {
+        allowedValue: unknown;
+    };
+}
+export interface TContainsError extends TValidationErrorBase {
+    keyword: 'contains';
+    params: {
+        minContains: number;
+        maxContains?: number;
+    };
+}
+export interface TDependenciesError extends TValidationErrorBase {
+    keyword: 'dependencies';
+    params: {
+        property: string;
+        dependencies: string[];
+    };
+}
+export interface TDependentRequiredError extends TValidationErrorBase {
+    keyword: 'dependentRequired';
+    params: {
+        property: string;
+        dependencies: string[];
+    };
+}
+export interface TEnumError extends TValidationErrorBase {
+    keyword: 'enum';
+    params: {
+        allowedValues: unknown[];
+    };
+}
+export interface TExclusiveMaximumError extends TValidationErrorBase {
+    keyword: 'exclusiveMaximum';
+    params: {
+        comparison: '<';
+        limit: number | bigint;
+    };
+}
+export interface TExclusiveMinimumError extends TValidationErrorBase {
+    keyword: 'exclusiveMinimum';
+    params: {
+        comparison: '>';
+        limit: number | bigint;
+    };
+}
+export interface TFormatError extends TValidationErrorBase {
+    keyword: 'format';
+    params: {
+        format: string;
+    };
+}
+export interface TGuardError extends TValidationErrorBase {
+    keyword: '~guard';
+    params: {
+        errors: object[];
+    };
+}
+export interface TIfError extends TValidationErrorBase {
+    keyword: 'if';
+    params: {
+        failingKeyword: 'then' | 'else';
+    };
+}
+export interface TMaximumError extends TValidationErrorBase {
+    keyword: 'maximum';
+    params: {
+        comparison: '<=';
+        limit: number | bigint;
+    };
+}
+export interface TMaxItemsError extends TValidationErrorBase {
+    keyword: 'maxItems';
+    params: {
+        limit: number;
+    };
+}
+export interface TMaxLengthError extends TValidationErrorBase {
+    keyword: 'maxLength';
+    params: {
+        limit: number;
+    };
+}
+export interface TMaxPropertiesError extends TValidationErrorBase {
+    keyword: 'maxProperties';
+    params: {
+        limit: number;
+    };
+}
+export interface TMinimumError extends TValidationErrorBase {
+    keyword: 'minimum';
+    params: {
+        comparison: '>=';
+        limit: number | bigint;
+    };
+}
+export interface TMinItemsError extends TValidationErrorBase {
+    keyword: 'minItems';
+    params: {
+        limit: number;
+    };
+}
+export interface TMinLengthError extends TValidationErrorBase {
+    keyword: 'minLength';
+    params: {
+        limit: number;
+    };
+}
+export interface TMinPropertiesError extends TValidationErrorBase {
+    keyword: 'minProperties';
+    params: {
+        limit: number;
+    };
+}
+export interface TMultipleOfError extends TValidationErrorBase {
+    keyword: 'multipleOf';
+    params: {
+        multipleOf: number | bigint;
+    };
+}
+export interface TMinimumError extends TValidationErrorBase {
+    keyword: 'minimum';
+    params: {
+        comparison: '>=';
+        limit: number | bigint;
+    };
+}
+export interface TNotError extends TValidationErrorBase {
+    keyword: 'not';
+    params: {};
+}
+export interface TOneOfError extends TValidationErrorBase {
+    keyword: 'oneOf';
+    params: {
+        passingSchemas: number[];
+    };
+}
+export interface TPatternError extends TValidationErrorBase {
+    keyword: 'pattern';
+    params: {
+        pattern: string | RegExp;
+    };
+}
+export interface TPropertyNamesError extends TValidationErrorBase {
+    keyword: 'propertyNames';
+    params: {
+        propertyNames: string[];
+    };
+}
+export interface TRefineError extends TValidationErrorBase {
+    keyword: '~refine';
+    params: {
+        index: number;
+        message: string;
+    };
+}
+export interface TRequiredError extends TValidationErrorBase {
+    keyword: 'required';
+    params: {
+        requiredProperties: string[];
+    };
+}
+export interface TTypeError extends TValidationErrorBase {
+    keyword: 'type';
+    params: {
+        type: string | string[];
+    };
+}
+export interface TUnevaluatedItemsError extends TValidationErrorBase {
+    keyword: 'unevaluatedItems';
+    params: {
+        unevaluatedItems: number[];
+    };
+}
+export interface TUnevaluatedPropertiesError extends TValidationErrorBase {
+    keyword: 'unevaluatedProperties';
+    params: {
+        unevaluatedProperties: PropertyKey[];
+    };
+}
+export interface TUniqueItemsError extends TValidationErrorBase {
+    keyword: 'uniqueItems';
+    params: {
+        duplicateItems: number[];
+    };
+}

package/node_modules/typebox/build/error/errors.mjs

@@ -0,0 +1,18 @@
+// deno-lint-ignore-file ban-types
+import { Guard } from '../guard/index.mjs';
+export function IsValidationError(value) {
+    return Guard.IsObject(value) &&
+        Guard.HasPropertyKey(value, 'keyword') &&
+        Guard.HasPropertyKey(value, 'schemaPath') &&
+        Guard.HasPropertyKey(value, 'instancePath') &&
+        Guard.HasPropertyKey(value, 'params') &&
+        Guard.IsString(value.keyword) &&
+        Guard.IsString(value.schemaPath) &&
+        Guard.IsString(value.instancePath) &&
+        Guard.IsObject(value.params);
+}
+export function IsLocalizedValidationError(value) {
+    return IsValidationError(value) &&
+        Guard.HasPropertyKey(value, 'message') &&
+        Guard.IsString(value.message);
+}

package/node_modules/typebox/build/error/index.d.mts

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

package/node_modules/typebox/build/error/index.mjs

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

package/node_modules/typebox/build/format/_idna.d.mts

@@ -0,0 +1,2 @@
+export declare function IsIdnLabel(value: string): boolean;
+export declare function IsLabel(value: string): boolean;

package/node_modules/typebox/build/format/_idna.mjs

@@ -0,0 +1,216 @@
+import * as Puny from './_puny.mjs';
+// ------------------------------------------------------------------
+// Unicode General Category Helper (RFC 5892)
+// ------------------------------------------------------------------
+function IsNonspacingMark(cp) {
+    return /\p{Mn}/u.test(String.fromCodePoint(cp));
+}
+function IsSpacingCombiningMark(cp) {
+    return /\p{Mc}/u.test(String.fromCodePoint(cp));
+}
+function IsEnclosingMark(cp) {
+    return /\p{Me}/u.test(String.fromCodePoint(cp));
+}
+function IsCombiningMark(cp) {
+    return IsNonspacingMark(cp) || IsSpacingCombiningMark(cp) || IsEnclosingMark(cp);
+}
+// ------------------------------------------------------------------
+// RFC 5892 §2.6 DISALLOWED exceptions
+//
+// https://tools.ietf.org/html/rfc5892#section-2.6
+// ------------------------------------------------------------------
+const RFC5892_DISALLOWED = new Set([
+    0x0640, // ARABIC TATWEEL
+    0x07fa, // NKO LAJANYALAN
+    0x302e, // HANGUL SINGLE DOT TONE MARK
+    0x302f, // HANGUL DOUBLE DOT TONE MARK
+    0x3031, // VERTICAL KANA REPEAT MARK
+    0x3032, // VERTICAL KANA REPEAT WITH VOICED ITERATION MARK
+    0x3033, // VERTICAL KANA REPEAT MARK UPPER HALF
+    0x3034, // VERTICAL KANA REPEAT WITH VOICED ITERATION MARK UPPER HALF
+    0x3035, // VERTICAL KANA REPEAT MARK LOWER HALF
+    0x303b // VERTICAL IDEOGRAPHIC ITERATION MARK
+]);
+// ------------------------------------------------------------------
+// A set of Virama (halant) code points used to validate CONTEXTJ
+// rules (RFC 5892 Appendix A.1). These characters allow a subsequent
+// Zero Width Joiner (U+200D) to be valid in a label.
+// ------------------------------------------------------------------
+const VIRAMA_CPS = new Set([
+    0x094d,
+    0x09cd,
+    0x0a4d,
+    0x0acd,
+    0x0b4d,
+    0x0bcd,
+    0x0c4d,
+    0x0ccd,
+    0x0d3b,
+    0x0d3c,
+    0x0d4d,
+    0x0dca,
+    0x1b44,
+    0x1baa,
+    0x1bab,
+    0xa9c0,
+    0x11046,
+    0x1107f,
+    0x110b9,
+    0x11133,
+    0x11134,
+    0x111c0,
+    0x11235,
+    0x1134d,
+    0x11442,
+    0x114c2,
+    0x115bf,
+    0x1163f,
+    0x116b6,
+    0x11c3f,
+    0x11d44,
+    0x11d45
+]);
+// ------------------------------------------------------------------
+// Guards for CONTEXTO rules (RFC 5892 Appendix A)
+// ------------------------------------------------------------------
+function IsGreek(cp) {
+    return /\p{Script=Greek}/u.test(String.fromCodePoint(cp));
+}
+function IsHebrew(cp) {
+    return /\p{Script=Hebrew}/u.test(String.fromCodePoint(cp));
+}
+function IsHiragana(cp) {
+    return /\p{Script=Hiragana}/u.test(String.fromCodePoint(cp));
+}
+function IsKatakana(cp) {
+    return /\p{Script=Katakana}/u.test(String.fromCodePoint(cp));
+}
+function IsHan(cp) {
+    return /\p{Script=Han}/u.test(String.fromCodePoint(cp));
+}
+function IsArabicIndicDigit(cp) {
+    return cp >= 0x0660 && cp <= 0x0669;
+}
+function IsExtendedArabicIndicDigit(cp) {
+    return cp >= 0x06f0 && cp <= 0x06f9;
+}
+function IsVirama(cp) {
+    return VIRAMA_CPS.has(cp);
+}
+// ------------------------------------------------------------------
+// IsUnicodeLabel
+// ------------------------------------------------------------------
+function IsUnicodeLabel(value) {
+    if (value.length === 0)
+        return false;
+    // Use spread to handle surrogate pairs and provide O(1) neighbor access
+    const cps = [...value].map((c) => c.codePointAt(0));
+    const len = cps.length;
+    // RFC 5891 §4.2.3.2: Hyphen rules
+    if (cps[0] === 0x2d || cps[len - 1] === 0x2d)
+        return false;
+    if (len >= 4 && cps[2] === 0x2d && cps[3] === 0x2d)
+        return false;
+    // RFC 5891 §4.2.3.2 - Must not begin with a combining mark
+    if (IsCombiningMark(cps[0]))
+        return false;
+    let hasJapanese = false;
+    let hasArabicIndic = false;
+    let hasExtendedArabicIndic = false;
+    for (let i = 0; i < len; i++) {
+        const cp = cps[i];
+        // 1. DISALLOWED exceptions
+        if (RFC5892_DISALLOWED.has(cp))
+            return false;
+        // 2. Collect Flags
+        if (IsHiragana(cp) || IsKatakana(cp) || IsHan(cp))
+            hasJapanese = true;
+        if (IsArabicIndicDigit(cp))
+            hasArabicIndic = true;
+        if (IsExtendedArabicIndicDigit(cp))
+            hasExtendedArabicIndic = true;
+        // 3. CONTEXTO / CONTEXTJ Neighbor Rules
+        const prev = cps[i - 1], next = cps[i + 1];
+        switch (cp) {
+            case 0x00b7:
+                if (prev !== 0x006c || next !== 0x006c)
+                    return false;
+                break; // MIDDLE DOT (Catalan)
+            case 0x0375:
+                if (next === undefined || !IsGreek(next))
+                    return false;
+                break; // Greek KERAIA
+            case 0x05f3:
+            case 0x05f4:
+                if (prev === undefined || !IsHebrew(prev))
+                    return false;
+                break; // Hebrew GERESH
+            case 0x200d:
+                if (prev === undefined || !IsVirama(prev))
+                    return false;
+                break; // ZWJ
+            case 0x30fb: /* Checked at end via hasJapanese */
+                break; // KATAKANA MIDDLE DOT
+        }
+    }
+    // 4. Global Context Validations (Post-loop)
+    // RFC 5892 Appendix A.7 - Katakana Middle Dot requirement
+    if (value.includes('\u30fb') && !hasJapanese)
+        return false;
+    // RFC 5892 Appendix A.8/A.9 - Mixing Arabic Digits
+    if (hasArabicIndic && hasExtendedArabicIndic)
+        return false;
+    return true;
+}
+// ------------------------------------------------------------------
+// IsAsciiLabel
+// ------------------------------------------------------------------
+function IsAsciiLabel(value) {
+    // Must not start or end with a hyphen
+    if (value.charCodeAt(0) === 45 || value.charCodeAt(value.length - 1) === 45)
+        return false;
+    // RFC 5891 §4.2.3.1 : "--" at positions 3-4 is reserved for A-labels only
+    if (value.length >= 4 && value.charCodeAt(2) === 45 && value.charCodeAt(3) === 45)
+        return false;
+    // All characters must be alphanumeric or hyphen
+    for (let i = 0; i < value.length; i++) {
+        const ch = value.charCodeAt(i);
+        if (!((ch >= 97 && ch <= 122) || // a-z
+            (ch >= 65 && ch <= 90) || // A-Z
+            (ch >= 48 && ch <= 57) || // 0-9
+            ch === 45 // '-'
+        ))
+            return false;
+    }
+    return true;
+}
+// ------------------------------------------------------------------
+// IsPunyLabel
+// ------------------------------------------------------------------
+function IsPuny(value) {
+    return value.toLowerCase().startsWith('xn--');
+}
+function IsPunyLabel(value) {
+    try {
+        return IsUnicodeLabel(Puny.Decode(value.slice(4)));
+    }
+    catch {
+        return false; // invalid punycode encoding
+    }
+}
+// ------------------------------------------------------------------
+// IsIdnLabel
+// ------------------------------------------------------------------
+export function IsIdnLabel(value) {
+    if (value.length === 0 || value.length > 63)
+        return false;
+    return IsPuny(value) ? IsPunyLabel(value) : IsUnicodeLabel(value);
+}
+// ------------------------------------------------------------------
+// IsLabel
+// ------------------------------------------------------------------
+export function IsLabel(value) {
+    if (value.length === 0 || value.length > 63)
+        return false;
+    return IsPuny(value) ? IsPunyLabel(value) : IsAsciiLabel(value);
+}

package/node_modules/typebox/build/format/_puny.d.mts

@@ -0,0 +1 @@
+export declare function Decode(value: string): string;

package/node_modules/typebox/build/format/_puny.mjs

@@ -0,0 +1,74 @@
+// ------------------------------------------------------------------
+// PunyCode (RFC 3492)
+// ------------------------------------------------------------------
+const PUNYCODE_BASE = 36;
+const PUNYCODE_TMIN = 1;
+const PUNYCODE_TMAX = 26;
+const PUNYCODE_SKEW = 38;
+const PUNYCODE_DAMP = 700;
+const PUNYCODE_INITIAL_BIAS = 72;
+const PUNYCODE_INITIAL_N = 128;
+// ------------------------------------------------------------------
+// Adapt
+// ------------------------------------------------------------------
+function Adapt(delta, numPoints, firstTime) {
+    delta = firstTime ? Math.floor(delta / PUNYCODE_DAMP) : delta >> 1;
+    delta += Math.floor(delta / numPoints);
+    let k = 0;
+    while (delta > (((PUNYCODE_BASE - PUNYCODE_TMIN) * PUNYCODE_TMAX) >> 1)) {
+        delta = Math.floor(delta / (PUNYCODE_BASE - PUNYCODE_TMIN));
+        k += PUNYCODE_BASE;
+    }
+    return k + Math.floor(((PUNYCODE_BASE - PUNYCODE_TMIN + 1) * delta) / (delta + PUNYCODE_SKEW));
+}
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+export function Decode(value) {
+    const output = [];
+    let n = PUNYCODE_INITIAL_N;
+    let i = 0;
+    let bias = PUNYCODE_INITIAL_BIAS;
+    const delimIdx = value.lastIndexOf('-');
+    if (delimIdx > 0) {
+        for (let j = 0; j < delimIdx; j++) {
+            const cp = value.charCodeAt(j);
+            if (cp >= 128)
+                throw new Error('Invalid punycode: non-basic before delimiter');
+            output.push(cp);
+        }
+    }
+    let inIdx = delimIdx < 0 ? 0 : delimIdx + 1;
+    while (inIdx < value.length) {
+        const oldi = i;
+        let w = 1;
+        let k = PUNYCODE_BASE;
+        while (true) {
+            if (inIdx >= value.length)
+                throw new Error('Invalid punycode: unexpected end of input');
+            const ch = value.charCodeAt(inIdx++);
+            let digit;
+            if (ch >= 0x61 && ch <= 0x7a)
+                digit = ch - 0x61; // a-z => 0-25
+            else if (ch >= 0x30 && ch <= 0x39)
+                digit = ch - 0x30 + 26; // 0-9 => 26-35
+            else if (ch >= 0x41 && ch <= 0x5a)
+                digit = ch - 0x41; // A-Z => 0-25
+            else
+                throw new Error('Invalid punycode: bad digit character');
+            i += digit * w;
+            const t = k <= bias ? PUNYCODE_TMIN : k >= bias + PUNYCODE_TMAX ? PUNYCODE_TMAX : k - bias;
+            if (digit < t)
+                break;
+            w *= PUNYCODE_BASE - t;
+            k += PUNYCODE_BASE;
+        }
+        const outLen = output.length + 1;
+        bias = Adapt(i - oldi, outLen, oldi === 0);
+        n += Math.floor(i / outLen);
+        i %= outLen;
+        output.splice(i, 0, n);
+        i++;
+    }
+    return globalThis.String.fromCodePoint(...output);
+}

package/node_modules/typebox/build/format/_registry.d.mts

@@ -0,0 +1,15 @@
+export type TFormatCheckFunction = (value: string) => boolean;
+/** Clears all entries */
+export declare function Clear(): void;
+/** Returns format entries in this registry */
+export declare function Entries(): [string, TFormatCheckFunction][];
+/** Sets a format */
+export declare function Set(format: string, check: TFormatCheckFunction): void;
+/** Returns true if the registry has this format */
+export declare function Has(format: string): boolean;
+/** Gets a format or undefined if not exists */
+export declare function Get(format: string): TFormatCheckFunction | undefined;
+/** Tests a value against a format, if the format is not registered, true */
+export declare function Test(format: string, value: string): boolean;
+/** Resets all formats to defaults */
+export declare function Reset(): void;

package/node_modules/typebox/build/format/_registry.mjs

@@ -0,0 +1,96 @@
+import { IsDateTime } from './date_time.mjs';
+import { IsDate } from './date.mjs';
+import { IsDuration } from './duration.mjs';
+import { IsEmail } from './email.mjs';
+import { IsHostname } from './hostname.mjs';
+import { IsIdnEmail } from './idn_email.mjs';
+import { IsIdnHostname } from './idn_hostname.mjs';
+import { IsIPv4 } from './ipv4.mjs';
+import { IsIPv6 } from './ipv6.mjs';
+import { IsIriReference } from './iri_reference.mjs';
+import { IsIri } from './iri.mjs';
+import { IsJsonPointerUriFragment } from './json_pointer_uri_fragment.mjs';
+import { IsJsonPointer } from './json_pointer.mjs';
+import { IsRegex } from './regex.mjs';
+import { IsRelativeJsonPointer } from './relative_json_pointer.mjs';
+import { IsTime } from './time.mjs';
+import { IsUriReference } from './uri_reference.mjs';
+import { IsUriTemplate } from './uri_template.mjs';
+import { IsUri } from './uri.mjs';
+import { IsUrl } from './url.mjs';
+import { IsUuid } from './uuid.mjs';
+// ------------------------------------------------------------------
+// Formats
+// ------------------------------------------------------------------
+const formats = new Map();
+// ------------------------------------------------------------------
+// Clear
+// ------------------------------------------------------------------
+/** Clears all entries */
+export function Clear() {
+    formats.clear();
+}
+// ------------------------------------------------------------------
+// Entries
+// ------------------------------------------------------------------
+/** Returns format entries in this registry */
+export function Entries() {
+    return [...formats.entries()];
+}
+// ------------------------------------------------------------------
+// Set
+// ------------------------------------------------------------------
+/** Sets a format */
+export function Set(format, check) {
+    formats.set(format, check);
+}
+// ------------------------------------------------------------------
+// Has
+// ------------------------------------------------------------------
+/** Returns true if the registry has this format */
+export function Has(format) {
+    return formats.has(format);
+}
+// ------------------------------------------------------------------
+// Get
+// ------------------------------------------------------------------
+/** Gets a format or undefined if not exists */
+export function Get(format) {
+    return formats.get(format);
+}
+// ------------------------------------------------------------------
+// Test
+// ------------------------------------------------------------------
+/** Tests a value against a format, if the format is not registered, true */
+export function Test(format, value) {
+    return formats.get(format)?.(value) ?? true;
+}
+// ------------------------------------------------------------------
+// Reset
+// ------------------------------------------------------------------
+/** Resets all formats to defaults */
+export function Reset() {
+    Clear();
+    formats.set('date-time', IsDateTime);
+    formats.set('date', IsDate);
+    formats.set('duration', IsDuration);
+    formats.set('email', IsEmail);
+    formats.set('hostname', IsHostname);
+    formats.set('idn-email', IsIdnEmail);
+    formats.set('idn-hostname', IsIdnHostname);
+    formats.set('ipv4', IsIPv4);
+    formats.set('ipv6', IsIPv6);
+    formats.set('iri-reference', IsIriReference);
+    formats.set('iri', IsIri);
+    formats.set('json-pointer-uri-fragment', IsJsonPointerUriFragment);
+    formats.set('json-pointer', IsJsonPointer);
+    formats.set('regex', IsRegex);
+    formats.set('relative-json-pointer', IsRelativeJsonPointer);
+    formats.set('time', IsTime);
+    formats.set('uri-reference', IsUriReference);
+    formats.set('uri-template', IsUriTemplate);
+    formats.set('uri', IsUri);
+    formats.set('url', IsUrl);
+    formats.set('uuid', IsUuid);
+}
+Reset();

package/node_modules/typebox/build/format/date.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the value is a ISO8601 Date component string
+ * @source ajv-formats
+ * @example `2020-12-12`
+ */
+export declare function IsDate(value: string): boolean;

package/node_modules/typebox/build/format/date.mjs

@@ -0,0 +1,19 @@
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+function IsLeapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+/**
+ * Returns true if the value is a ISO8601 Date component string
+ * @source ajv-formats
+ * @example `2020-12-12`
+ */
+export function IsDate(value) {
+    const matches = DATE.exec(value);
+    if (!matches)
+        return false;
+    const year = +matches[1];
+    const month = +matches[2];
+    const day = +matches[3];
+    return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && IsLeapYear(year) ? 29 : DAYS[month]);
+}

package/node_modules/typebox/build/format/date_time.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the value is a ISO8601 DateTime string
+ * @source ajv-formats
+ * @example `2020-12-12T20:20:40+00:00`
+ */
+export declare function IsDateTime(value: string, strictTimeZone?: boolean): boolean;