@warlock.js/seal 4.0.162 → 4.0.164

package/cjs/rules/string/pattern.d.ts

@@ -0,0 +1,8 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Pattern rule - validates against regex pattern
+ */
+export declare const patternRule: SchemaRule<{
+    pattern: RegExp;
+}>;
+//# sourceMappingURL=pattern.d.ts.map

package/cjs/rules/string/pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.d.ts","sourceRoot":"","sources":["../../../src/rules/string/pattern.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,UAAU,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAWvD,CAAC"}

package/cjs/rules/string/pattern.js

@@ -0,0 +1,14 @@
+'use strict';require('@mongez/reinforcements');var validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * Pattern rule - validates against regex pattern
+ */
+const patternRule = {
+    name: "pattern",
+    defaultErrorMessage: "The :input does not match the required pattern",
+    async validate(value, context) {
+        if (this.context.options.pattern.test(value)) {
+            return validationHelpers.VALID_RULE;
+        }
+        this.context.translationParams.pattern = this.context.options.pattern.toString();
+        return validationHelpers.invalidRule(this, context);
+    },
+};exports.patternRule=patternRule;//# sourceMappingURL=pattern.js.map

package/cjs/rules/string/pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.js","sources":["../../../src/rules/string/pattern.ts"],"sourcesContent":[null],"names":["VALID_RULE","invalidRule"],"mappings":"oHAGA;;AAEG;AACU,MAAA,WAAW,GAAoC;AAC1D,IAAA,IAAI,EAAE,SAAS;AACf,IAAA,mBAAmB,EAAE,gDAAgD;AACrE,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;AAC5C,YAAA,OAAOA,4BAAU,CAAC;AACnB,SAAA;AAED,QAAA,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;AACjF,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;"}

package/cjs/rules/string/string-comparison.d.ts

@@ -0,0 +1,26 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Starts with rule
+ */
+export declare const startsWithRule: SchemaRule<{
+    value: string;
+}>;
+/**
+ * Ends with rule
+ */
+export declare const endsWithRule: SchemaRule<{
+    value: string;
+}>;
+/**
+ * Contains rule
+ */
+export declare const containsRule: SchemaRule<{
+    value: string;
+}>;
+/**
+ * Not contains rule
+ */
+export declare const notContainsRule: SchemaRule<{
+    value: string;
+}>;
+//# sourceMappingURL=string-comparison.d.ts.map

package/cjs/rules/string/string-comparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-comparison.d.ts","sourceRoot":"","sources":["../../../src/rules/string/string-comparison.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAYxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAYtD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAYtD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,UAAU,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAYzD,CAAC"}

package/cjs/rules/string/string-comparison.js

@@ -0,0 +1,56 @@
+'use strict';require('@mongez/reinforcements');var validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * Starts with rule
+ */
+const startsWithRule = {
+    name: "startsWith",
+    defaultErrorMessage: "The :input must start with :value",
+    async validate(value, context) {
+        if (String(value).startsWith(this.context.options.value)) {
+            return validationHelpers.VALID_RULE;
+        }
+        this.context.translatableParams.value = this.context.options.value;
+        return validationHelpers.invalidRule(this, context);
+    },
+};
+/**
+ * Ends with rule
+ */
+const endsWithRule = {
+    name: "endsWith",
+    defaultErrorMessage: "The :input must end with :value",
+    async validate(value, context) {
+        if (String(value).endsWith(this.context.options.value)) {
+            return validationHelpers.VALID_RULE;
+        }
+        this.context.translatableParams.value = this.context.options.value;
+        return validationHelpers.invalidRule(this, context);
+    },
+};
+/**
+ * Contains rule
+ */
+const containsRule = {
+    name: "contains",
+    defaultErrorMessage: "The :input must contain :value",
+    async validate(value, context) {
+        if (String(value).includes(this.context.options.value)) {
+            return validationHelpers.VALID_RULE;
+        }
+        this.context.translatableParams.value = this.context.options.value;
+        return validationHelpers.invalidRule(this, context);
+    },
+};
+/**
+ * Not contains rule
+ */
+const notContainsRule = {
+    name: "notContains",
+    defaultErrorMessage: "The :input must not contain :value",
+    async validate(value, context) {
+        if (!String(value).includes(this.context.options.value)) {
+            return validationHelpers.VALID_RULE;
+        }
+        this.context.translatableParams.value = this.context.options.value;
+        return validationHelpers.invalidRule(this, context);
+    },
+};exports.containsRule=containsRule;exports.endsWithRule=endsWithRule;exports.notContainsRule=notContainsRule;exports.startsWithRule=startsWithRule;//# sourceMappingURL=string-comparison.js.map

