@openclaw/tavily-plugin 0.0.0 → 2026.6.11-beta.2

package/node_modules/typebox/build/schema/static/patternProperties.d.mts

@@ -0,0 +1,7 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticPatternProperties<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>, InferredProperties extends Record<PropertyKey, unknown> = {
+    [Key in keyof Properties]: XStaticSchema<Stack, Root, Properties[Key]>;
+}, EvaluatedProperties extends unknown = {
+    [key: string]: InferredProperties[keyof InferredProperties];
+}> = EvaluatedProperties;

package/node_modules/typebox/build/schema/static/patternProperties.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/typebox/build/schema/static/prefixItems.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticElements } from './_elements.mjs';
+export type XStaticPrefixItems<Stack extends string[], Root extends XSchema, Schema extends XSchema, PrefixItems extends XSchema[], Result extends unknown[] = XStaticElements<Stack, Root, Schema, PrefixItems>> = Result;

package/node_modules/typebox/build/schema/static/prefixItems.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/typebox/build/schema/static/properties.d.mts

@@ -0,0 +1,32 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XRequired } from '../types/required.mjs';
+import type { XStaticSchema } from './schema.mjs';
+type XIsReadonly<Schema extends XSchema> = (Schema extends {
+    readOnly: true;
+} ? true : Schema extends {
+    '~readonly': true;
+} ? true : false);
+type XRequiredArray<Schema extends XSchema, Result extends PropertyKey[] = Schema extends XRequired<infer Keys extends string[]> ? Keys : []> = Result;
+type XReadonlyKeys<Properties extends Record<PropertyKey, XSchema>, ReadonlyProperties extends Record<PropertyKey, unknown> = {
+    [Key in keyof Properties as XIsReadonly<Properties[Key]> extends true ? Key : never]: unknown;
+}, Result extends PropertyKey = keyof ReadonlyProperties> = Result;
+type XRequiredKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[], Result extends PropertyKey = RequiredArray extends [] ? never : Extract<keyof Properties, RequiredArray[number]>> = Result;
+type XUnknownKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[], Result extends PropertyKey = Exclude<RequiredArray[number], keyof Properties>> = Result;
+type XOptionalKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[], Result extends PropertyKey = RequiredArray extends [] ? keyof Properties : Exclude<keyof Properties, RequiredArray[number]>> = Result;
+type XReadonlyOptionalProperties<Stack extends string[], Root extends XSchema, OptionalKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+    readonly [Key in Extract<keyof Properties, OptionalKeys>]?: XStaticSchema<Stack, Root, Properties[Key]>;
+};
+type XReadonlyRequiredProperties<Stack extends string[], Root extends XSchema, RequiredKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+    readonly [Key in Extract<keyof Properties, RequiredKeys>]: XStaticSchema<Stack, Root, Properties[Key]>;
+};
+type XOptionalProperties<Stack extends string[], Root extends XSchema, OptionalKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+    [Key in Extract<keyof Properties, OptionalKeys>]?: XStaticSchema<Stack, Root, Properties[Key]>;
+};
+type XRequiredProperties<Stack extends string[], Root extends XSchema, RequiredKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+    [Key in Extract<keyof Properties, RequiredKeys>]: XStaticSchema<Stack, Root, Properties[Key]>;
+};
+type XUnknownProperties<UnknownKeys extends PropertyKey> = {
+    [Key in UnknownKeys]: unknown;
+};
+export type XStaticProperties<Stack extends string[], Root extends XSchema, Schema extends XSchema, Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[] = XRequiredArray<Schema>, ReadonlyKeys extends PropertyKey = XReadonlyKeys<Properties>, OptionalKeys extends PropertyKey = XOptionalKeys<Properties, RequiredArray>, RequiredKeys extends PropertyKey = XRequiredKeys<Properties, RequiredArray>, UnknownKeys extends PropertyKey = XUnknownKeys<Properties, RequiredArray>, ReadonlyOptionalProperties extends Record<PropertyKey, unknown> = XReadonlyOptionalProperties<Stack, Root, Extract<OptionalKeys, ReadonlyKeys>, Properties>, ReadonlyRequiredProperties extends Record<PropertyKey, unknown> = XReadonlyRequiredProperties<Stack, Root, Extract<RequiredKeys, ReadonlyKeys>, Properties>, OptionalProperties extends Record<PropertyKey, unknown> = XOptionalProperties<Stack, Root, Exclude<OptionalKeys, ReadonlyKeys>, Properties>, RequiredProperties extends Record<PropertyKey, unknown> = XRequiredProperties<Stack, Root, Exclude<RequiredKeys, ReadonlyKeys>, Properties>, UnknownProperties extends Record<PropertyKey, unknown> = XUnknownProperties<UnknownKeys>, Result extends Record<PropertyKey, unknown> = (ReadonlyOptionalProperties & ReadonlyRequiredProperties & OptionalProperties & RequiredProperties & UnknownProperties)> = Result;
+export {};

