@stndrds/schema 0.1.0-alpha.66 → 1.0.0-alpha.100

package/dist/chunk-4DMDOSFN.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunk5SQEKHPW_js = require('./chunk-5SQEKHPW.js');
+var zod = require('zod');
+
+function createCheckboxValidator(_attr, _messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  return zod.z.boolean();
+}
+
+exports.createCheckboxValidator = createCheckboxValidator;

package/dist/chunk-4IVCBFJA.mjs

@@ -0,0 +1,12 @@
+import { DEFAULT_VALIDATION_MESSAGES } from './chunk-JEDANRCG.mjs';
+import { z } from 'zod';
+
+function createRatingValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  let schema = z.number().min(0);
+  if (attr.max !== void 0) {
+    schema = schema.max(attr.max, messages.maxValue(attr, attr.max));
+  }
+  return schema;
+}
+
+export { createRatingValidator };

package/dist/chunk-5CBTJS7J.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var chunk5SQEKHPW_js = require('./chunk-5SQEKHPW.js');
+var zod = require('zod');
+
+function createLocationValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  return zod.z.object(
+    {
+      address: zod.z.string().optional(),
+      address2: zod.z.string().optional(),
+      city: zod.z.string().optional(),
+      state: zod.z.string().optional(),
+      postalCode: zod.z.string().optional(),
+      country: zod.z.string().length(3).optional(),
+      latitude: zod.z.number().optional(),
+      longitude: zod.z.number().optional()
+    },
+    { message: messages.invalidLocation(attr) }
+  );
+}
+
+exports.createLocationValidator = createLocationValidator;

package/dist/chunk-5SQEKHPW.js

@@ -0,0 +1,78 @@
+'use strict';
+
+// src/validation/core/messages.ts
+var DEFAULT_VALIDATION_MESSAGES = {
+  required: (attr) => `${attr.label} is required`,
+  invalidType: (attr, expected) => `${attr.label} must be a ${expected}`,
+  minLength: (attr, min) => `${attr.label} must be at least ${min} characters`,
+  maxLength: (attr, max) => `${attr.label} must be at most ${max} characters`,
+  invalidPattern: (attr) => `${attr.label} format is invalid`,
+  minValue: (attr, min) => `${attr.label} must be at least ${min}`,
+  maxValue: (attr, max) => `${attr.label} must be at most ${max}`,
+  mustBeInteger: (attr) => `${attr.label} must be an integer`,
+  invalidDate: (attr) => `${attr.label} must be a valid date`,
+  invalidOption: (attr, options) => `${attr.label} must be one of: ${options.join(", ")}`,
+  invalidId: (attr) => `${attr.label} must be a valid ID`,
+  minItems: (attr, min) => `${attr.label} must have at least ${min} item${min > 1 ? "s" : ""}`,
+  maxItems: (attr, max) => `${attr.label} must have at most ${max} item${max > 1 ? "s" : ""}`,
+  invalidRichtext: (attr) => `${attr.label} must be valid rich text content`,
+  invalidPhone: (attr) => `${attr.label} must be a valid phone number`,
+  invalidCurrency: (attr) => `${attr.label} must be a valid currency value`,
+  invalidLocation: (attr) => `${attr.label} must be a valid location`
+};
+
+// src/lib/lru-cache.ts
+var LRUCache = class {
+  constructor(capacity) {
+    if (capacity <= 0) {
+      throw new Error("LRU cache capacity must be greater than 0");
+    }
+    this.capacity = capacity;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== void 0) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.capacity) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+
+// src/validation/core/regex-cache.ts
+function createRegexCache(capacity = 100) {
+  return new LRUCache(capacity);
+}
+function getCachedRegex(cache, pattern) {
+  let cached = cache.get(pattern);
+  if (!cached) {
+    cached = new RegExp(pattern);
+    cache.set(pattern, cached);
+  }
+  return cached;
+}
+
+exports.DEFAULT_VALIDATION_MESSAGES = DEFAULT_VALIDATION_MESSAGES;
+exports.createRegexCache = createRegexCache;
+exports.getCachedRegex = getCachedRegex;

package/dist/chunk-6IFD5732.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunk5SQEKHPW_js = require('./chunk-5SQEKHPW.js');
+var zod = require('zod');
+
+function createRollupValidator(_attr, _messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  return zod.z.unknown();
+}
+
+exports.createRollupValidator = createRollupValidator;