package/cjs/rules/string/string-comparison.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-comparison.js","sources":["../../../src/rules/string/string-comparison.ts"],"sourcesContent":[null],"names":["VALID_RULE","invalidRule"],"mappings":"oHAGA;;AAEG;AACU,MAAA,cAAc,GAAkC;AAC3D,IAAA,IAAI,EAAE,YAAY;AAClB,IAAA,mBAAmB,EAAE,mCAAmC;AACxD,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AACxD,YAAA,OAAOA,4BAAU,CAAC;AACnB,SAAA;AAED,QAAA,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;AAEnE,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;EACD;AAEF;;AAEG;AACU,MAAA,YAAY,GAAkC;AACzD,IAAA,IAAI,EAAE,UAAU;AAChB,IAAA,mBAAmB,EAAE,iCAAiC;AACtD,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AACtD,YAAA,OAAOD,4BAAU,CAAC;AACnB,SAAA;AAED,QAAA,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;AAEnE,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;EACD;AAEF;;AAEG;AACU,MAAA,YAAY,GAAkC;AACzD,IAAA,IAAI,EAAE,UAAU;AAChB,IAAA,mBAAmB,EAAE,gCAAgC;AACrD,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AACtD,YAAA,OAAOD,4BAAU,CAAC;AACnB,SAAA;AAED,QAAA,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;AAEnE,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;EACD;AAEF;;AAEG;AACU,MAAA,eAAe,GAAkC;AAC5D,IAAA,IAAI,EAAE,aAAa;AACnB,IAAA,mBAAmB,EAAE,oCAAoC;AACzD,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AACvD,YAAA,OAAOD,4BAAU,CAAC;AACnB,SAAA;AAED,QAAA,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;AAEnE,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;"}

package/cjs/rules/string/strong-password-rule.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Strong Password rule - validates password strength
+ * Requirements:
+ * - At least 8 characters
+ * - At least 1 uppercase letter
+ * - At least 1 lowercase letter
+ * - At least 1 number
+ * - At least 1 special character
+ */
+export declare const strongPasswordRule: SchemaRule<{
+    minLength?: number;
+}>;
+//# sourceMappingURL=strong-password-rule.d.ts.map

package/cjs/rules/string/strong-password-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strong-password-rule.d.ts","sourceRoot":"","sources":["../../../src/rules/string/strong-password-rule.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,EAAE,UAAU,CAAC;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAmCjE,CAAC"}

package/cjs/rules/string/strong-password-rule.js

