@stndrds/schema 1.0.0-alpha.293 → 1.0.0-alpha.68

package/dist/chunk-IXHWBBIY.mjs

@@ -0,0 +1,721 @@
+// src/validation/validators.ts
+import { isValidIso3 } from "@stndrds/constants";
+import { z } from "zod";
+
+// src/phone-utils.ts
+import { getCountryByIso3, stripTrunkPrefix } from "@stndrds/constants";
+import { parsePhoneNumberFromString } from "libphonenumber-js";
+function digitsOnly(input) {
+  return input.replace(/\D/g, "");
+}
+function getIso2(iso3) {
+  const country = getCountryByIso3(iso3);
+  return country?.iso2;
+}
+function normalizePhoneNumber(phoneNumber, countryIso3) {
+  if (!phoneNumber) return "";
+  const iso2 = getIso2(countryIso3);
+  if (!iso2) {
+    return digitsOnly(phoneNumber);
+  }
+  const parsed = parsePhoneNumberFromString(phoneNumber, iso2);
+  if (parsed) {
+    return parsed.nationalNumber;
+  }
+  const country = getCountryByIso3(countryIso3);
+  const digits = digitsOnly(phoneNumber);
+  if (country) {
+    const callingCode = country.phoneCode.replace("+", "");
+    const withoutCC = digits.startsWith(callingCode) ? digits.slice(callingCode.length) : digits;
+    return stripTrunkPrefix(withoutCC, country.phoneTrunkPrefix ?? "");
+  }
+  return digits;
+}
+function validatePhoneNumber(phoneNumber, countryIso3) {
+  if (!phoneNumber) return false;
+  const iso2 = getIso2(countryIso3);
+  if (!iso2) return false;
+  const country = getCountryByIso3(countryIso3);
+  if (!country) return false;
+  const trunkPrefix = country.phoneTrunkPrefix ?? "";
+  const digits = digitsOnly(phoneNumber);
+  const withTrunk = trunkPrefix + digits;
+  const parsed = parsePhoneNumberFromString(withTrunk, iso2);
+  if (parsed?.isValid()) return true;
+  const parsedDirect = 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 = getCountryByIso3(phone.countryCode);
+  const dial = country?.phoneCode ?? "";
+  if (!iso2) {
+    return `${dial} ${phone.phoneNumber}`.trim();
+  }
+  const e164 = `${dial}${digitsOnly(phone.phoneNumber)}`;
+  const parsed = 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/validators.ts
+var regexPatternCache = /* @__PURE__ */ new Map();
+function getCachedRegex(pattern) {
+  let cached = regexPatternCache.get(pattern);
+  if (!cached) {
+    cached = new RegExp(pattern);
+    regexPatternCache.set(pattern, cached);
+  }
+  return cached;
+}
+function formatZodErrors(error) {
+  return error.issues.map((err) => ({
+    path: err.path.map(String),
+    message: err.message
+  }));
+}
+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`
+};
+var baseConfigSchema = z.object({
+  disabled: z.boolean().optional(),
+  placeholder: z.string().optional(),
+  description: z.string().optional(),
+  defaultValue: z.unknown().optional(),
+  icon: z.string().optional(),
+  order: z.number().int().optional(),
+  hidden: z.boolean().optional(),
+  archived: z.boolean().optional(),
+  deprecated: z.boolean().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var optionSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  value: z.string().min(1),
+  color: z.string().optional(),
+  icon: z.string().optional(),
+  description: z.string().optional(),
+  group: z.enum(["idle", "in_progress", "finished"]).optional()
+});
+var optionsArraySchema = z.array(optionSchema).min(1).refine(
+  (options) => {
+    const values = options.map((o) => o.value);
+    return new Set(values).size === values.length;
+  },
+  { message: "Duplicate option values are not allowed" }
+);
+var relationTargetSchema = z.object({
+  object: z.string().min(1),
+  displayTemplate: z.string().optional(),
+  filter: z.record(z.string(), z.unknown()).optional()
+});
+var textConfigSchema = baseConfigSchema.extend({
+  minLength: z.number().int().min(0).optional(),
+  maxLength: z.number().int().min(1).optional(),
+  pattern: z.string().optional()
+});
+var textareaConfigSchema = baseConfigSchema;
+var richtextConfigSchema = baseConfigSchema.extend({
+  features: z.array(
+    z.enum(["headings", "bold", "italic", "lists", "links", "images", "codeBlocks", "tables"])
+  ).optional()
+});
+var numberConfigSchema = baseConfigSchema.extend({
+  min: z.number().optional(),
+  max: z.number().optional(),
+  unit: z.enum(["integer", "decimal", "percentage"]).optional(),
+  decimals: z.number().int().min(0).optional()
+});
+var checkboxConfigSchema = baseConfigSchema;
+var dateConfigSchema = baseConfigSchema.extend({
+  dateFormat: z.enum(["short", "long", "full", "relative"]).optional(),
+  minDate: z.string().optional(),
+  maxDate: z.string().optional()
+});
+var phoneConfigSchema = baseConfigSchema.extend({
+  defaultCountryCode: z.string().length(3).optional()
+});
+var currencyConfigSchema = baseConfigSchema.extend({
+  defaultCurrency: z.string().length(3).optional(),
+  allowedCurrencies: z.array(z.string().length(3)).optional()
+});
+var statusConfigSchema = baseConfigSchema.extend({
+  options: optionsArraySchema
+});
+var locationConfigSchema = baseConfigSchema.extend({
+  granularity: z.enum(["full", "address", "city", "state", "country", "coordinates"]),
+  enableAutocomplete: z.boolean().optional(),
+  enableMap: z.boolean().optional(),
+  defaultCountry: z.string().length(3).optional(),
+  allowedCountries: z.array(z.string().length(3)).optional(),
+  displayFormat: z.enum(["single_line", "multi_line", "compact"]).optional()
+});
+var selectConfigSchema = baseConfigSchema.extend({
+  options: optionsArraySchema
+});
+var multiselectConfigSchema = baseConfigSchema.extend({
+  options: optionsArraySchema
+});
+var fileConfigSchema = baseConfigSchema.extend({
+  maxFiles: z.number().int().min(1).optional(),
+  maxSize: z.number().int().min(1).optional(),
+  allowedTypes: z.array(z.string()).optional(),
+  multiple: z.boolean().optional()
+});
+var userConfigSchema = baseConfigSchema.extend({
+  allowedRoles: z.array(z.string()).optional(),
+  multiple: z.boolean().optional()
+});
+var relationConfigSchema = baseConfigSchema.extend({
+  targets: z.array(relationTargetSchema).min(1),
+  cardinality: z.enum(["one", "many"]),
+  minItems: z.number().int().min(0).optional(),
+  maxItems: z.number().int().min(1).optional()
+});
+var ratingConfigSchema = baseConfigSchema.extend({
+  max: z.number().int().min(1).optional(),
+  iconType: z.enum(["star", "heart", "thumbs", "number"]).optional()
+});
+var formulaConfigSchema = baseConfigSchema.extend({
+  expression: z.string().min(1),
+  returnType: z.enum(["text", "number", "boolean", "date"]),
+  decimals: z.number().int().min(0).max(10).optional(),
+  allowRelations: z.boolean().optional()
+});
+var rollupConfigSchema = baseConfigSchema.extend({
+  relationAttribute: z.string().min(1).optional(),
+  relationPath: z.string().optional(),
+  targetAttribute: z.string().min(1),
+  function: z.enum([
+    // Numeric aggregates
+    "sum",
+    "avg",
+    // Date aggregates
+    "earliest",
+    "latest",
+    // Count (universal)
+    "count",
+    "countValues",
+    "countUniqueValues",
+    "countEmpty",
+    // Percent (universal)
+    "percentEmpty",
+    "percentNotEmpty",
+    // Lookup (universal)
+    "original"
+  ]),
+  decimals: z.number().int().min(0).max(10).optional(),
+  targetAttributeType: z.string().optional(),
+  targetAttributeOptions: z.array(
+    z.object({
+      id: z.string(),
+      label: z.string(),
+      value: z.string(),
+      color: z.string().optional(),
+      icon: z.string().optional(),
+      description: z.string().optional(),
+      group: z.enum(["idle", "in_progress", "finished"]).optional()
+    })
+  ).optional()
+});
+var documentConfigSchema = baseConfigSchema.extend({
+  templateId: z.string().optional(),
+  allowedTemplates: z.array(z.string()).optional(),
+  multiple: z.boolean().optional(),
+  maxDocuments: z.number().int().min(1).optional(),
+  autoProcess: z.boolean().optional()
+});
+var attributeConfigSchemas = {
+  text: textConfigSchema,
+  textarea: textareaConfigSchema,
+  richtext: richtextConfigSchema,
+  number: numberConfigSchema,
+  checkbox: checkboxConfigSchema,
+  date: dateConfigSchema,
+  phone: phoneConfigSchema,
+  currency: currencyConfigSchema,
+  status: statusConfigSchema,
+  location: locationConfigSchema,
+  select: selectConfigSchema,
+  multiselect: multiselectConfigSchema,
+  file: fileConfigSchema,
+  user: userConfigSchema,
+  relation: relationConfigSchema,
+  rating: ratingConfigSchema,
+  formula: formulaConfigSchema,
+  rollup: rollupConfigSchema,
+  document: documentConfigSchema
+};
+function getAttributeConfigSchema(type) {
+  return attributeConfigSchemas[type];
+}
+function validateAttributeConfig(type, config) {
+  const schema = getAttributeConfigSchema(type);
+  const result = schema.safeParse(config);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    errors: formatZodErrors(result.error).map((err) => `${err.path.join(".")}: ${err.message}`)
+  };
+}
+function parseAttributeConfig(type, config) {
+  const schema = getAttributeConfigSchema(type);
+  return schema.strip().parse(config);
+}
+function safeParseAttributeConfig(type, config) {
+  const schema = getAttributeConfigSchema(type);
+  const result = schema.strip().safeParse(config);
+  return result.success ? result.data : void 0;
+}
+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(attr.pattern), messages.invalidPattern(attr));
+  }
+  return schema;
+}
+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;
+}
+function createCheckboxValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.boolean();
+}
+function createDateValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.coerce.date({ message: messages.invalidDate(attr) });
+}
+function createPhoneValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.object(
+    {
+      countryCode: z.string().length(3),
+      phoneNumber: z.string().min(1)
+    },
+    { message: messages.invalidPhone(attr) }
+  ).refine((val) => 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)
+  });
+}
+function createCurrencyValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.object(
+    {
+      code: z.string().length(3),
+      value: z.number().min(0)
+    },
+    { message: messages.invalidCurrency(attr) }
+  );
+}
+function createStatusValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  const validValues = attr.options.map((opt) => opt.value);
+  const validLabels = attr.options.map((opt) => opt.label);
+  return z.enum(validValues, {
+    message: messages.invalidOption(attr, validLabels)
+  });
+}
+function createSelectValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  const validValues = attr.options.map((opt) => opt.value);
+  const validLabels = attr.options.map((opt) => opt.label);
+  return z.enum(validValues, {
+    message: messages.invalidOption(attr, validLabels)
+  });
+}
+function createMultiselectValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  const validValues = attr.options.map((opt) => opt.value);
+  const validLabels = attr.options.map((opt) => opt.label);
+  return z.array(
+    z.enum(validValues, {
+      message: messages.invalidOption(attr, validLabels)
+    })
+  );
+}
+function createLocationValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.object(
+    {
+      address: z.string().optional(),
+      address2: z.string().optional(),
+      city: z.string().optional(),
+      state: z.string().optional(),
+      postalCode: z.string().optional(),
+      country: z.string().length(3).optional(),
+      latitude: z.number().optional(),
+      longitude: z.number().optional()
+    },
+    { message: messages.invalidLocation(attr) }
+  );
+}
+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;
+}
+function createUserValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  const uuidSchema = z.uuid({
+    message: messages.invalidId(attr)
+  });
+  if (attr.multiple) {
+    return z.array(uuidSchema);
+  }
+  return uuidSchema;
+}
+function extractRelationId(item) {
+  if (typeof item === "object" && item !== null && "id" in item) {
+    return item.id;
+  }
+  return item;
+}
+function createSingleRelationValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  const uuidSchema = z.uuid({
+    message: messages.invalidId(attr)
+  });
+  return z.preprocess((val) => extractRelationId(val), z.union([uuidSchema, z.null()]));
+}
+function createMultiRelationValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  const uuidSchema = z.uuid({
+    message: messages.invalidId(attr)
+  });
+  let arraySchema = z.array(uuidSchema);
+  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 z.preprocess(
+    (val) => Array.isArray(val) ? val.map(extractRelationId) : val,
+    arraySchema
+  );
+}
+function createRelationValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  if (attr.cardinality === "many") {
+    return createMultiRelationValidator(attr, messages);
+  }
+  return createSingleRelationValidator(attr, messages);
+}
+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;
+}
+function createFormulaValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.unknown();
+}
+function createRollupValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.unknown();
+}
+function createTextAreaValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.string();
+}
+function createRichtextValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.string({
+    message: messages.invalidRichtext(attr)
+  });
+}
+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 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());
+}
+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 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 createDraftValidator(objectDef) {
+  const shape = {};
+  for (const attr of objectDef.attributes) {
+    const validator = createAttributeValidator(attr);
+    shape[attr.name] = withEmptyToNull(validator);
+  }
+  return z.object(shape).passthrough();
+}
+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 {
+  normalizePhoneNumber,
+  validatePhoneNumber,
+  formatPhoneForDisplay,
+  parseRawPhoneInput,
+  formatZodErrors,
+  DEFAULT_VALIDATION_MESSAGES,
+  textConfigSchema,
+  textareaConfigSchema,
+  richtextConfigSchema,
+  numberConfigSchema,
+  checkboxConfigSchema,
+  dateConfigSchema,
+  phoneConfigSchema,
+  currencyConfigSchema,
+  statusConfigSchema,
+  locationConfigSchema,
+  selectConfigSchema,
+  multiselectConfigSchema,
+  fileConfigSchema,
+  userConfigSchema,
+  relationConfigSchema,
+  ratingConfigSchema,
+  formulaConfigSchema,
+  rollupConfigSchema,
+  documentConfigSchema,
+  attributeConfigSchemas,
+  getAttributeConfigSchema,
+  validateAttributeConfig,
+  parseAttributeConfig,
+  safeParseAttributeConfig,
+  createTextValidator,
+  createNumberValidator,
+  createCheckboxValidator,
+  createDateValidator,
+  createPhoneValidator,
+  createCurrencyValidator,
+  createStatusValidator,
+  createSelectValidator,
+  createMultiselectValidator,
+  createLocationValidator,
+  createFileValidator,
+  createUserValidator,
+  createSingleRelationValidator,
+  createMultiRelationValidator,
+  createRelationValidator,
+  createRatingValidator,
+  createFormulaValidator,
+  createRollupValidator,
+  createTextAreaValidator,
+  createRichtextValidator,
+  createAttributeValidator,
+  createFormAttributeValidator,
+  createObjectValidator,
+  validateAttribute,
+  validateObject,
+  validateObjectOrThrow,
+  createDraftValidator,
+  validateDraft,
+  validateDraftOrThrow,
+  getMissingRequiredAttributes,
+  isRecordComplete,
+  computeRecordStatus
+};