package/node_modules/typebox/build/schema/static/properties.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/typebox/build/schema/static/ref.d.mts

@@ -0,0 +1,8 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XPointerGet } from '../pointer/pointer_get.mjs';
+import type { XStaticSchema } from './schema.mjs';
+type XCyclicCheck<Stack extends unknown[], MaxLength extends number, Buffer extends unknown[] = []> = (Stack extends [infer Left, ...infer Right] ? Buffer['length'] extends MaxLength ? false : XCyclicCheck<Right, MaxLength, [...Buffer, Left]> : true);
+type XCyclicGuard<Stack extends unknown[], Ref extends string> = (Ref extends Stack[number] ? XCyclicCheck<Stack, 2> : true);
+type XNormal<Pointer extends string, Result extends string = (Pointer extends `#${infer Rest extends string}` ? Rest : Pointer)> = Result;
+export type XStaticRef<Stack extends string[], Root extends XSchema, Ref extends string, Normal extends string = XNormal<Ref>, Target extends unknown = XPointerGet<Root, Normal>, Schema extends XSchema = Target extends XSchema ? Target : {}, Result extends unknown = (XCyclicGuard<Stack, Ref> extends true ? XStaticSchema<[...Stack, Ref], Root, Schema> : any)> = Result;
+export {};

package/node_modules/typebox/build/schema/static/ref.mjs

@@ -0,0 +1,3 @@
+// deno-lint-ignore-file ban-types no-explicit-any
+// deno-fmt-ignore-file
+export {};

package/node_modules/typebox/build/schema/static/required.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XProperties } from '../types/properties.mjs';
+export type XStaticRequired<_Stack extends string[], _Root extends XSchema, Schema extends XSchema, Keys extends string[], Result extends Record<PropertyKey, unknown> = Schema extends XProperties ? {} : Record<Keys[number], unknown>> = Result;

package/node_modules/typebox/build/schema/static/required.mjs

@@ -0,0 +1,3 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+export {};

package/node_modules/typebox/build/schema/static/schema.d.mts