@@ -0,0 +1,38 @@
+'use strict';require('@mongez/reinforcements');var validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * Strong Password rule - validates password strength
+ * Requirements:
+ * - At least 8 characters
+ * - At least 1 uppercase letter
+ * - At least 1 lowercase letter
+ * - At least 1 number
+ * - At least 1 special character
+ */
+const strongPasswordRule = {
+    name: "strongPassword",
+    defaultErrorMessage: "The :input must be at least 8 characters and contain at least one uppercase letter, one lowercase letter, one number, and one special character",
+    async validate(value, context) {
+        const password = String(value);
+        const minLength = this.context.options.minLength ?? 8;
+        // Check minimum length
+        if (password.length < minLength) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        // Check for at least one uppercase letter
+        if (!/[A-Z]/.test(password)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        // Check for at least one lowercase letter
+        if (!/[a-z]/.test(password)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        // Check for at least one number
+        if (!/[0-9]/.test(password)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        // Check for at least one special character
+        if (!/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(password)) {
+            return validationHelpers.invalidRule(this, context);
+        }
+        return validationHelpers.VALID_RULE;
+    },
+};exports.strongPasswordRule=strongPasswordRule;//# sourceMappingURL=strong-password-rule.js.map

package/cjs/rules/string/strong-password-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strong-password-rule.js","sources":["../../../src/rules/string/strong-password-rule.ts"],"sourcesContent":[null],"names":["invalidRule","VALID_RULE"],"mappings":"oHAGA;;;;;;;;AAQG;AACU,MAAA,kBAAkB,GAAuC;AACpE,IAAA,IAAI,EAAE,gBAAgB;AACtB,IAAA,mBAAmB,EACjB,iJAAiJ;AACnJ,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC/B,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,IAAI,CAAC,CAAC;;AAGtD,QAAA,IAAI,QAAQ,CAAC,MAAM,GAAG,SAAS,EAAE;AAC/B,YAAA,OAAOA,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;;AAGD,QAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;AAC3B,YAAA,OAAOA,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;;AAGD,QAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;AAC3B,YAAA,OAAOA,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;;AAGD,QAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;AAC3B,YAAA,OAAOA,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;;AAGD,QAAA,IAAI,CAAC,qCAAqC,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;AACzD,YAAA,OAAOA,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;AAED,QAAA,OAAOC,4BAAU,CAAC;KACnB;"}

package/cjs/rules/string/url.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaRule } from "../../types";
+/**
+ * URL rule - validates URL format
+ */
+export declare const urlRule: SchemaRule;
+//# sourceMappingURL=url.d.ts.map

package/cjs/rules/string/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../src/rules/string/url.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,UAWrB,CAAC"}

package/cjs/rules/string/url.js

@@ -0,0 +1,16 @@
+'use strict';require('@mongez/reinforcements');var validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * URL rule - validates URL format
+ */
+const urlRule = {
+    name: "url",
+    defaultErrorMessage: "The :input must be a valid URL",
+    async validate(value, context) {
+        try {
+            new URL(value);
+            return validationHelpers.VALID_RULE;
+        }
+        catch {
+            return validationHelpers.invalidRule(this, context);
+        }
+    },
+};exports.urlRule=urlRule;//# sourceMappingURL=url.js.map

package/cjs/rules/string/url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.js","sources":["../../../src/rules/string/url.ts"],"sourcesContent":[null],"names":["VALID_RULE","invalidRule"],"mappings":"oHAGA;;AAEG;AACU,MAAA,OAAO,GAAe;AACjC,IAAA,IAAI,EAAE,KAAK;AACX,IAAA,mBAAmB,EAAE,gCAAgC;AACrD,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;QAChC,IAAI;AACF,YAAA,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC;AACf,YAAA,OAAOA,4BAAU,CAAC;AACnB,SAAA;QAAC,MAAM;AACN,YAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACnC,SAAA;KACF;"}

package/cjs/rules/string/without-whitespace.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaRule } from "../../types";
+/**
+ * Without whitespace rule - value must not contain whitespace
+ */
+export declare const withoutWhitespaceRule: SchemaRule;
+//# sourceMappingURL=without-whitespace.d.ts.map

package/cjs/rules/string/without-whitespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"without-whitespace.d.ts","sourceRoot":"","sources":["../../../src/rules/string/without-whitespace.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,UASnC,CAAC"}

package/cjs/rules/string/without-whitespace.js

@@ -0,0 +1,13 @@
+'use strict';require('@mongez/reinforcements');var validationHelpers=require('../../helpers/validation-helpers.js');/**
+ * Without whitespace rule - value must not contain whitespace
+ */
+const withoutWhitespaceRule = {
+    name: "withoutWhitespace",
+    defaultErrorMessage: "The :input must not contain whitespace",
+    async validate(value, context) {
+        if (!/\s/.test(value)) {
+            return validationHelpers.VALID_RULE;
+        }
+        return validationHelpers.invalidRule(this, context);
+    },
+};exports.withoutWhitespaceRule=withoutWhitespaceRule;//# sourceMappingURL=without-whitespace.js.map

package/cjs/rules/string/without-whitespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"without-whitespace.js","sources":["../../../src/rules/string/without-whitespace.ts"],"sourcesContent":[null],"names":["VALID_RULE","invalidRule"],"mappings":"oHAGA;;AAEG;AACU,MAAA,qBAAqB,GAAe;AAC/C,IAAA,IAAI,EAAE,mBAAmB;AACzB,IAAA,mBAAmB,EAAE,wCAAwC;AAC7D,IAAA,MAAM,QAAQ,CAAC,KAAU,EAAE,OAAO,EAAA;AAChC,QAAA,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;AACrB,YAAA,OAAOA,4BAAU,CAAC;AACnB,SAAA;AACD,QAAA,OAAOC,6BAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;KACnC;"}

