pi-proactive 0.2.0-beta.5 → 0.2.0-beta.6

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

@@ -1,59 +0,0 @@
-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 { XPropertyNames } from '../types/propertyNames.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 { XStaticPropertyNames } from './propertyNames.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 XPropertyNames<infer Type extends XSchema> ? XStaticPropertyNames<Stack, Root, Type> : 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

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

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

@@ -1,4 +0,0 @@
-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

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

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

@@ -1,4 +0,0 @@
-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

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

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

@@ -1,7 +0,0 @@
-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

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,18 +0,0 @@
-// 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

@@ -1,9 +0,0 @@
-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

@@ -1,14 +0,0 @@
-// 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

@@ -1,9 +0,0 @@
-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

@@ -1,14 +0,0 @@
-// 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

@@ -1,9 +0,0 @@
-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

@@ -1,15 +0,0 @@
-// 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

@@ -1,8 +0,0 @@
-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

@@ -1,12 +0,0 @@
-// 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

@@ -1,9 +0,0 @@
-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

@@ -1,15 +0,0 @@
-// 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

@@ -1,9 +0,0 @@
-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

@@ -1,12 +0,0 @@
-// 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

@@ -1,9 +0,0 @@
-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

@@ -1,14 +0,0 @@
-// 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/default.d.mts

@@ -1,9 +0,0 @@
-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

@@ -1,12 +0,0 @@
-// 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

@@ -1,6 +0,0 @@
-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

@@ -1,12 +0,0 @@
-// 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

@@ -1,11 +0,0 @@
-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

@@ -1,16 +0,0 @@
-// 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

@@ -1,9 +0,0 @@
-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

@@ -1,15 +0,0 @@
-// 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

@@ -1,9 +0,0 @@
-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

@@ -1,15 +0,0 @@
-// 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));
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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