@@ -0,0 +1,56 @@
+import type { XAdditionalProperties } from '../types/additionalProperties.mjs';
+import type { XAnyOf } from '../types/anyOf.mjs';
+import type { XAllOf } from '../types/allOf.mjs';
+import type { XConst } from '../types/const.mjs';
+import type { XEnum } from '../types/enum.mjs';
+import type { XIf } from '../types/if.mjs';
+import type { XItems } from '../types/items.mjs';
+import type { XOneOf } from '../types/oneOf.mjs';
+import type { XPatternProperties } from '../types/patternProperties.mjs';
+import type { XPrefixItems } from '../types/prefixItems.mjs';
+import type { XProperties } from '../types/properties.mjs';
+import type { XRef } from '../types/ref.mjs';
+import type { XRequired } from '../types/required.mjs';
+import type { XSchema } from '../types/schema.mjs';
+import type { XType } from '../types/type.mjs';
+import type { XUnevaluatedProperties } from '../types/unevaluatedProperties.mjs';
+import type { XStaticAdditionalProperties } from './additionalProperties.mjs';
+import type { XStaticAllOf } from './allOf.mjs';
+import type { XStaticAnyOf } from './anyOf.mjs';
+import type { XStaticConst } from './const.mjs';
+import type { XStaticEnum } from './enum.mjs';
+import type { XStaticIf } from './if.mjs';
+import type { XStaticItems } from './items.mjs';
+import type { XStaticOneOf } from './oneOf.mjs';
+import type { XStaticPatternProperties } from './patternProperties.mjs';
+import type { XStaticPrefixItems } from './prefixItems.mjs';
+import type { XStaticProperties } from './properties.mjs';
+import type { XStaticRef } from './ref.mjs';
+import type { XStaticRequired } from './required.mjs';
+import type { XStaticType } from './type.mjs';
+import type { XStaticUnevaluatedProperties } from './unevaluatedProperties.mjs';
+type XFromKeywords<Stack extends string[], Root extends XSchema, Schema extends XSchema, Result extends unknown[] = [
+    Schema extends XAdditionalProperties<infer Type extends XSchema> ? XStaticAdditionalProperties<Stack, Root, Type> : unknown,
+    Schema extends XAllOf<infer Types extends XSchema[]> ? XStaticAllOf<Stack, Root, Types> : unknown,
+    Schema extends XAnyOf<infer Types extends XSchema[]> ? XStaticAnyOf<Stack, Root, Types> : unknown,
+    Schema extends XConst<infer Value extends unknown> ? XStaticConst<Value> : unknown,
+    Schema extends XIf<infer Type extends XSchema> ? XStaticIf<Stack, Root, Schema, Type> : unknown,
+    Schema extends XEnum<infer Values extends unknown[]> ? XStaticEnum<Values> : unknown,
+    Schema extends XItems<infer Types extends XSchema[] | XSchema> ? XStaticItems<Stack, Root, Schema, Types> : unknown,
+    Schema extends XOneOf<infer Types extends XSchema[]> ? XStaticOneOf<Stack, Root, Types> : unknown,
+    Schema extends XPatternProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticPatternProperties<Stack, Root, Properties> : unknown,
+    Schema extends XPrefixItems<infer Types extends XSchema[]> ? XStaticPrefixItems<Stack, Root, Schema, Types> : unknown,
+    Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticProperties<Stack, Root, Schema, Properties> : unknown,
+    Schema extends XRef<infer Ref extends string> ? XStaticRef<Stack, Root, Ref> : unknown,
+    Schema extends XRequired<infer Keys extends string[]> ? XStaticRequired<Stack, Root, Schema, Keys> : unknown,
+    Schema extends XType<infer TypeName extends string[] | string> ? XStaticType<TypeName> : unknown,
+    Schema extends XUnevaluatedProperties<infer Type extends XSchema> ? XStaticUnevaluatedProperties<Stack, Root, Type> : unknown
+]> = Result;
+type XKeywordsIntersected<Schemas extends unknown[], Result extends unknown = unknown> = (Schemas extends [infer Left extends unknown, ...infer Right extends unknown[]] ? XKeywordsIntersected<Right, Result & Left> : Result);
+type XKeywordsEvaluated<Schema extends unknown, Result extends unknown = Schema extends object ? {
+    [Key in keyof Schema]: Schema[Key];
+} : Schema> = Result;
+export type XStaticObject<Stack extends string[], Root extends XSchema, Schema extends XSchema, Keywords extends unknown[] = XFromKeywords<Stack, Root, Schema>, Intersected extends unknown = XKeywordsIntersected<Keywords>, Evaluated extends unknown = XKeywordsEvaluated<Intersected>> = Evaluated;
+export type XStaticBoolean<Schema extends boolean, Result extends unknown = Schema extends false ? never : unknown> = Result;
+export type XStaticSchema<Stack extends string[], Root extends XSchema, Schema extends XSchema, Result extends unknown = Schema extends boolean ? XStaticBoolean<Schema> : XStaticObject<Stack, Root, Schema>> = Result;
+export {};

package/node_modules/typebox/build/schema/static/schema.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/node_modules/typebox/build/schema/static/static.d.mts

@@ -0,0 +1,4 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XCanonical } from './_canonical.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStatic<Value extends unknown, Schema extends XSchema = Value extends XSchema ? Value : {}, Canonical extends XSchema = XCanonical<Schema>, Result extends unknown = XStaticSchema<[], Canonical, Canonical>> = Result;

package/node_modules/typebox/build/schema/static/static.mjs

@@ -0,0 +1,3 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+export {};

package/node_modules/typebox/build/schema/static/type.d.mts

@@ -0,0 +1,4 @@
+type XFromTypeNames<TypeNames extends string[], Result extends unknown = never> = (TypeNames extends readonly [infer Left extends string, ...infer Right extends string[]] ? XFromTypeNames<Right, Result | XFromTypeName<Left>> : Result);
+type XFromTypeName<TypeName extends string> = (TypeName extends 'object' ? object : TypeName extends 'array' ? {} : TypeName extends 'boolean' ? boolean : TypeName extends 'integer' ? number : TypeName extends 'number' ? number : TypeName extends 'null' ? null : TypeName extends 'string' ? string : TypeName extends 'bigint' ? bigint : TypeName extends 'symbol' ? symbol : TypeName extends 'undefined' ? undefined : TypeName extends 'void' ? void : TypeName extends 'asyncIterator' ? {} : TypeName extends 'constructor' ? {} : TypeName extends 'function' ? {} : TypeName extends 'iterator' ? {} : unknown);
+export type XStaticType<TypeName extends string[] | string> = (TypeName extends string[] ? XFromTypeNames<TypeName> : TypeName extends string ? XFromTypeName<TypeName> : unknown);
+export {};