package/cjs/standard-schema/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./map-result";
+export * from "./json-schema";
+//# sourceMappingURL=index.d.ts.map

package/cjs/standard-schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/standard-schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC"}

package/cjs/standard-schema/json-schema.d.ts

@@ -0,0 +1,61 @@
+import type { StandardJSONSchemaV1 } from "./types";
+/**
+ * Supported JSON Schema generation targets.
+ */
+export type JsonSchemaTarget = StandardJSONSchemaV1.Target;
+/**
+ * The result shape for a generated JSON Schema.
+ */
+export type JsonSchemaResult = Record<string, unknown>;
+/**
+ * Apply nullable to a JSON Schema object based on the target dialect.
+ *
+ * - draft-2020-12  : `type` becomes an array: `["string", "null"]`
+ * - openai-strict  : same as draft-2020-12 (type array form)
+ * - draft-07       : wraps in `oneOf: [{ ...schema }, { type: "null" }]`
+ * - openapi-3.0    : adds `nullable: true` alongside the existing type
+ *
+ * Mutates the schema in-place.
+ *
+ * @example
+ * ```ts
+ * const schema = { type: "string" };
+ * applyNullable(schema, "draft-2020-12");
+ * // → { type: ["string", "null"] }
+ * ```
+ */
+export declare function applyNullable(schema: JsonSchemaResult, target: JsonSchemaTarget): void;
+/**
+ * Wrap a field schema as nullable for OpenAI strict mode.
+ *
+ * OpenAI strict requires optional fields to be expressed as a nullable type
+ * rather than being omitted from the `required` array. This helper wraps a
+ * given schema into its nullable equivalent using the type-array form.
+ *
+ * Unlike `applyNullable()` (which mutates in-place), this returns a new
+ * schema object to avoid side effects when wrapping child schemas.
+ *
+ * @example
+ * ```ts
+ * wrapNullableStrict({ type: "string", minLength: 3 })
+ * // → { type: ["string", "null"], minLength: 3 }
+ *
+ * wrapNullableStrict({ type: "object", properties: {...} })
+ * // → { type: ["object", "null"], properties: {...} }
+ *
+ * wrapNullableStrict({ oneOf: [...] })
+ * // → { oneOf: [..., { type: "null" }] }
+ * ```
+ */
+export declare function wrapNullableStrict(schema: JsonSchemaResult): JsonSchemaResult;
+/**
+ * Find the first rule matching the given name in a rules array,
+ * and return its options bag.
+ */
+export declare function getRuleOptions(rules: Array<{
+    name: string;
+    context: {
+        options: Record<string, unknown>;
+    };
+}>, ruleName: string): Record<string, unknown> | undefined;
+//# sourceMappingURL=json-schema.d.ts.map

package/cjs/standard-schema/json-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../../src/standard-schema/json-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,CAAC,MAAM,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEvD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAoBtF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,CAqB7E;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAA;CAAE,CAAC,EAC7E,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAGrC"}

package/cjs/standard-schema/json-schema.js

