@turndown/library 0.1.59 → 0.1.62

package/dist/index.mjs

@@ -1093,6 +1093,229 @@ var HTTP_STATUS = {
   InternalError: 500
 };
 
+// src/types/validation/index.ts
+var createValidationSchema = (fields) => {
+  const allowedFields = Object.keys(fields);
+  const requiredFields = allowedFields.filter((fieldName) => {
+    return fields[fieldName].required;
+  });
+  return {
+    fields,
+    allowedFields,
+    requiredFields,
+    validate: (value, options = {}) => {
+      if (!isRecord2(value)) {
+        return {
+          success: false,
+          issues: [
+            {
+              fieldName: "body",
+              type: "INVALID_BODY"
+            }
+          ]
+        };
+      }
+      const issues = getValidationIssues(fields, value, options);
+      if (issues.length > 0) {
+        return {
+          success: false,
+          issues
+        };
+      }
+      return {
+        success: true,
+        data: value,
+        issues: []
+      };
+    }
+  };
+};
+var requiredStringField = (missingValuePolicy = "Nullish") => ({
+  required: true,
+  missingValuePolicy,
+  validate: isNonEmptyString
+});
+var optionalStringField = () => ({
+  required: false,
+  missingValuePolicy: "Nullish",
+  validate: isNonEmptyString
+});
+var optionalNullableStringField = () => ({
+  required: false,
+  missingValuePolicy: "Nullish",
+  validate: (value) => {
+    return value === null || isNonEmptyString(value);
+  }
+});
+var requiredEmailField = (missingValuePolicy = "BlankString") => ({
+  required: true,
+  missingValuePolicy,
+  validate: isEmail2
+});
+var requiredUuidField = (missingValuePolicy = "Nullish") => ({
+  required: true,
+  missingValuePolicy,
+  validate: isUuid
+});
+var optionalNullableNonNegativeIntegerField = () => ({
+  required: false,
+  missingValuePolicy: "Nullish",
+  validate: (value) => {
+    return value === null || Number.isInteger(value) && Number(value) >= 0;
+  }
+});
+var optionalRecordField = () => ({
+  required: false,
+  missingValuePolicy: "Nullish",
+  validate: isRecord2
+});
+var requiredEnumField = (allowedValues, missingValuePolicy = "Nullish") => ({
+  required: true,
+  missingValuePolicy,
+  validate: (value) => {
+    return isAllowedStringValue(value, allowedValues);
+  }
+});
+var optionalEnumField = (allowedValues) => ({
+  required: false,
+  missingValuePolicy: "Nullish",
+  validate: (value) => {
+    return isAllowedStringValue(value, allowedValues);
+  }
+});
+var optionalNullableEnumField = (allowedValues) => ({
+  required: false,
+  missingValuePolicy: "Nullish",
+  validate: (value) => {
+    return value === null || isAllowedStringValue(value, allowedValues);
+  }
+});
+var getValidationIssues = (fields, value, options) => {
+  const allowedFieldSet = new Set(Object.keys(fields));
+  const issues = [];
+  Object.entries(fields).forEach(([fieldName, field]) => {
+    const fieldValue = value[fieldName];
+    if (field.required && isMissingValue(fieldValue, field.missingValuePolicy)) {
+      issues.push({
+        fieldName,
+        type: "MISSING_FIELD"
+      });
+      return;
+    }
+    if (fieldValue === void 0) {
+      return;
+    }
+    if (!field.validate(fieldValue)) {
+      issues.push({
+        fieldName,
+        type: "INVALID_FIELD"
+      });
+    }
+  });
+  if (options.rejectUnknownFields === true) {
+    Object.keys(value).forEach((fieldName) => {
+      if (!allowedFieldSet.has(fieldName)) {
+        issues.push({
+          fieldName,
+          type: "UNSUPPORTED_FIELD"
+        });
+      }
+    });
+  }
+  return issues;
+};
+var isRecord2 = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var isMissingValue = (value, missingValuePolicy) => {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  return missingValuePolicy === "BlankString" && typeof value === "string" && value.trim().length === 0;
+};
+var isNonEmptyString = (value) => {
+  return typeof value === "string" && value.trim().length > 0;
+};
+var isAllowedStringValue = (value, allowedValues) => {
+  return typeof value === "string" && allowedValues.includes(value);
+};
+var isEmail2 = (value) => {
+  if (!isNonEmptyString(value)) {
+    return false;
+  }
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value.trim());
+};
+var isUuid = (value) => {
+  if (!isNonEmptyString(value)) {
+    return false;
+  }
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+    value
+  );
+};
+
+// src/types/user/constants.ts
+var ACCOUNT_TYPE = {
+  TURNDOWN_ADMIN: "TURNDOWN_ADMIN",
+  ACCOUNT_ADMIN: "ACCOUNT_ADMIN",
+  MANAGER: "MANAGER",
+  STAFF: "STAFF",
+  GUEST: "GUEST"
+};
+var ACCOUNT_STATUS = {
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE",
+  SUSPENDED: "SUSPENDED",
+  PENDING: "PENDING"
+};
+var LANGUAGE = {
+  ENGLISH: "ENGLISH",
+  FRENCH: "FRENCH",
+  SPANISH: "SPANISH",
+  GERMAN: "GERMAN"
+};
+
+// src/types/auth/routes.ts
+var AccountTypeValues = Object.values(ACCOUNT_TYPE);
+var RegisterRequestSchema = createValidationSchema({
+  email: requiredEmailField(),
+  password: requiredStringField("BlankString"),
+  firstName: requiredStringField("BlankString"),
+  lastName: optionalStringField(),
+  accountType: requiredEnumField(AccountTypeValues, "BlankString"),
+  deviceInfo: optionalRecordField()
+});
+var LoginRequestSchema = createValidationSchema({
+  email: requiredEmailField(),
+  password: requiredStringField("BlankString"),
+  deviceInfo: optionalRecordField()
+});
+var RefreshSessionRequestSchema = createValidationSchema({
+  refreshToken: requiredStringField("BlankString"),
+  deviceInfo: optionalRecordField()
+});
+var LogoutRequestSchema = createValidationSchema({
+  refreshToken: optionalStringField()
+});
+var ChangePasswordRequestSchema = createValidationSchema({
+  currentPassword: requiredStringField("BlankString"),
+  newPassword: requiredStringField("BlankString")
+});
+var ForgotPasswordRequestSchema = createValidationSchema({
+  email: requiredEmailField()
+});
+var RegisterWithInvitationRequestSchema = createValidationSchema({
+  token: requiredStringField("BlankString"),
+  password: requiredStringField("BlankString"),
+  firstName: requiredStringField("BlankString"),
+  lastName: optionalStringField(),
+  deviceInfo: optionalRecordField()
+});
+var AcceptInvitationRequestSchema = createValidationSchema({
+  userId: optionalStringField(),
+  token: requiredStringField("BlankString")
+});
+
 // src/types/auth/index.ts
 var AUTH_STATUS = {
   Initializing: "Initializing",
@@ -1273,14 +1496,7 @@ var ServiceTypeOptions = [
   { label: "Other", value: SERVICE_TYPES.OTHER }
 ];
 
-// src/types/company/routes.ts
-var CompanyFilter = {
-  Active: "active",
-  Pending: "pending",
-  All: "all"
-};
-
-// src/types/company/index.ts
+// src/types/company/constants.ts
 var COMPANY_RELATIONSHIP_STATUS = {
   ACTIVE: "ACTIVE",
   INACTIVE: "INACTIVE",
@@ -1300,6 +1516,50 @@ var COMPANY_TYPES = {
   OTHER: "OTHER"
 };
 
+// src/types/company/routes.ts
+var CompanyFilter = {
+  Active: "active",
+  Pending: "pending",
+  All: "all"
+};
+var CompanyTypeValues = Object.values(COMPANY_TYPES);
+var StateCodeValues = Object.keys(US_JURISDICTIONS);
+var InviteUserRoleValues = Object.values(ACCOUNT_TYPE).filter(
+  (accountType) => accountType !== ACCOUNT_TYPE.TURNDOWN_ADMIN
+);
+var CreateCompanyRequestSchema = createValidationSchema({
+  displayName: requiredStringField("BlankString"),
+  addressLine1: requiredStringField("BlankString"),
+  addressLine2: optionalNullableStringField(),
+  city: requiredStringField("BlankString"),
+  stateCode: requiredEnumField(StateCodeValues, "BlankString"),
+  postalCode: requiredStringField("BlankString"),
+  companyType: requiredEnumField(CompanyTypeValues, "BlankString"),
+  country: optionalNullableStringField(),
+  timezone: optionalNullableStringField(),
+  imageUrl: optionalNullableStringField()
+});
+var UpdateCompanyRequestSchema = createValidationSchema({
+  displayName: optionalStringField(),
+  addressLine1: optionalStringField(),
+  addressLine2: optionalNullableStringField(),
+  city: optionalStringField(),
+  stateCode: optionalEnumField(StateCodeValues),
+  postalCode: optionalStringField(),
+  companyType: optionalEnumField(CompanyTypeValues),
+  country: optionalNullableStringField(),
+  timezone: optionalNullableStringField(),
+  imageUrl: optionalNullableStringField()
+});
+var InviteUserToCompanyRequestSchema = createValidationSchema({
+  email: requiredEmailField(),
+  role: requiredEnumField(InviteUserRoleValues, "BlankString")
+});
+var InviteCompanyToCompanyRequestSchema = createValidationSchema({
+  providerCompanyId: requiredUuidField(),
+  message: optionalNullableStringField()
+});
+
 // src/types/damage-report/index.ts
 var DAMAGE_SEVERITY = {
   LOW: "LOW",
@@ -1402,7 +1662,7 @@ var INVENTORY_ITEM_TYPE = {
   FIXED: "FIXED"
 };
 
-// src/types/property/index.ts
+// src/types/property/constants.ts
 var PROPERTY_STATUS = {
   ACTIVE: "ACTIVE",
   INACTIVE: "INACTIVE"
@@ -1477,7 +1737,52 @@ var PropertyTypeOptions = [
   }
 ];
 
-// src/types/room/index.ts
+// src/types/property/routes.ts
+var PropertyTypeValues = Object.values(PROPERTY_TYPES);
+var PropertyStatusValues = Object.values(PROPERTY_STATUS);
+var StateCodeValues2 = Object.keys(US_JURISDICTIONS);
+var CreatePropertyRequestSchema = createValidationSchema({
+  companyId: requiredStringField(),
+  displayName: requiredStringField(),
+  propertyType: requiredEnumField(PropertyTypeValues),
+  status: optionalNullableEnumField(PropertyStatusValues),
+  addressLine1: requiredStringField(),
+  addressLine2: optionalNullableStringField(),
+  city: requiredStringField(),
+  stateCode: requiredEnumField(StateCodeValues2),
+  postalCode: requiredStringField(),
+  country: optionalNullableStringField(),
+  sqft: optionalNullableNonNegativeIntegerField(),
+  timezone: optionalNullableStringField(),
+  imageUrl: optionalNullableStringField(),
+  specialNotes: optionalNullableStringField()
+});
+var UpdatePropertyRequestSchema = createValidationSchema({
+  displayName: optionalStringField(),
+  propertyType: optionalNullableEnumField(PropertyTypeValues),
+  status: optionalNullableEnumField(PropertyStatusValues),
+  addressLine1: optionalStringField(),
+  addressLine2: optionalNullableStringField(),
+  city: optionalStringField(),
+  stateCode: optionalEnumField(StateCodeValues2),
+  postalCode: optionalStringField(),
+  country: optionalNullableStringField(),
+  sqft: optionalNullableNonNegativeIntegerField(),
+  timezone: optionalNullableStringField(),
+  imageUrl: optionalNullableStringField(),
+  specialNotes: optionalNullableStringField()
+});
+var UpdatePropertyAccessInformationRequestSchema = createValidationSchema({
+  entryInstructions: optionalNullableStringField(),
+  accessCode: optionalNullableStringField(),
+  wifiName: optionalNullableStringField(),
+  wifiPassword: optionalNullableStringField(),
+  alarmCode: optionalNullableStringField(),
+  parkingInfo: optionalNullableStringField(),
+  specialNotes: optionalNullableStringField()
+});
+
+// src/types/room/constants.ts
 var ROOM_TYPE = {
   BEDROOM: "BEDROOM",
   BATHROOM: "BATHROOM",
@@ -1495,6 +1800,24 @@ var ROOM_TYPE = {
   OTHER: "OTHER"
 };
 
+// src/types/room/routes.ts
+var RoomTypeValues = Object.values(ROOM_TYPE);
+var CreateRoomRequestSchema = createValidationSchema({
+  propertyId: requiredStringField(),
+  displayName: requiredStringField(),
+  description: optionalNullableStringField(),
+  checklistTemplateId: optionalNullableStringField(),
+  roomType: optionalNullableEnumField(RoomTypeValues),
+  heroPhoto: optionalNullableStringField()
+});
+var UpdateRoomRequestSchema = createValidationSchema({
+  displayName: optionalStringField(),
+  description: optionalNullableStringField(),
+  checklistTemplateId: optionalNullableStringField(),
+  roomType: optionalNullableEnumField(RoomTypeValues),
+  heroPhoto: optionalNullableStringField()
+});
+
 // src/types/subscription/index.ts
 var SUBSCRIPTION_STATUS = {
   ACTIVE: "ACTIVE",
@@ -1513,26 +1836,22 @@ var BILLING_PERIOD = {
   YEARLY: "YEARLY"
 };
 
-// src/types/user/index.ts
-var ACCOUNT_TYPE = {
-  TURNDOWN_ADMIN: "TURNDOWN_ADMIN",
-  ACCOUNT_ADMIN: "ACCOUNT_ADMIN",
-  MANAGER: "MANAGER",
-  STAFF: "STAFF",
-  GUEST: "GUEST"
-};
-var ACCOUNT_STATUS = {
-  ACTIVE: "ACTIVE",
-  INACTIVE: "INACTIVE",
-  SUSPENDED: "SUSPENDED",
-  PENDING: "PENDING"
-};
-var LANGUAGE = {
-  ENGLISH: "ENGLISH",
-  FRENCH: "FRENCH",
-  SPANISH: "SPANISH",
-  GERMAN: "GERMAN"
-};
+// src/types/user/routes.ts
+var LanguageValues = Object.values(LANGUAGE);
+var UpdateUserRequestSchema = createValidationSchema({
+  firstName: optionalStringField(),
+  lastName: optionalNullableStringField(),
+  mi: optionalNullableStringField(),
+  username: optionalNullableStringField(),
+  email: optionalStringField(),
+  phoneNumber: optionalNullableStringField(),
+  phoneFormat: optionalNullableStringField(),
+  preferredLanguage: optionalEnumField(LanguageValues)
+});
+var UpdateCurrentUserRequestSchema = createValidationSchema({
+  firstName: optionalStringField(),
+  lastName: optionalStringField()
+});
 
 // src/types/work-session/index.ts
 var WORK_SESSION_STATUS = {
@@ -1550,17 +1869,23 @@ export {
   ACCOUNT_STATUS,
   ACCOUNT_TYPE,
   AUTH_STATUS,
+  AcceptInvitationRequestSchema,
   BILLING_PERIOD,
   CHECKLIST_EXECUTION_STATUS,
   COMPANY_RELATIONSHIP_STATUS,
   COMPANY_TYPES,
+  ChangePasswordRequestSchema,
   CompanyFilter,
+  CreateCompanyRequestSchema,
+  CreatePropertyRequestSchema,
+  CreateRoomRequestSchema,
   DAMAGE_SEVERITY,
   DAMAGE_STATUS,
   DATABASE_STATUS,
   ENVIRONMENT,
   ERROR_CODES,
   FilterCondition,
+  ForgotPasswordRequestSchema,
   HTTP_METHOD,
   HTTP_STATUS,
   IMAGE_ENTITY,
@@ -1569,8 +1894,12 @@ export {
   INVENTORY_RESTOCK_ORDER_STATUS,
   INVENTORY_UNITS,
   INVITATION_STATUS,
+  InviteCompanyToCompanyRequestSchema,
+  InviteUserToCompanyRequestSchema,
   JSONStringify,
   LANGUAGE,
+  LoginRequestSchema,
+  LogoutRequestSchema,
   MODE,
   MONTHS,
   PROPERTY_STATUS,
@@ -1578,6 +1907,9 @@ export {
   PropertyStatusOptions,
   PropertyTypeOptions,
   ROOM_TYPE,
+  RefreshSessionRequestSchema,
+  RegisterRequestSchema,
+  RegisterWithInvitationRequestSchema,
   SERVER_STATUS,
   SERVICE_TYPES,
   SEVERITY,
@@ -1590,6 +1922,12 @@ export {
   StatusOptions,
   US_JURISDICTIONS,
   UnitedStatesJurisdictionOptions,
+  UpdateCompanyRequestSchema,
+  UpdateCurrentUserRequestSchema,
+  UpdatePropertyAccessInformationRequestSchema,
+  UpdatePropertyRequestSchema,
+  UpdateRoomRequestSchema,
+  UpdateUserRequestSchema,
   WORK_ORDER_PRIORITY,
   WORK_ORDER_STATUS,
   WORK_SESSION_STATUS,
@@ -1604,6 +1942,7 @@ export {
   containsAny,
   convertStringBooleans,
   createPagingObject,
+  createValidationSchema,
   daysBetween,
   deepClone,
   deletePropertyIfExists,
@@ -1644,6 +1983,12 @@ export {
   normalCase,
   normalizeSpaces,
   omitProperties,
+  optionalEnumField,
+  optionalNullableEnumField,
+  optionalNullableNonNegativeIntegerField,
+  optionalNullableStringField,
+  optionalRecordField,
+  optionalStringField,
   padEnd,
   padStart,
   parseJSON,
@@ -1658,6 +2003,10 @@ export {
   repeat,
   repeatChar,
   replaceNulls,
+  requiredEmailField,
+  requiredEnumField,
+  requiredStringField,
+  requiredUuidField,
   resetPagination,
   returnObject,
   reverse,