package/dist/chunk-6MXQAQBB.mjs

@@ -0,0 +1,18 @@
+import { DEFAULT_VALIDATION_MESSAGES } from './chunk-JEDANRCG.mjs';
+import { z } from 'zod';
+
+function createNumberValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  let schema = z.number();
+  if (attr.min !== void 0) {
+    schema = schema.min(attr.min, messages.minValue(attr, attr.min));
+  }
+  if (attr.max !== void 0) {
+    schema = schema.max(attr.max, messages.maxValue(attr, attr.max));
+  }
+  if (attr.unit === "integer") {
+    schema = schema.int(messages.mustBeInteger(attr));
+  }
+  return schema;
+}
+
+export { createNumberValidator };

package/dist/chunk-7FSIBNRH.mjs

@@ -0,0 +1,25 @@
+import { createRegexCache, DEFAULT_VALIDATION_MESSAGES, getCachedRegex } from './chunk-JEDANRCG.mjs';
+import { z } from 'zod';
+
+var textRegexCache = createRegexCache();
+function createTextValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  let schema = z.string();
+  if (attr.minLength !== void 0) {
+    schema = schema.min(attr.minLength, messages.minLength(attr, attr.minLength));
+  }
+  if (attr.maxLength !== void 0) {
+    schema = schema.max(attr.maxLength, messages.maxLength(attr, attr.maxLength));
+  }
+  if (attr.pattern) {
+    schema = schema.regex(
+      getCachedRegex(textRegexCache, attr.pattern),
+      messages.invalidPattern(attr)
+    );
+  }
+  return schema;
+}
+function createTextAreaValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.string();
+}
+
+export { createTextAreaValidator, createTextValidator };

package/dist/chunk-ALV6GETG.mjs

@@ -0,0 +1,10 @@
+import { DEFAULT_VALIDATION_MESSAGES } from './chunk-JEDANRCG.mjs';
+import { z } from 'zod';
+
+function createRichtextValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.string({
+    message: messages.invalidRichtext(attr)
+  });
+}
+
+export { createRichtextValidator };

package/dist/chunk-ANP6HGMJ.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var chunk5SQEKHPW_js = require('./chunk-5SQEKHPW.js');
+var zod = require('zod');
+
+function extractRelationId(item) {
+  if (typeof item === "object" && item !== null && "id" in item) {
+    return item.id;
+  }
+  return item;
+}
+function createSingleRelationValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  const uuidSchema = zod.z.uuid({
+    message: messages.invalidId(attr)
+  });
+  const nullableUuidSchema = zod.z.union([uuidSchema, zod.z.null()]);
+  return zod.z.union([
+    nullableUuidSchema,
+    zod.z.object({
+      id: uuidSchema,
+      props: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+    }).passthrough()
+    // Allow additional properties (bilateral relations may have extra metadata)
+  ]);
+}
+function createMultiRelationValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  const uuidSchema = zod.z.uuid({
+    message: messages.invalidId(attr)
+  });
+  const itemSchema = zod.z.union([
+    uuidSchema,
+    zod.z.object({
+      id: uuidSchema,
+      props: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+    }).passthrough()
+    // Allow additional properties
+  ]);
+  let arraySchema = zod.z.array(itemSchema);
+  if (attr.minItems !== void 0) {
+    arraySchema = arraySchema.min(attr.minItems, messages.minItems(attr, attr.minItems));
+  }
+  if (attr.maxItems !== void 0) {
+    arraySchema = arraySchema.max(attr.maxItems, messages.maxItems(attr, attr.maxItems));
+  }
+  return arraySchema.refine(
+    (items) => {
+      return items.every((item) => {
+        const id = extractRelationId(item);
+        return typeof id === "string" && uuidSchema.safeParse(id).success;
+      });
+    },
+    { message: messages.invalidId(attr) }
+  );
+}
+function createRelationValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  if (attr.cardinality === "many") {
+    return createMultiRelationValidator(attr, messages);
+  }
+  return createSingleRelationValidator(attr, messages);
+}
+
+exports.createMultiRelationValidator = createMultiRelationValidator;
+exports.createRelationValidator = createRelationValidator;
+exports.createSingleRelationValidator = createSingleRelationValidator;