@@ -0,0 +1,85 @@
+'use strict';/**
+ * Apply nullable to a JSON Schema object based on the target dialect.
+ *
+ * - draft-2020-12  : `type` becomes an array: `["string", "null"]`
+ * - openai-strict  : same as draft-2020-12 (type array form)
+ * - draft-07       : wraps in `oneOf: [{ ...schema }, { type: "null" }]`
+ * - openapi-3.0    : adds `nullable: true` alongside the existing type
+ *
+ * Mutates the schema in-place.
+ *
+ * @example
+ * ```ts
+ * const schema = { type: "string" };
+ * applyNullable(schema, "draft-2020-12");
+ * // → { type: ["string", "null"] }
+ * ```
+ */
+function applyNullable(schema, target) {
+    if (target === "openapi-3.0") {
+        schema.nullable = true;
+        return;
+    }
+    if (target === "draft-2020-12" || target === "openai-strict") {
+        const baseType = schema.type;
+        schema.type = Array.isArray(baseType)
+            ? [...baseType, "null"]
+            : [baseType, "null"];
+        return;
+    }
+    // draft-07: oneOf wrapping
+    const copy = { ...schema };
+    for (const key of Object.keys(schema)) {
+        delete schema[key];
+    }
+    schema.oneOf = [copy, { type: "null" }];
+}
+/**
+ * Wrap a field schema as nullable for OpenAI strict mode.
+ *
+ * OpenAI strict requires optional fields to be expressed as a nullable type
+ * rather than being omitted from the `required` array. This helper wraps a
+ * given schema into its nullable equivalent using the type-array form.
+ *
+ * Unlike `applyNullable()` (which mutates in-place), this returns a new
+ * schema object to avoid side effects when wrapping child schemas.
+ *
+ * @example
+ * ```ts
+ * wrapNullableStrict({ type: "string", minLength: 3 })
+ * // → { type: ["string", "null"], minLength: 3 }
+ *
+ * wrapNullableStrict({ type: "object", properties: {...} })
+ * // → { type: ["object", "null"], properties: {...} }
+ *
+ * wrapNullableStrict({ oneOf: [...] })
+ * // → { oneOf: [..., { type: "null" }] }
+ * ```
+ */
+function wrapNullableStrict(schema) {
+    // If the schema uses oneOf/anyOf (e.g. union), append null to the list
+    if (schema.oneOf) {
+        return { ...schema, oneOf: [...schema.oneOf, { type: "null" }] };
+    }
+    if (schema.anyOf) {
+        return { ...schema, anyOf: [...schema.anyOf, { type: "null" }] };
+    }
+    // If there's no type at all (permissive `{}`), stay permissive
+    if (schema.type === undefined) {
+        return schema;
+    }
+    // Standard case: wrap type into array with null
+    const baseType = schema.type;
+    return {
+        ...schema,
+        type: Array.isArray(baseType) ? [...baseType, "null"] : [baseType, "null"],
+    };
+}
+/**
+ * Find the first rule matching the given name in a rules array,
+ * and return its options bag.
+ */
+function getRuleOptions(rules, ruleName) {
+    const rule = rules.find(r => r.name === ruleName);
+    return rule?.context?.options;
+}exports.applyNullable=applyNullable;exports.getRuleOptions=getRuleOptions;exports.wrapNullableStrict=wrapNullableStrict;//# sourceMappingURL=json-schema.js.map

package/cjs/standard-schema/json-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.js","sources":["../../src/standard-schema/json-schema.ts"],"sourcesContent":[null],"names":[],"mappings":"aAYA;;;;;;;;;;;;;;;;AAgBG;AACa,SAAA,aAAa,CAAC,MAAwB,EAAE,MAAwB,EAAA;IAC9E,IAAI,MAAM,KAAK,aAAa,EAAE;AAC5B,QAAA,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC;QACvB,OAAO;AACR,KAAA;AAED,IAAA,IAAI,MAAM,KAAK,eAAe,IAAI,MAAM,KAAK,eAAe,EAAE;AAC5D,QAAA,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAqC,CAAC;QAC9D,MAAM,CAAC,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;AACnC,cAAE,CAAC,GAAG,QAAQ,EAAE,MAAM,CAAC;AACvB,cAAE,CAAC,QAAkB,EAAE,MAAM,CAAC,CAAC;QACjC,OAAO;AACR,KAAA;;AAGD,IAAA,MAAM,IAAI,GAAG,EAAE,GAAG,MAAM,EAAE,CAAC;IAC3B,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;AACrC,QAAA,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;AACpB,KAAA;AACD,IAAA,MAAM,CAAC,KAAK,GAAG,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG,SAAU,kBAAkB,CAAC,MAAwB,EAAA;;IAEzD,IAAI,MAAM,CAAC,KAAK,EAAE;AAChB,QAAA,OAAO,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,CAAC,GAAI,MAAM,CAAC,KAAmB,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;AACjF,KAAA;IAED,IAAI,MAAM,CAAC,KAAK,EAAE;AAChB,QAAA,OAAO,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,CAAC,GAAI,MAAM,CAAC,KAAmB,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;AACjF,KAAA;;AAGD,IAAA,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE;AAC7B,QAAA,OAAO,MAAM,CAAC;AACf,KAAA;;AAGD,IAAA,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAyB,CAAC;IAClD,OAAO;AACL,QAAA,GAAG,MAAM;QACT,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC;KAC3E,CAAC;AACJ,CAAC;AAED;;;AAGG;AACa,SAAA,cAAc,CAC5B,KAA6E,EAC7E,QAAgB,EAAA;AAEhB,IAAA,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;AAClD,IAAA,OAAO,IAAI,EAAE,OAAO,EAAE,OAA8C,CAAC;AACvE"}

