@daniel156161/prism 0.2.76 → 0.2.78

package/node_modules/@earendil-works/pi-protocol/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/@earendil-works/pi-protocol/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/@earendil-works/pi-protocol/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));
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/dynamicAnchor.d.mts

@@ -0,0 +1,8 @@
+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/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/dynamicAnchor.mjs

@@ -0,0 +1,12 @@
+// 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/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/dynamicRef.d.mts

@@ -0,0 +1,8 @@
+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/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/dynamicRef.mjs

@@ -0,0 +1,12 @@
+// 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/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/else.d.mts

@@ -0,0 +1,9 @@
+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/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/else.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 else property
+ * @specification Json Schema 7
+ */
+export function IsElse(schema) {
+    return Guard.HasPropertyKey(schema, 'else')
+        && IsSchema(schema.else);
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/enum.d.mts

@@ -0,0 +1,9 @@
+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/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/enum.mjs

@@ -0,0 +1,13 @@
+// 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/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/exclusiveMaximum.d.mts

@@ -0,0 +1,9 @@
+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/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/exclusiveMaximum.mjs

@@ -0,0 +1,13 @@
+// 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/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/exclusiveMinimum.d.mts

@@ -0,0 +1,9 @@
+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/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/exclusiveMinimum.mjs

@@ -0,0 +1,13 @@
+// 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/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/format.d.mts

@@ -0,0 +1,9 @@
+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/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/format.mjs

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/id.d.mts

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/id.mjs

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/if.d.mts

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/if.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 $id property
+ * @specification Json Schema 7
+ */
+export function IsIf(schema) {
+    return Guard.HasPropertyKey(schema, 'if')
+        && IsSchema(schema.if);
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/index.d.mts

@@ -0,0 +1,53 @@
+export * from './_refine.mjs';
+export * from './additionalItems.mjs';
+export * from './additionalProperties.mjs';
+export * from './allOf.mjs';
+export * from './anchor.mjs';
+export * from './anyOf.mjs';
+export * from './const.mjs';
+export * from './contains.mjs';
+export * from './contentEncoding.mjs';
+export * from './contentMediaType.mjs';
+export * from './default.mjs';
+export * from './defs.mjs';
+export * from './dependencies.mjs';
+export * from './dependentRequired.mjs';
+export * from './dependentSchemas.mjs';
+export * from './dynamicAnchor.mjs';
+export * from './dynamicRef.mjs';
+export * from './else.mjs';
+export * from './enum.mjs';
+export * from './exclusiveMaximum.mjs';
+export * from './exclusiveMinimum.mjs';
+export * from './format.mjs';
+export * from './id.mjs';
+export * from './if.mjs';
+export * from './items.mjs';
+export * from './maximum.mjs';
+export * from './maxContains.mjs';
+export * from './maxItems.mjs';
+export * from './maxLength.mjs';
+export * from './maxProperties.mjs';
+export * from './minimum.mjs';
+export * from './minContains.mjs';
+export * from './minItems.mjs';
+export * from './minLength.mjs';
+export * from './minProperties.mjs';
+export * from './multipleOf.mjs';
+export * from './not.mjs';
+export * from './oneOf.mjs';
+export * from './pattern.mjs';
+export * from './patternProperties.mjs';
+export * from './prefixItems.mjs';
+export * from './properties.mjs';
+export * from './propertyNames.mjs';
+export * from './recursiveAnchor.mjs';
+export * from './recursiveRef.mjs';
+export * from './ref.mjs';
+export * from './required.mjs';
+export * from './schema.mjs';
+export * from './then.mjs';
+export * from './type.mjs';
+export * from './uniqueItems.mjs';
+export * from './unevaluatedItems.mjs';
+export * from './unevaluatedProperties.mjs';

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/index.mjs

@@ -0,0 +1,59 @@
+// ------------------------------------------------------------------
+// Extensions
+// ------------------------------------------------------------------
+export * from './_refine.mjs';
+// ------------------------------------------------------------------
+// Standard
+// ------------------------------------------------------------------
+export * from './additionalItems.mjs';
+export * from './additionalProperties.mjs';
+export * from './allOf.mjs';
+export * from './anchor.mjs';
+export * from './anyOf.mjs';
+export * from './const.mjs';
+export * from './contains.mjs';
+export * from './contentEncoding.mjs';
+export * from './contentMediaType.mjs';
+export * from './default.mjs';
+export * from './defs.mjs';
+export * from './dependencies.mjs';
+export * from './dependentRequired.mjs';
+export * from './dependentSchemas.mjs';
+export * from './dynamicAnchor.mjs';
+export * from './dynamicRef.mjs';
+export * from './else.mjs';
+export * from './enum.mjs';
+export * from './exclusiveMaximum.mjs';
+export * from './exclusiveMinimum.mjs';
+export * from './format.mjs';
+export * from './id.mjs';
+export * from './if.mjs';
+export * from './items.mjs';
+export * from './maximum.mjs';
+export * from './maxContains.mjs';
+export * from './maxItems.mjs';
+export * from './maxLength.mjs';
+export * from './maxProperties.mjs';
+export * from './minimum.mjs';
+export * from './minContains.mjs';
+export * from './minItems.mjs';
+export * from './minLength.mjs';
+export * from './minProperties.mjs';
+export * from './multipleOf.mjs';
+export * from './not.mjs';
+export * from './oneOf.mjs';
+export * from './pattern.mjs';
+export * from './patternProperties.mjs';
+export * from './prefixItems.mjs';
+export * from './properties.mjs';
+export * from './propertyNames.mjs';
+export * from './recursiveAnchor.mjs';
+export * from './recursiveRef.mjs';
+export * from './ref.mjs';
+export * from './required.mjs';
+export * from './schema.mjs';
+export * from './then.mjs';
+export * from './type.mjs';
+export * from './uniqueItems.mjs';
+export * from './unevaluatedItems.mjs';
+export * from './unevaluatedProperties.mjs';

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/items.d.mts

@@ -0,0 +1,19 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XItemsSized<Items extends XSchema[] = XSchema[]> {
+    items: Items;
+}
+export interface XItemsUnsized<Items extends XSchema = XSchema> {
+    items: Items;
+}
+export interface XItems<Items extends (XSchema | XSchema[]) = (XSchema | XSchema[])> {
+    items: Items;
+}
+/**
+ * Returns true if the schema contains a valid items property
+ * @specification Json Schema 7
+ */
+export declare function IsItems(schema: XSchemaObject): schema is XItems;
+/** Returns true if this schema is a sized items variant */
+export declare function IsItemsSized(schema: XSchemaObject): schema is XItemsSized;
+/** Returns true if this schema is a unsized items variant */
+export declare function IsItemsUnsized(schema: XSchemaObject): schema is XItemsUnsized;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/items.mjs

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid items property
+ * @specification Json Schema 7
+ */
+export function IsItems(schema) {
+    return Guard.HasPropertyKey(schema, 'items')
+        && (IsSchema(schema.items)
+            || (Guard.IsArray(schema.items)
+                && schema.items.every(value => {
+                    return IsSchema(value);
+                })));
+}
+/** Returns true if this schema is a sized items variant */
+export function IsItemsSized(schema) {
+    return IsItems(schema) && Guard.IsArray(schema.items);
+}
+/** Returns true if this schema is a unsized items variant */
+export function IsItemsUnsized(schema) {
+    return IsItems(schema) && !Guard.IsArray(schema.items);
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/maxContains.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMaxContains<MaxContains extends number = number> {
+    maxContains: MaxContains;
+}
+/**
+ * Returns true if the schema contains a valid maxContains property
+ * @specification Json Schema 2019-09
+ */
+export declare function IsMaxContains(schema: XSchemaObject): schema is XMaxContains;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/maxContains.mjs

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/maxItems.d.mts

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/maxItems.mjs

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/maxLength.d.mts

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/maxLength.mjs

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/maxProperties.d.mts

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/maxProperties.mjs

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/maximum.d.mts

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/maximum.mjs

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/minContains.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMinContains<MinContains extends number = number> {
+    minContains: MinContains;
+}
+/**
+ * Returns true if the schema contains a valid maxContains property
+ * @specification Json Schema 2019-09
+ */
+export declare function IsMinContains(schema: XSchemaObject): schema is XMinContains;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/minContains.mjs

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/minItems.d.mts

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/minItems.mjs

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/minLength.d.mts

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/types/minLength.mjs

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