package/dist/chunk-ATA4XHB4.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var chunk5SQEKHPW_js = require('./chunk-5SQEKHPW.js');
+var zod = require('zod');
+
+function createNumberValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  let schema = zod.z.number();
+  if (attr.min !== void 0) {
+    schema = schema.min(attr.min, messages.minValue(attr, attr.min));
+  }
+  if (attr.max !== void 0) {
+    schema = schema.max(attr.max, messages.maxValue(attr, attr.max));
+  }
+  if (attr.unit === "integer") {
+    schema = schema.int(messages.mustBeInteger(attr));
+  }
+  return schema;
+}
+
+exports.createNumberValidator = createNumberValidator;

package/dist/chunk-BEN6TE7Y.js

@@ -0,0 +1,11 @@
+'use strict';
+
+// src/validation/core/errors.ts
+function formatZodErrors(error) {
+  return error.issues.map((err) => ({
+    path: err.path.map(String),
+    message: err.message
+  }));
+}
+
+exports.formatZodErrors = formatZodErrors;

package/dist/chunk-BZTLI773.mjs

@@ -0,0 +1,8 @@
+import { DEFAULT_VALIDATION_MESSAGES } from './chunk-JEDANRCG.mjs';
+import { z } from 'zod';
+
+function createDateValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.coerce.date({ message: messages.invalidDate(attr) });
+}
+
+export { createDateValidator };

package/dist/chunk-C7KW4NAD.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var chunk5SQEKHPW_js = require('./chunk-5SQEKHPW.js');
+var zod = require('zod');
+
+function createFileValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  const uuidSchema = zod.z.uuid({
+    message: messages.invalidId(attr)
+  });
+  if (attr.multiple) {
+    let arraySchema = zod.z.array(uuidSchema);
+    if (attr.maxFiles) {
+      arraySchema = arraySchema.max(attr.maxFiles, messages.maxItems(attr, attr.maxFiles));
+    }
+    return arraySchema;
+  }
+  return uuidSchema;
+}
+
+exports.createFileValidator = createFileValidator;

package/dist/chunk-CE25ADK5.js