package/cjs/standard-schema/map-result.d.ts

@@ -0,0 +1,18 @@
+import type { ValidationResult } from "../types";
+import type { StandardSchemaV1 } from "./types";
+/**
+ * Maps a Seal ValidationResult to a Standard Schema result shape.
+ *
+ * Seal error paths are dot-notation strings (e.g. "address.city").
+ * Standard Schema expects an array of path segments: [{ key: "address" }, { key: "city" }].
+ *
+ * @example
+ * ```ts
+ * const result = await validator.validate(value, context);
+ * return mapToStandardResult(result);
+ * // Success → { value: <data> }
+ * // Failure → { issues: [{ message: "...", path: [{ key: "..." }] }] }
+ * ```
+ */
+export declare function mapToStandardResult(result: ValidationResult): StandardSchemaV1.Result<unknown>;
+//# sourceMappingURL=map-result.d.ts.map

package/cjs/standard-schema/map-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-result.d.ts","sourceRoot":"","sources":["../../src/standard-schema/map-result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,gBAAgB,GACvB,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC,CAalC"}

package/cjs/standard-schema/map-result.js

@@ -0,0 +1,27 @@
+'use strict';/**
+ * Maps a Seal ValidationResult to a Standard Schema result shape.
+ *
+ * Seal error paths are dot-notation strings (e.g. "address.city").
+ * Standard Schema expects an array of path segments: [{ key: "address" }, { key: "city" }].
+ *
+ * @example
+ * ```ts
+ * const result = await validator.validate(value, context);
+ * return mapToStandardResult(result);
+ * // Success → { value: <data> }
+ * // Failure → { issues: [{ message: "...", path: [{ key: "..." }] }] }
+ * ```
+ */
+function mapToStandardResult(result) {
+    if (result.isValid) {
+        return { value: result.data };
+    }
+    return {
+        issues: result.errors.map(e => ({
+            message: e.error,
+            path: e.input
+                ? e.input.split(".").map(key => ({ key }))
+                : undefined,
+        })),
+    };
+}exports.mapToStandardResult=mapToStandardResult;//# sourceMappingURL=map-result.js.map

package/cjs/standard-schema/map-result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-result.js","sources":["../../src/standard-schema/map-result.ts"],"sourcesContent":[null],"names":[],"mappings":"aAGA;;;;;;;;;;;;;AAaG;AACG,SAAU,mBAAmB,CACjC,MAAwB,EAAA;IAExB,IAAI,MAAM,CAAC,OAAO,EAAE;AAClB,QAAA,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC;AAC/B,KAAA;IAED,OAAO;QACL,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK;YAC9B,OAAO,EAAE,CAAC,CAAC,KAAK;YAChB,IAAI,EAAE,CAAC,CAAC,KAAK;kBACT,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;AAC1C,kBAAE,SAAS;AACd,SAAA,CAAC,CAAC;KACJ,CAAC;AACJ"}

