@stndrds/schema 1.0.0-alpha.95 → 1.0.0-alpha.97

package/dist/chunk-2TEWGEUI.js

@@ -0,0 +1,212 @@
+'use strict';
+
+var chunkXK6XC3V4_js = require('./chunk-XK6XC3V4.js');
+var chunkVD3P2A6Q_js = require('./chunk-VD3P2A6Q.js');
+var chunkXZ5B5MTG_js = require('./chunk-XZ5B5MTG.js');
+var chunkN47XKY4R_js = require('./chunk-N47XKY4R.js');
+var chunkLHXE7LLD_js = require('./chunk-LHXE7LLD.js');
+var chunk6HHSX6LP_js = require('./chunk-6HHSX6LP.js');
+var chunkS5VJ2FZE_js = require('./chunk-S5VJ2FZE.js');
+var chunkKC4F3HB7_js = require('./chunk-KC4F3HB7.js');
+var chunkCKZHFJQT_js = require('./chunk-CKZHFJQT.js');
+var chunkJ4ORNCAH_js = require('./chunk-J4ORNCAH.js');
+var chunkYKHC2AW6_js = require('./chunk-YKHC2AW6.js');
+var chunkQY65ZSBL_js = require('./chunk-QY65ZSBL.js');
+var chunkZ2T7ONKU_js = require('./chunk-Z2T7ONKU.js');
+var chunkBH3RPSC5_js = require('./chunk-BH3RPSC5.js');
+var chunkAHPXNPJC_js = require('./chunk-AHPXNPJC.js');
+var chunkVCPYYLCS_js = require('./chunk-VCPYYLCS.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 = chunkVCPYYLCS_js.DEFAULT_VALIDATION_MESSAGES) {
+  switch (attr.type) {
+    case "text":
+      return chunkLHXE7LLD_js.createTextValidator(attr, messages);
+    case "textarea":
+      return chunkLHXE7LLD_js.createTextAreaValidator(attr, messages);
+    case "richtext":
+      return chunkS5VJ2FZE_js.createRichtextValidator(attr, messages);
+    case "number":
+      return chunkXZ5B5MTG_js.createNumberValidator(attr, messages);
+    case "checkbox":
+      return chunkXK6XC3V4_js.createCheckboxValidator(attr, messages);
+    case "date":
+      return chunkVD3P2A6Q_js.createDateValidator(attr, messages);
+    case "phone":
+      return chunkAHPXNPJC_js.createPhoneValidator(attr, messages);
+    case "currency":
+      return chunkQY65ZSBL_js.createCurrencyValidator(attr, messages);
+    case "status":
+      return chunkKC4F3HB7_js.createStatusValidator(attr, messages);
+    case "location":
+      return chunkBH3RPSC5_js.createLocationValidator(attr, messages);
+    case "select":
+      return chunkKC4F3HB7_js.createSelectValidator(attr, messages);
+    case "multiselect":
+      return chunkKC4F3HB7_js.createMultiselectValidator(attr, messages);
+    case "file":
+      return chunkZ2T7ONKU_js.createFileValidator(attr, messages);
+    case "user":
+      return chunkCKZHFJQT_js.createUserValidator(attr, messages);
+    case "relation":
+      return chunk6HHSX6LP_js.createRelationValidator(attr, messages);
+    case "rating":
+      return chunkN47XKY4R_js.createRatingValidator(attr, messages);
+    case "formula":
+      return chunkJ4ORNCAH_js.createFormulaValidator(attr, messages);
+    case "rollup":
+      return chunkYKHC2AW6_js.createRollupValidator(attr, messages);
+    default:
+      return zod.z.unknown();
+  }
+}
+function createFormAttributeValidator(attr, messages = chunkVCPYYLCS_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-4RGFTMQR.mjs

@@ -0,0 +1,8 @@
+import { DEFAULT_VALIDATION_MESSAGES } from './chunk-BIQ35DLC.mjs';
+import { z } from 'zod';
+
+function createFormulaValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.unknown();
+}
+
+export { createFormulaValidator };

package/dist/chunk-5TLM4QXO.mjs

@@ -0,0 +1,8 @@
+import { DEFAULT_VALIDATION_MESSAGES } from './chunk-BIQ35DLC.mjs';
+import { z } from 'zod';
+
+function createCheckboxValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.boolean();
+}
+
+export { createCheckboxValidator };