@@ -0,0 +1,212 @@
+'use strict';
+
+var chunk4DMDOSFN_js = require('./chunk-4DMDOSFN.js');
+var chunkFKETRWAF_js = require('./chunk-FKETRWAF.js');
+var chunkATA4XHB4_js = require('./chunk-ATA4XHB4.js');
+var chunkSTKN6A5M_js = require('./chunk-STKN6A5M.js');
+var chunkZWMMEQI7_js = require('./chunk-ZWMMEQI7.js');
+var chunkANP6HGMJ_js = require('./chunk-ANP6HGMJ.js');
+var chunkHJNLL34O_js = require('./chunk-HJNLL34O.js');
+var chunkOO2LJ6GP_js = require('./chunk-OO2LJ6GP.js');
+var chunkKC2FFNL4_js = require('./chunk-KC2FFNL4.js');
+var chunkUPEQEX2D_js = require('./chunk-UPEQEX2D.js');
+var chunk6IFD5732_js = require('./chunk-6IFD5732.js');
+var chunkQPDXDX7A_js = require('./chunk-QPDXDX7A.js');
+var chunkC7KW4NAD_js = require('./chunk-C7KW4NAD.js');
+var chunk5CBTJS7J_js = require('./chunk-5CBTJS7J.js');
+var chunkH3VBSMVW_js = require('./chunk-H3VBSMVW.js');
+var chunk5SQEKHPW_js = require('./chunk-5SQEKHPW.js');
+var chunkBEN6TE7Y_js = require('./chunk-BEN6TE7Y.js');
+var zod = require('zod');
+
+function isEmptyValue(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string" && value.trim() === "") return true;
+  if (value instanceof Date) return false;
+  if (typeof value === "object" && !Array.isArray(value)) {
+    return Object.values(value).every(
+      (v) => v === null || v === void 0 || typeof v === "string" && v.trim() === ""
+    );
+  }
+  return false;
+}
+function withEmptyToNull(validator) {
+  return zod.z.preprocess((val) => isEmptyValue(val) ? null : val, validator.nullish());
+}
+
+// src/validation/object/attribute-factory.ts
+function createAttributeValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  switch (attr.type) {
+    case "text":
+      return chunkZWMMEQI7_js.createTextValidator(attr, messages);
+    case "textarea":
+      return chunkZWMMEQI7_js.createTextAreaValidator(attr, messages);
+    case "richtext":
+      return chunkHJNLL34O_js.createRichtextValidator(attr, messages);
+    case "number":
+      return chunkATA4XHB4_js.createNumberValidator(attr, messages);
+    case "checkbox":
+      return chunk4DMDOSFN_js.createCheckboxValidator(attr, messages);
+    case "date":
+      return chunkFKETRWAF_js.createDateValidator(attr, messages);
+    case "phone":
+      return chunkH3VBSMVW_js.createPhoneValidator(attr, messages);
+    case "currency":
+      return chunkQPDXDX7A_js.createCurrencyValidator(attr, messages);
+    case "status":
+      return chunkOO2LJ6GP_js.createStatusValidator(attr, messages);
+    case "location":
+      return chunk5CBTJS7J_js.createLocationValidator(attr, messages);
+    case "select":
+      return chunkOO2LJ6GP_js.createSelectValidator(attr, messages);
+    case "multiselect":
+      return chunkOO2LJ6GP_js.createMultiselectValidator(attr, messages);
+    case "file":
+      return chunkC7KW4NAD_js.createFileValidator(attr, messages);
+    case "user":
+      return chunkKC2FFNL4_js.createUserValidator(attr, messages);
+    case "relation":
+      return chunkANP6HGMJ_js.createRelationValidator(attr, messages);
+    case "rating":
+      return chunkSTKN6A5M_js.createRatingValidator(attr, messages);
+    case "formula":
+      return chunkUPEQEX2D_js.createFormulaValidator(attr, messages);
+    case "rollup":
+      return chunk6IFD5732_js.createRollupValidator(attr, messages);
+    default:
+      return zod.z.unknown();
+  }
+}
+function createFormAttributeValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  const validator = createAttributeValidator(attr, messages);
+  if (!attr.required) {
+    return withEmptyToNull(validator);
+  }
+  return validator;
+}
+function createObjectValidator(objectDef) {
+  const shape = {};
+  for (const attr of objectDef.attributes) {
+    const validator = createAttributeValidator(attr);
+    shape[attr.name] = attr.required ? validator : withEmptyToNull(validator);
+  }
+  return zod.z.object(shape).passthrough();
+}
+function createDraftValidator(objectDef) {
+  const shape = {};
+  for (const attr of objectDef.attributes) {
+    const validator = createAttributeValidator(attr);
+    shape[attr.name] = withEmptyToNull(validator);
+  }
+  return zod.z.object(shape).passthrough();
+}
+
+// src/validation/object/helpers.ts
+function validateAttribute(attr, value) {
+  const validator = createAttributeValidator(attr);
+  if (!attr.required && (value === void 0 || value === null)) {
+    return { success: true, data: { [attr.name]: value } };
+  }
+  const result = validator.safeParse(value);
+  if (result.success) {
+    return {
+      success: true,
+      data: { [attr.name]: result.data }
+    };
+  }
+  return {
+    success: false,
+    errors: chunkBEN6TE7Y_js.formatZodErrors(result.error).map((err) => ({
+      path: [attr.name, ...err.path],
+      message: err.message
+    }))
+  };
+}
+function validateObject(objectDef, data) {
+  const validator = createObjectValidator(objectDef);
+  const result = validator.safeParse(data);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data
+    };
+  }
+  return {
+    success: false,
+    errors: chunkBEN6TE7Y_js.formatZodErrors(result.error)
+  };
+}
+function validateObjectOrThrow(objectDef, data) {
+  const result = validateObject(objectDef, data);
+  if (!result.success) {
+    const errorMessages = result.errors?.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n") || "Unknown validation error";
+    throw new Error(`Validation failed for ${objectDef.label}:
+${errorMessages}`);
+  }
+  return result.data;
+}
+function validateDraft(objectDef, data) {
+  const validator = createDraftValidator(objectDef);
+  const result = validator.safeParse(data);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data
+    };
+  }
+  return {
+    success: false,
+    errors: chunkBEN6TE7Y_js.formatZodErrors(result.error)
+  };
+}
+function validateDraftOrThrow(objectDef, data) {
+  const result = validateDraft(objectDef, data);
+  if (!result.success) {
+    const errorMessages = result.errors?.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n") || "Unknown validation error";
+    throw new Error(`Draft validation failed for ${objectDef.label}:
+${errorMessages}`);
+  }
+  return result.data;
+}
+function isValuePresent(value) {
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return false;
+  }
+  return true;
+}
+function getMissingRequiredAttributes(objectDef, data) {
+  const missing = [];
+  for (const attr of objectDef.attributes) {
+    if (attr.required && !isValuePresent(data[attr.name])) {
+      missing.push(attr);
+    }
+  }
+  return missing;
+}
+function isRecordComplete(objectDef, data) {
+  const missing = getMissingRequiredAttributes(objectDef, data);
+  if (missing.length > 0) {
+    return false;
+  }
+  const validation = validateObject(objectDef, data);
+  return validation.success;
+}
+function computeRecordStatus(objectDef, data) {
+  return isRecordComplete(objectDef, data) ? "complete" : "draft";
+}
+
+exports.computeRecordStatus = computeRecordStatus;
+exports.createAttributeValidator = createAttributeValidator;
+exports.createDraftValidator = createDraftValidator;
+exports.createFormAttributeValidator = createFormAttributeValidator;
+exports.createObjectValidator = createObjectValidator;
+exports.getMissingRequiredAttributes = getMissingRequiredAttributes;
+exports.isRecordComplete = isRecordComplete;
+exports.validateAttribute = validateAttribute;
+exports.validateDraft = validateDraft;
+exports.validateDraftOrThrow = validateDraftOrThrow;
+exports.validateObject = validateObject;
+exports.validateObjectOrThrow = validateObjectOrThrow;