package/cjs/standard-schema/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Standard Schema Spec Types
+ *
+ * Copied from @standard-schema/spec to avoid a runtime dependency.
+ * Source: https://standardschema.dev
+ *
+ * Implements:
+ *  - StandardSchemaV1  — for validation interop (OpenAI, LangGraph, TanStack Form, Conform, etc.)
+ *  - StandardJSONSchemaV1 — for JSON Schema generation (OpenAPI, draft-07, draft-2020-12)
+ */
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown, options?: Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    }
+    /** Success result. */
+    interface SuccessResult<Output> {
+        readonly value: Output;
+        readonly issues?: undefined;
+    }
+    /** Options passed to validate. */
+    interface Options {
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** Failure result. */
+    interface FailureResult {
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** Issue in a failed result. */
+    interface Issue {
+        readonly message: string;
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** A single segment in an issue path. */
+    interface PathSegment {
+        readonly key: PropertyKey;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        readonly input: Input;
+        readonly output: Output;
+    }
+    /** Infer the input type of a Standard Schema. */
+    type InferInput<S extends StandardSchemaV1> = NonNullable<S["~standard"]["types"]>["input"];
+    /** Infer the output type of a Standard Schema. */
+    type InferOutput<S extends StandardSchemaV1> = NonNullable<S["~standard"]["types"]>["output"];
+}
+/** The Standard JSON Schema interface. */
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardJSONSchemaV1 {
+    interface Props<Input = unknown, Output = Input> extends Omit<StandardSchemaV1.Props<Input, Output>, never> {
+        readonly jsonSchema: Converter;
+    }
+    /** Methods for generating JSON Schema. */
+    interface Converter {
+        /** Converts the input type to JSON Schema. */
+        readonly input: (options: Options) => Record<string, unknown>;
+        /** Converts the output type to JSON Schema. */
+        readonly output: (options: Options) => Record<string, unknown>;
+    }
+    /**
+     * Supported JSON Schema targets.
+     * Libraries should throw if a target is not supported.
+     *
+     * - `draft-2020-12`  — JSON Schema 2020-12 (default, recommended)
+     * - `draft-07`       — JSON Schema draft-07 (Swagger 2.0, older tooling)
+     * - `openapi-3.0`    — OpenAPI 3.0 extensions (nullable: true)
+     * - `openai-strict`  — OpenAI Structured Outputs strict mode.
+     *                      All fields listed in required; optional fields
+     *                      expressed as `{ type: ["T", "null"] }` instead
+     *                      of being omitted from required.
+     */
+    type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | "openai-strict" | ({} & string);
+    interface Options {
+        readonly target: Target;
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/cjs/standard-schema/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/standard-schema/types.ts"],"names":[],"mappings":"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"}

package/cjs/types/conditional-types.d.ts

@@ -0,0 +1,15 @@
+import type { BaseValidator } from "../validators/base-validator";
+/**
+ * Options for conditional when rule
+ */
+export type WhenRuleOptions = {
+    /** Field name to check */
+    field: string;
+    /** Map of field values to validators */
+    is: Record<string, BaseValidator>;
+    /** Fallback validator if no condition matches */
+    otherwise?: BaseValidator;
+    /** Whether to check in global context or sibling context (default: "global") */
+    scope?: "global" | "sibling";
+};
+//# sourceMappingURL=conditional-types.d.ts.map

package/cjs/types/conditional-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-types.d.ts","sourceRoot":"","sources":["../../src/types/conditional-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,0BAA0B;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAClC,iDAAiD;IACjD,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,gFAAgF;IAChF,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B,CAAC"}

package/cjs/types/context-types.d.ts

@@ -0,0 +1,47 @@
+import type { SchemaRule } from "./rule-types";
+import type { Schema } from "./schema-types";
+export type RuleTranslation = {
+    rule: SchemaRule;
+    context: SchemaContext;
+    attributes: {
+        input: string;
+        path: string;
+        key: string;
+        value: any;
+        [key: string]: any;
+    };
+};
+export type AttributeTranslation = {
+    attribute: string;
+    context: SchemaContext;
+    rule: SchemaRule;
+};
+/**
+ * Validation context passed to validators and rules
+ */
+export type SchemaContext = {
+    /** All input values */
+    allValues: any;
+    /** Parent object if nested */
+    parent: any;
+    /** Current value being validated */
+    value: any;
+    /** Current key */
+    key: string;
+    /** Full path to the current value */
+    path: string;
+    /** Schema definition if object validator */
+    schema?: Schema;
+    /** Additional context */
+    context?: Record<string, any>;
+    /** Root context */
+    rootContext?: Record<string, any>;
+    /** Translation function for error messages */
+    translateRule: (ruleTranslation: RuleTranslation) => string;
+    translateAttribute: (attributeTranslation: AttributeTranslation) => string;
+    /** Validation configurations */
+    configurations?: {
+        firstErrorOnly?: boolean;
+    };
+};
+//# sourceMappingURL=context-types.d.ts.map