package/dist/chunk-67PQMHQA.mjs

@@ -0,0 +1,199 @@
+import { createCheckboxValidator } from './chunk-5TLM4QXO.mjs';
+import { createDateValidator } from './chunk-XEOG24K6.mjs';
+import { createNumberValidator } from './chunk-PKG3E5MW.mjs';
+import { createRatingValidator } from './chunk-X6VDDXG7.mjs';
+import { createTextAreaValidator, createTextValidator } from './chunk-U7VN3RUE.mjs';
+import { createRelationValidator } from './chunk-QL3UGPUG.mjs';
+import { createRichtextValidator } from './chunk-VPEV3W34.mjs';
+import { createMultiselectValidator, createSelectValidator, createStatusValidator } from './chunk-ZFL7DXAE.mjs';
+import { createUserValidator } from './chunk-WGFQMQMV.mjs';
+import { createFormulaValidator } from './chunk-4RGFTMQR.mjs';
+import { createRollupValidator } from './chunk-NXXSNUDI.mjs';
+import { createCurrencyValidator } from './chunk-SVII65W7.mjs';
+import { createFileValidator } from './chunk-MD6XGXTU.mjs';
+import { createLocationValidator } from './chunk-ZM7W2ZCF.mjs';
+import { createPhoneValidator } from './chunk-EIWGW2ML.mjs';
+import { DEFAULT_VALIDATION_MESSAGES } from './chunk-BIQ35DLC.mjs';
+import { formatZodErrors } from './chunk-RDXQ4CYT.mjs';
+import { z } from '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 z.preprocess((val) => isEmptyValue(val) ? null : val, validator.nullish());
+}
+
+// src/validation/object/attribute-factory.ts
+function createAttributeValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  switch (attr.type) {
+    case "text":
+      return createTextValidator(attr, messages);
+    case "textarea":
+      return createTextAreaValidator(attr, messages);
+    case "richtext":
+      return createRichtextValidator(attr, messages);
+    case "number":
+      return createNumberValidator(attr, messages);
+    case "checkbox":
+      return createCheckboxValidator(attr, messages);
+    case "date":
+      return createDateValidator(attr, messages);
+    case "phone":
+      return createPhoneValidator(attr, messages);
+    case "currency":
+      return createCurrencyValidator(attr, messages);
+    case "status":
+      return createStatusValidator(attr, messages);
+    case "location":
+      return createLocationValidator(attr, messages);
+    case "select":
+      return createSelectValidator(attr, messages);
+    case "multiselect":
+      return createMultiselectValidator(attr, messages);
+    case "file":
+      return createFileValidator(attr, messages);
+    case "user":
+      return createUserValidator(attr, messages);
+    case "relation":
+      return createRelationValidator(attr, messages);
+    case "rating":
+      return createRatingValidator(attr, messages);
+    case "formula":
+      return createFormulaValidator(attr, messages);
+    case "rollup":
+      return createRollupValidator(attr, messages);
+    default:
+      return z.unknown();
+  }
+}
+function createFormAttributeValidator(attr, messages = 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 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 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: 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: 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: 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";
+}
+
+export { computeRecordStatus, createAttributeValidator, createDraftValidator, createFormAttributeValidator, createObjectValidator, getMissingRequiredAttributes, isRecordComplete, validateAttribute, validateDraft, validateDraftOrThrow, validateObject, validateObjectOrThrow };