package/dist/chunk-E6XO2STS.js

@@ -0,0 +1,61 @@
+'use strict';
+
+// src/utils.ts
+function asTenantId(id) {
+  return id;
+}
+function asUserId(id) {
+  return id;
+}
+function generateId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function generatePrefixedId(prefix) {
+  return `${prefix}_${generateId()}`;
+}
+function slugify(input) {
+  return input.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase().replace(/[^a-z0-9\s_-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-");
+}
+function generateTemplateName(label) {
+  const slug = slugify(label) || "template";
+  const suffix = generateId().slice(0, 8);
+  return `${slug}-${suffix}`;
+}
+function indexBy(items, keyFn) {
+  return new Map(items.map((item) => [keyFn(item), item]));
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) return false;
+    if (a.length !== b.length) return false;
+    return a.every((item, index) => deepEqual(item, b[index]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every((key) => key in bObj && deepEqual(aObj[key], bObj[key]));
+  }
+  return false;
+}
+
+exports.asTenantId = asTenantId;
+exports.asUserId = asUserId;
+exports.deepEqual = deepEqual;
+exports.generateId = generateId;
+exports.generatePrefixedId = generatePrefixedId;
+exports.generateTemplateName = generateTemplateName;
+exports.indexBy = indexBy;
+exports.slugify = slugify;

package/dist/chunk-EKG35CSO.mjs

@@ -0,0 +1 @@
+

package/dist/chunk-ERG77ADK.mjs

@@ -0,0 +1,18 @@
+import { DEFAULT_VALIDATION_MESSAGES } from './chunk-JEDANRCG.mjs';
+import { z } from 'zod';
+
+function createFileValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  const uuidSchema = z.uuid({
+    message: messages.invalidId(attr)
+  });
+  if (attr.multiple) {
+    let arraySchema = z.array(uuidSchema);
+    if (attr.maxFiles) {
+      arraySchema = arraySchema.max(attr.maxFiles, messages.maxItems(attr, attr.maxFiles));
+    }
+    return arraySchema;
+  }
+  return uuidSchema;
+}
+
+export { createFileValidator };

package/dist/chunk-FKETRWAF.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunk5SQEKHPW_js = require('./chunk-5SQEKHPW.js');
+var zod = require('zod');
+
+function createDateValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  return zod.z.coerce.date({ message: messages.invalidDate(attr) });
+}
+
+exports.createDateValidator = createDateValidator;

package/dist/chunk-FKPYFM6G.mjs

@@ -0,0 +1,14 @@
+import { DEFAULT_VALIDATION_MESSAGES } from './chunk-JEDANRCG.mjs';
+import { z } from 'zod';
+
+function createCurrencyValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.object(
+    {
+      code: z.string().length(3),
+      value: z.number().min(0)
+    },
+    { message: messages.invalidCurrency(attr) }
+  );
+}
+
+export { createCurrencyValidator };