package/node_modules/typebox/build/schema/static/type.mjs

@@ -0,0 +1,3 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+export {};

package/node_modules/typebox/build/schema/static/unevaluatedProperties.d.mts

@@ -0,0 +1,7 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticUnevaluatedProperties<Stack extends string[], Root extends XSchema, Schema extends XSchema, Result extends Record<PropertyKey, unknown> = (Schema extends true ? {
+    [key: string]: unknown;
+} : Schema extends false ? {} : {
+    [key: string]: XStaticSchema<Stack, Root, Schema>;
+})> = Result;

package/node_modules/typebox/build/schema/static/unevaluatedProperties.mjs

@@ -0,0 +1,3 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+export {};

package/node_modules/typebox/build/schema/types/_guard.d.mts

@@ -0,0 +1,10 @@
+import type { XSchemaObject } from './schema.mjs';
+export interface XGuardInterface<Value extends unknown = unknown> {
+    check(value: unknown): value is Value;
+    errors(value: unknown): object[];
+}
+export interface XGuard<Value extends unknown = unknown> {
+    '~guard': XGuardInterface<Value>;
+}
+export declare function IsGuardInterface(value: unknown): value is XGuardInterface;
+export declare function IsGuard(value: XSchemaObject): value is XGuard;

package/node_modules/typebox/build/schema/types/_guard.mjs

@@ -0,0 +1,16 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+export function IsGuardInterface(value) {
+    return Guard.IsObject(value)
+        && Guard.HasPropertyKey(value, 'check')
+        && Guard.HasPropertyKey(value, 'errors')
+        && Guard.IsFunction(value.check)
+        && Guard.IsFunction(value.errors);
+}
+export function IsGuard(value) {
+    return Guard.HasPropertyKey(value, '~guard')
+        && IsGuardInterface(value['~guard']);
+}

package/node_modules/typebox/build/schema/types/_refine.d.mts

@@ -0,0 +1,13 @@
+import type { XSchemaObject } from './schema.mjs';
+export interface XRefinement {
+    check: (value: unknown) => boolean;
+    error: (value: unknown) => string;
+}
+export interface XRefine<Refinements extends XRefinement[] = XRefinement[]> {
+    '~refine': Refinements;
+}
+/**
+ * Returns true if the schema contains an '~refine` keyword
+ * @specification None
+ */
+export declare function IsRefine(value: XSchemaObject): value is XRefine;

package/node_modules/typebox/build/schema/types/_refine.mjs

@@ -0,0 +1,18 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains an '~refine` keyword
+ * @specification None
+ */
+export function IsRefine(value) {
+    return Guard.HasPropertyKey(value, '~refine')
+        && Guard.IsArray(value["~refine"])
+        && Guard.Every(value['~refine'], 0, value => Guard.IsObject(value)
+            && Guard.HasPropertyKey(value, 'check')
+            && Guard.HasPropertyKey(value, 'error')
+            && Guard.IsFunction(value.check)
+            && Guard.IsFunction(value.error));
+}

package/node_modules/typebox/build/schema/types/additionalItems.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from '../types/schema.mjs';
+export interface XAdditionalItems<AdditionalItems extends XSchema = XSchema> {
+    additionalItems: AdditionalItems;
+}
+/**
+ * Returns true if the schema contains a valid additionalItems property
+ * @specification Json Schema 7
+ */
+export declare function IsAdditionalItems(schema: XSchemaObject): schema is XAdditionalItems;

package/node_modules/typebox/build/schema/types/additionalItems.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from '../types/schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid additionalItems property
+ * @specification Json Schema 7
+ */
+export function IsAdditionalItems(schema) {
+    return Guard.HasPropertyKey(schema, 'additionalItems')
+        && IsSchema(schema.additionalItems);
+}

package/node_modules/typebox/build/schema/types/additionalProperties.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XAdditionalProperties<AdditionalProperties extends XSchema = XSchema> {
+    additionalProperties: AdditionalProperties;
+}
+/**
+ * Returns true if the schema contains a valid additionalProperties property
+ * @specification Json Schema 7
+ */
+export declare function IsAdditionalProperties(schema: XSchemaObject): schema is XAdditionalProperties;