package/dist/chunk-6HHSX6LP.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var chunkVCPYYLCS_js = require('./chunk-VCPYYLCS.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 = chunkVCPYYLCS_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 = chunkVCPYYLCS_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 = chunkVCPYYLCS_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-AHPXNPJC.js

@@ -0,0 +1,105 @@
+'use strict';
+
+var chunkVCPYYLCS_js = require('./chunk-VCPYYLCS.js');
+var constants = require('@stndrds/constants');
+var zod = require('zod');
+var libphonenumberJs = require('libphonenumber-js');
+
+function digitsOnly(input) {
+  return input.replace(/\D/g, "");
+}
+function getIso2(iso3) {
+  const country = constants.getCountryByIso3(iso3);
+  return country?.iso2;
+}
+function normalizePhoneNumber(phoneNumber, countryIso3) {
+  if (!phoneNumber) return "";
+  const iso2 = getIso2(countryIso3);
+  if (!iso2) {
+    return digitsOnly(phoneNumber);
+  }
+  const parsed = libphonenumberJs.parsePhoneNumberFromString(phoneNumber, iso2);
+  if (parsed) {
+    return parsed.nationalNumber;
+  }
+  const country = constants.getCountryByIso3(countryIso3);
+  const digits = digitsOnly(phoneNumber);
+  if (country) {
+    const callingCode = country.phoneCode.replace("+", "");
+    const withoutCC = digits.startsWith(callingCode) ? digits.slice(callingCode.length) : digits;
+    return constants.stripTrunkPrefix(withoutCC, country.phoneTrunkPrefix ?? "");
+  }
+  return digits;
+}
+function validatePhoneNumber(phoneNumber, countryIso3) {
+  if (!phoneNumber) return false;
+  const iso2 = getIso2(countryIso3);
+  if (!iso2) return false;
+  const country = constants.getCountryByIso3(countryIso3);
+  if (!country) return false;
+  const trunkPrefix = country.phoneTrunkPrefix ?? "";
+  const digits = digitsOnly(phoneNumber);
+  const withTrunk = trunkPrefix + digits;
+  const parsed = libphonenumberJs.parsePhoneNumberFromString(withTrunk, iso2);
+  if (parsed?.isValid()) return true;
+  const parsedDirect = libphonenumberJs.parsePhoneNumberFromString(phoneNumber, iso2);
+  if (parsedDirect?.isValid()) return true;
+  const maxDigits = country.phoneMaxDigits ?? 15;
+  const expectedWithoutTrunk = maxDigits - trunkPrefix.length;
+  return digits.length === expectedWithoutTrunk || digits.length === maxDigits;
+}
+function formatPhoneForDisplay(phone) {
+  if (!phone.phoneNumber) return "";
+  const iso2 = getIso2(phone.countryCode);
+  const country = constants.getCountryByIso3(phone.countryCode);
+  const dial = country?.phoneCode ?? "";
+  if (!iso2) {
+    return `${dial} ${phone.phoneNumber}`.trim();
+  }
+  const e164 = `${dial}${digitsOnly(phone.phoneNumber)}`;
+  const parsed = libphonenumberJs.parsePhoneNumberFromString(e164);
+  if (parsed) {
+    return parsed.formatInternational();
+  }
+  return `${dial} ${phone.phoneNumber}`.trim();
+}
+function parseRawPhoneInput(rawInput, countryIso3) {
+  if (!rawInput || rawInput.trim() === "") {
+    return { success: false, error: "Phone number is empty" };
+  }
+  const normalized = normalizePhoneNumber(rawInput, countryIso3);
+  if (!normalized) {
+    return { success: false, error: "Could not extract digits from input" };
+  }
+  if (!validatePhoneNumber(normalized, countryIso3)) {
+    return { success: false, error: "Invalid phone number for country" };
+  }
+  return {
+    success: true,
+    phone: { countryCode: countryIso3, phoneNumber: normalized }
+  };
+}
+
+// src/validation/complex/phone.ts
+function createPhoneValidator(attr, messages = chunkVCPYYLCS_js.DEFAULT_VALIDATION_MESSAGES) {
+  return zod.z.object(
+    {
+      countryCode: zod.z.string().length(3),
+      phoneNumber: zod.z.string().min(1)
+    },
+    { message: messages.invalidPhone(attr) }
+  ).refine((val) => constants.isValidIso3(val.countryCode), {
+    message: "Invalid country code"
+  }).transform((val) => ({
+    countryCode: val.countryCode,
+    phoneNumber: normalizePhoneNumber(val.phoneNumber, val.countryCode)
+  })).refine((val) => validatePhoneNumber(val.phoneNumber, val.countryCode), {
+    message: messages.invalidPhone(attr)
+  });
+}
+
+exports.createPhoneValidator = createPhoneValidator;
+exports.formatPhoneForDisplay = formatPhoneForDisplay;
+exports.normalizePhoneNumber = normalizePhoneNumber;
+exports.parseRawPhoneInput = parseRawPhoneInput;
+exports.validatePhoneNumber = validatePhoneNumber;

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-BH3RPSC5.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var chunkVCPYYLCS_js = require('./chunk-VCPYYLCS.js');
+var zod = require('zod');
+
+function createLocationValidator(attr, messages = chunkVCPYYLCS_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;