package/node_modules/typebox/build/schema/types/additionalProperties.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid additionalProperties property
+ * @specification Json Schema 7
+ */
+export function IsAdditionalProperties(schema) {
+    return Guard.HasPropertyKey(schema, 'additionalProperties')
+        && IsSchema(schema.additionalProperties);
+}

package/node_modules/typebox/build/schema/types/allOf.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XAllOf<AllOf extends XSchema[] = XSchema[]> {
+    allOf: AllOf;
+}
+/**
+ * Returns true if the schema contains a valid allOf property
+ * @specification Json Schema 7
+ */
+export declare function IsAllOf(schema: XSchemaObject): schema is XAllOf;

package/node_modules/typebox/build/schema/types/allOf.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid allOf property
+ * @specification Json Schema 7
+ */
+export function IsAllOf(schema) {
+    return Guard.HasPropertyKey(schema, 'allOf')
+        && Guard.IsArray(schema.allOf)
+        && schema.allOf.every(value => IsSchema(value));
+}

package/node_modules/typebox/build/schema/types/anchor.d.mts

@@ -0,0 +1,8 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XAnchor<Anchor extends string = string> {
+    $anchor: Anchor;
+}
+/**
+ * Returns true if the schema contains a valid $anchor property
+ */
+export declare function IsAnchor(schema: XSchemaObject): schema is XAnchor;

package/node_modules/typebox/build/schema/types/anchor.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid $anchor property
+ */
+export function IsAnchor(schema) {
+    return Guard.HasPropertyKey(schema, '$anchor')
+        && Guard.IsString(schema.$anchor);
+}

package/node_modules/typebox/build/schema/types/anyOf.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XAnyOf<AnyOf extends XSchema[] = XSchema[]> {
+    anyOf: AnyOf;
+}
+/**
+ * Returns true if the schema contains a valid anyOf property
+ * @specification Json Schema 7
+ */
+export declare function IsAnyOf(schema: XSchemaObject): schema is XAnyOf;

package/node_modules/typebox/build/schema/types/anyOf.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid anyOf property
+ * @specification Json Schema 7
+ */
+export function IsAnyOf(schema) {
+    return Guard.HasPropertyKey(schema, 'anyOf')
+        && Guard.IsArray(schema.anyOf)
+        && schema.anyOf.every(value => IsSchema(value));
+}

package/node_modules/typebox/build/schema/types/const.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XConst<Const extends unknown = unknown> {
+    const: Const;
+}
+/**
+ * Returns true if the schema contains a valid const property
+ * @specification Json Schema 7
+ */
+export declare function IsConst(value: XSchemaObject): value is XConst;

package/node_modules/typebox/build/schema/types/const.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid const property
+ * @specification Json Schema 7
+ */
+export function IsConst(value) {
+    return Guard.HasPropertyKey(value, 'const');
+}

package/node_modules/typebox/build/schema/types/contains.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XContains<Contains extends XSchema = XSchema> {
+    contains: Contains;
+}
+/**
+ * Returns true if the schema contains a valid contains property
+ * @specification Json Schema 7
+ */
+export declare function IsContains(schema: XSchemaObject): schema is XContains;

package/node_modules/typebox/build/schema/types/contains.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid contains property
+ * @specification Json Schema 7
+ */
+export function IsContains(schema) {
+    return Guard.HasPropertyKey(schema, 'contains')
+        && IsSchema(schema.contains);
+}

package/node_modules/typebox/build/schema/types/contentEncoding.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XContentEncoding<ContentEncoding extends string = string> {
+    contentEncoding: ContentEncoding;
+}
+/**
+ * Returns true if the schema contains a valid contentEncoding property
+ * @specification Json Schema 7
+ */
+export declare function IsContentEncoding(schema: XSchemaObject): schema is XContentEncoding;

package/node_modules/typebox/build/schema/types/contentEncoding.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid contentEncoding property
+ * @specification Json Schema 7
+ */
+export function IsContentEncoding(schema) {
+    return Guard.HasPropertyKey(schema, 'contentEncoding')
+        && Guard.IsString(schema.contentEncoding);
+}

package/node_modules/typebox/build/schema/types/contentMediaType.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XContentMediaType<ContentMediaType extends string = string> {
+    contentMediaType: ContentMediaType;
+}
+/**
+ * Returns true if the schema contains a valid contentMediaType property
+ * @specification Json Schema 7
+ */
+export declare function IsContentMediaType(schema: XSchemaObject): schema is XContentMediaType;

package/node_modules/typebox/build/schema/types/contentMediaType.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid contentMediaType property
+ * @specification Json Schema 7
+ */
+export function IsContentMediaType(schema) {
+    return Guard.HasPropertyKey(schema, 'contentMediaType')
+        && Guard.IsString(schema.contentMediaType);
+}

package/node_modules/typebox/build/schema/types/default.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XDefault<Default extends unknown = unknown> {
+    default: Default;
+}
+/**
+ * Returns true if the schema contains a valid contentMediaType property
+ * @specification Json Schema 7
+ */
+export declare function IsDefault(schema: XSchemaObject): schema is XDefault;

package/node_modules/typebox/build/schema/types/default.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid contentMediaType property
+ * @specification Json Schema 7
+ */
+export function IsDefault(schema) {
+    return Guard.HasPropertyKey(schema, 'default');
+}

package/node_modules/typebox/build/schema/types/defs.d.mts

@@ -0,0 +1,6 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XDefs<Defs extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>> {
+    $defs: Defs;
+}
+/** Returns true if the schema contains a valid $defs property */
+export declare function IsDefs(schema: XSchemaObject): schema is XDefs;

package/node_modules/typebox/build/schema/types/defs.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the schema contains a valid $defs property */
+export function IsDefs(schema) {
+    return Guard.HasPropertyKey(schema, '$defs')
+        && Guard.IsObject(schema.$defs)
+        && Object.values(schema.$defs).every(value => IsSchema(value));
+}

package/node_modules/typebox/build/schema/types/dependencies.d.mts

@@ -0,0 +1,11 @@
+import { type XSchemaObject } from './schema.mjs';
+type XDependenciesProperty = Record<PropertyKey, boolean | Record<PropertyKey, unknown> | string[]>;
+export interface XDependencies<Dependencies extends XDependenciesProperty = XDependenciesProperty> {
+    dependencies: Dependencies;
+}
+/**
+ * Returns true if the schema contains a valid dependencies property
+ * @specification Json Schema 7
+ */
+export declare function IsDependencies(schema: XSchemaObject): schema is XDependencies;
+export {};

package/node_modules/typebox/build/schema/types/dependencies.mjs

@@ -0,0 +1,16 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid dependencies property
+ * @specification Json Schema 7
+ */
+export function IsDependencies(schema) {
+    return Guard.HasPropertyKey(schema, 'dependencies')
+        && Guard.IsObject(schema.dependencies)
+        && Object.values(schema.dependencies).every(value => IsSchema(value)
+            || Guard.IsArray(value) && value.every(value => Guard.IsString(value)));
+}

package/node_modules/typebox/build/schema/types/dependentRequired.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XDependentRequired<DependentRequired extends Record<PropertyKey, string[]> = Record<PropertyKey, string[]>> {
+    dependentRequired: DependentRequired;
+}
+/**
+ * Returns true if the schema contains a valid dependentRequired property
+ * @specification Json Schema 2019-09
+ */
+export declare function IsDependentRequired(schema: XSchemaObject): schema is XDependentRequired;

package/node_modules/typebox/build/schema/types/dependentRequired.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid dependentRequired property
+ * @specification Json Schema 2019-09
+ */
+export function IsDependentRequired(schema) {
+    return Guard.HasPropertyKey(schema, 'dependentRequired')
+        && Guard.IsObject(schema.dependentRequired)
+        && Object.values(schema.dependentRequired).every(value => Guard.IsArray(value)
+            && value.every(value => Guard.IsString(value)));
+}

package/node_modules/typebox/build/schema/types/dependentSchemas.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XDependentSchemas<DependentSchemas extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>> {
+    dependentSchemas: DependentSchemas;
+}
+/**
+ * Returns true if the schema contains a valid dependentRequired property
+ * @specification Json Schema 2019-09
+ */
+export declare function IsDependentSchemas(schema: XSchemaObject): schema is XDependentSchemas;

package/node_modules/typebox/build/schema/types/dependentSchemas.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid dependentRequired property
+ * @specification Json Schema 2019-09
+ */
+export function IsDependentSchemas(schema) {
+    return Guard.HasPropertyKey(schema, 'dependentSchemas')
+        && Guard.IsObject(schema.dependentSchemas)
+        && Object.values(schema.dependentSchemas).every(value => IsSchema(value));
+}