@turndown/library 0.1.64 → 0.1.66

package/dist/types/index.cjs

@@ -0,0 +1,947 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types/index.ts
+var types_exports = {};
+__export(types_exports, {
+  ACCOUNT_STATUS: () => ACCOUNT_STATUS,
+  ACCOUNT_TYPE: () => ACCOUNT_TYPE,
+  AUTH_STATUS: () => AUTH_STATUS,
+  AcceptInvitationRequestSchema: () => AcceptInvitationRequestSchema,
+  BILLING_PERIOD: () => BILLING_PERIOD,
+  CHECKLIST_EXECUTION_STATUS: () => CHECKLIST_EXECUTION_STATUS,
+  COMPANY_RELATIONSHIP_STATUS: () => COMPANY_RELATIONSHIP_STATUS,
+  COMPANY_TYPES: () => COMPANY_TYPES,
+  ChangePasswordRequestSchema: () => ChangePasswordRequestSchema,
+  CompanyFilter: () => CompanyFilter,
+  CreateCompanyRequestSchema: () => CreateCompanyRequestSchema,
+  CreatePropertyRequestSchema: () => CreatePropertyRequestSchema,
+  CreateRoomRequestSchema: () => CreateRoomRequestSchema,
+  DAMAGE_SEVERITY: () => DAMAGE_SEVERITY,
+  DAMAGE_STATUS: () => DAMAGE_STATUS,
+  DATABASE_STATUS: () => DATABASE_STATUS,
+  ENVIRONMENT: () => ENVIRONMENT,
+  ERROR_CODES: () => ERROR_CODES,
+  FilterCondition: () => FilterCondition,
+  ForgotPasswordRequestSchema: () => ForgotPasswordRequestSchema,
+  HTTP_METHOD: () => HTTP_METHOD,
+  HTTP_STATUS: () => HTTP_STATUS,
+  IMAGE_ENTITY: () => IMAGE_ENTITY,
+  IMAGE_ENTITY_TYPE: () => IMAGE_ENTITY_TYPE,
+  INVENTORY_ITEM_TYPE: () => INVENTORY_ITEM_TYPE,
+  INVENTORY_RESTOCK_ORDER_STATUS: () => INVENTORY_RESTOCK_ORDER_STATUS,
+  INVENTORY_UNITS: () => INVENTORY_UNITS,
+  INVITATION_STATUS: () => INVITATION_STATUS,
+  InviteCompanyToCompanyRequestSchema: () => InviteCompanyToCompanyRequestSchema,
+  InviteUserToCompanyRequestSchema: () => InviteUserToCompanyRequestSchema,
+  LANGUAGE: () => LANGUAGE,
+  LoginRequestSchema: () => LoginRequestSchema,
+  LogoutRequestSchema: () => LogoutRequestSchema,
+  MODE: () => MODE,
+  MONTHS: () => MONTHS,
+  PROPERTY_STATUS: () => PROPERTY_STATUS,
+  PROPERTY_TYPES: () => PROPERTY_TYPES,
+  PropertyStatusOptions: () => PropertyStatusOptions,
+  PropertyTypeOptions: () => PropertyTypeOptions,
+  ROOM_TYPE: () => ROOM_TYPE,
+  RefreshSessionRequestSchema: () => RefreshSessionRequestSchema,
+  RegisterRequestSchema: () => RegisterRequestSchema,
+  RegisterWithInvitationRequestSchema: () => RegisterWithInvitationRequestSchema,
+  SERVER_STATUS: () => SERVER_STATUS,
+  SERVICE_TYPES: () => SERVICE_TYPES,
+  SEVERITY: () => SEVERITY,
+  STATUS: () => STATUS,
+  SUBSCRIPTION_PROVIDER: () => SUBSCRIPTION_PROVIDER,
+  SUBSCRIPTION_STATUS: () => SUBSCRIPTION_STATUS,
+  ServiceTypeOptions: () => ServiceTypeOptions,
+  SeverityOptions: () => SeverityOptions,
+  SortDirection: () => SortDirection,
+  StatusOptions: () => StatusOptions,
+  US_JURISDICTIONS: () => US_JURISDICTIONS,
+  UnitedStatesJurisdictionOptions: () => UnitedStatesJurisdictionOptions,
+  UpdateCompanyRequestSchema: () => UpdateCompanyRequestSchema,
+  UpdateCurrentUserRequestSchema: () => UpdateCurrentUserRequestSchema,
+  UpdatePropertyAccessInformationRequestSchema: () => UpdatePropertyAccessInformationRequestSchema,
+  UpdatePropertyRequestSchema: () => UpdatePropertyRequestSchema,
+  UpdateRoomRequestSchema: () => UpdateRoomRequestSchema,
+  UpdateUserRequestSchema: () => UpdateUserRequestSchema,
+  WEEK_DAY: () => WEEK_DAY,
+  WEEK_DAY_LETTER: () => WEEK_DAY_LETTER,
+  WEEK_DAY_SHORT_LABEL: () => WEEK_DAY_SHORT_LABEL,
+  WORK_ORDER_PRIORITY: () => WORK_ORDER_PRIORITY,
+  WORK_ORDER_STATUS: () => WORK_ORDER_STATUS,
+  WORK_SESSION_STATUS: () => WORK_SESSION_STATUS,
+  createPagingObject: () => createPagingObject,
+  createValidationSchema: () => createValidationSchema,
+  isAuthError: () => isAuthError,
+  isMissingFieldsError: () => isMissingFieldsError,
+  isRateLimitError: () => isRateLimitError,
+  isValidationError: () => isValidationError,
+  optionalEnumField: () => optionalEnumField,
+  optionalNullableEnumField: () => optionalNullableEnumField,
+  optionalNullableNonNegativeIntegerField: () => optionalNullableNonNegativeIntegerField,
+  optionalNullableStringField: () => optionalNullableStringField,
+  optionalRecordField: () => optionalRecordField,
+  optionalStringField: () => optionalStringField,
+  requiredEmailField: () => requiredEmailField,
+  requiredEnumField: () => requiredEnumField,
+  requiredStringField: () => requiredStringField,
+  requiredUuidField: () => requiredUuidField
+});
+module.exports = __toCommonJS(types_exports);
+
+// src/types/api/index.ts
+var HTTP_METHOD = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT",
+  PATCH: "PATCH",
+  DELETE: "DELETE"
+};
+var ERROR_CODES = {
+  BAD_REQUEST: "BAD_REQUEST",
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  MISSING_FIELDS: "MISSING_FIELDS",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  INVALID_TOKEN: "INVALID_TOKEN",
+  INVALID_CREDENTIALS: "INVALID_CREDENTIALS",
+  FORBIDDEN: "FORBIDDEN",
+  NOT_FOUND: "NOT_FOUND",
+  CONFLICT: "CONFLICT",
+  ALREADY_EXISTS: "ALREADY_EXISTS",
+  RATE_LIMIT: "RATE_LIMIT",
+  RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  DATABASE_ERROR: "DATABASE_ERROR",
+  NOT_IMPLEMENTED: "NOT_IMPLEMENTED"
+};
+var HTTP_STATUS = {
+  Ok: 200,
+  Created: 201,
+  NoContent: 204,
+  BadRequest: 400,
+  Unauthorized: 401,
+  Forbidden: 403,
+  NotFound: 404,
+  Conflict: 409,
+  UnprocessableEntity: 422,
+  TooManyRequests: 429,
+  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 (!isRecord(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: isEmail
+});
+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: isRecord
+});
+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 isRecord = (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 isEmail = (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",
+  Unauthenticated: "Unauthenticated",
+  Authenticated: "Authenticated",
+  Refreshing: "Refreshing",
+  SessionExpired: "SessionExpired"
+};
+
+// src/types/base/paging.types.ts
+var SortDirection = {
+  Asc: "Asc",
+  Desc: "Desc"
+};
+var FilterCondition = {
+  Equal: "=",
+  GreaterThan: ">",
+  LessThan: "<",
+  NotEqual: "!=",
+  Like: "LIKE",
+  In: "IN",
+  GreaterThanOrEqual: ">=",
+  LessThanOrEqual: "<="
+};
+var createPagingObject = (page, size, sort, filters) => ({
+  pagination: {
+    page,
+    size,
+    sort,
+    filters
+  }
+});
+
+// src/types/base/index.ts
+var ENVIRONMENT = {
+  Prod: "Prod",
+  Dev: "Dev",
+  Local: "Local",
+  Test: "Test"
+};
+var MODE = {
+  Create: "Create",
+  Edit: "Edit",
+  Delete: "Delete",
+  Details: "Details"
+};
+var IMAGE_ENTITY = {
+  USER_PROFILE: "USER_PROFILE",
+  PROPERTY: "PROPERTY",
+  COMPANY: "COMPANY",
+  CHECKLIST_ITEM: "CHECKLIST_ITEM",
+  PROPERTY_ROOM: "PROPERTY_ROOM",
+  MAINTENANCE_TICKET: "MAINTENANCE_TICKET",
+  WORK_REPORT: "WORK_REPORT",
+  CLEANING_REPORT: "CLEANING_REPORT",
+  TURNDOWN_DEFAULT: "TURNDOWN_DEFAULT"
+};
+var US_JURISDICTIONS = {
+  // 50 States
+  AL: "Alabama",
+  AK: "Alaska",
+  AZ: "Arizona",
+  AR: "Arkansas",
+  CA: "California",
+  CO: "Colorado",
+  CT: "Connecticut",
+  DE: "Delaware",
+  FL: "Florida",
+  GA: "Georgia",
+  HI: "Hawaii",
+  ID: "Idaho",
+  IL: "Illinois",
+  IN: "Indiana",
+  IA: "Iowa",
+  KS: "Kansas",
+  KY: "Kentucky",
+  LA: "Louisiana",
+  ME: "Maine",
+  MD: "Maryland",
+  MA: "Massachusetts",
+  MI: "Michigan",
+  MN: "Minnesota",
+  MS: "Mississippi",
+  MO: "Missouri",
+  MT: "Montana",
+  NE: "Nebraska",
+  NV: "Nevada",
+  NH: "New Hampshire",
+  NJ: "New Jersey",
+  NM: "New Mexico",
+  NY: "New York",
+  NC: "North Carolina",
+  ND: "North Dakota",
+  OH: "Ohio",
+  OK: "Oklahoma",
+  OR: "Oregon",
+  PA: "Pennsylvania",
+  RI: "Rhode Island",
+  SC: "South Carolina",
+  SD: "South Dakota",
+  TN: "Tennessee",
+  TX: "Texas",
+  UT: "Utah",
+  VT: "Vermont",
+  VA: "Virginia",
+  WA: "Washington",
+  WV: "West Virginia",
+  WI: "Wisconsin",
+  WY: "Wyoming",
+  // Territories
+  DC: "District of Columbia",
+  PR: "Puerto Rico",
+  GU: "Guam",
+  VI: "United States Virgin Islands",
+  AS: "American Samoa",
+  MP: "Northern Mariana Islands"
+};
+var STATUS = {
+  PENDING: "PENDING",
+  IN_PROGRESS: "IN_PROGRESS",
+  COMPLETED: "COMPLETED",
+  OVERDUE: "OVERDUE",
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE"
+};
+var SEVERITY = {
+  LOW: "LOW",
+  MEDIUM: "MEDIUM",
+  HIGH: "HIGH"
+};
+var SERVICE_TYPES = {
+  PROPERTY: "PROPERTY",
+  CLEANING: "CLEANING",
+  MAINTENANCE: "MAINTENANCE",
+  INSPECTION: "INSPECTION",
+  OTHER: "OTHER"
+};
+var MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var WEEK_DAY = {
+  Sunday: "Sunday",
+  Monday: "Monday",
+  Tuesday: "Tuesday",
+  Wednesday: "Wednesday",
+  Thursday: "Thursday",
+  Friday: "Friday",
+  Saturday: "Saturday"
+};
+var WEEK_DAY_SHORT_LABEL = {
+  Sunday: "Sun",
+  Monday: "Mon",
+  Tuesday: "Tue",
+  Wednesday: "Wed",
+  Thursday: "Thu",
+  Friday: "Fri",
+  Saturday: "Sat"
+};
+var WEEK_DAY_LETTER = {
+  Sunday: "S",
+  Monday: "M",
+  Tuesday: "T",
+  Wednesday: "W",
+  Thursday: "T",
+  Friday: "F",
+  Saturday: "S"
+};
+var createSelectOptions = (values) => values.map((value) => ({
+  label: value,
+  value
+}));
+var getRecordValues = (record) => Object.values(record);
+var UnitedStatesJurisdictionOptions = createSelectOptions(
+  getRecordValues(US_JURISDICTIONS)
+);
+var StatusOptions = [
+  { label: "Pending", value: STATUS.PENDING },
+  { label: "In Progress", value: STATUS.IN_PROGRESS },
+  { label: "Completed", value: STATUS.COMPLETED },
+  { label: "Overdue", value: STATUS.OVERDUE },
+  { label: "Active", value: STATUS.ACTIVE },
+  { label: "Inactive", value: STATUS.INACTIVE }
+];
+var SeverityOptions = [
+  { label: "Low", value: SEVERITY.LOW },
+  { label: "Medium", value: SEVERITY.MEDIUM },
+  { label: "High", value: SEVERITY.HIGH }
+];
+var ServiceTypeOptions = [
+  { label: "Property", value: SERVICE_TYPES.PROPERTY },
+  { label: "Cleaning", value: SERVICE_TYPES.CLEANING },
+  { label: "Maintenance", value: SERVICE_TYPES.MAINTENANCE },
+  { label: "Inspection", value: SERVICE_TYPES.INSPECTION },
+  { label: "Other", value: SERVICE_TYPES.OTHER }
+];
+
+// src/types/company/constants.ts
+var COMPANY_RELATIONSHIP_STATUS = {
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE",
+  SUSPENDED: "SUSPENDED"
+};
+var INVITATION_STATUS = {
+  PENDING: "PENDING",
+  ACCEPTED: "ACCEPTED",
+  EXPIRED: "EXPIRED",
+  REVOKED: "REVOKED",
+  DECLINED: "DECLINED"
+};
+var COMPANY_TYPES = {
+  PROPERTY_MANAGEMENT: "PROPERTY_MANAGEMENT",
+  MAINTENANCE: "MAINTENANCE",
+  CLEANER: "CLEANER",
+  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",
+  MEDIUM: "MEDIUM",
+  HIGH: "HIGH",
+  CRITICAL: "CRITICAL"
+};
+var DAMAGE_STATUS = {
+  OPEN: "OPEN",
+  IN_REVIEW: "IN_REVIEW",
+  ASSIGNED: "ASSIGNED",
+  IN_PROGRESS: "IN_PROGRESS",
+  RESOLVED: "RESOLVED",
+  CLOSED: "CLOSED",
+  ESCALATED: "ESCALATED"
+};
+var WORK_ORDER_PRIORITY = {
+  LOW: "LOW",
+  NORMAL: "NORMAL",
+  HIGH: "HIGH",
+  URGENT: "URGENT"
+};
+var WORK_ORDER_STATUS = {
+  PENDING: "PENDING",
+  SCHEDULED: "SCHEDULED",
+  IN_PROGRESS: "IN_PROGRESS",
+  COMPLETED: "COMPLETED",
+  CANCELLED: "CANCELLED"
+};
+
+// src/types/errors/index.ts
+var isErrorLike = (error) => {
+  return typeof error === "object" && error !== null;
+};
+function isValidationError(error) {
+  return isErrorLike(error) && error.code === ERROR_CODES.VALIDATION_ERROR && Array.isArray(error.details);
+}
+function isMissingFieldsError(error) {
+  return isErrorLike(error) && error.code === ERROR_CODES.MISSING_FIELDS && typeof error.details === "object" && error.details !== null && "missingFields" in error.details && Array.isArray(error.details.missingFields);
+}
+function isRateLimitError(error) {
+  return isErrorLike(error) && error.code === ERROR_CODES.RATE_LIMIT_EXCEEDED;
+}
+function isAuthError(error) {
+  return isErrorLike(error) && (error.code === ERROR_CODES.UNAUTHORIZED || error.code === ERROR_CODES.INVALID_TOKEN || error.code === ERROR_CODES.INVALID_CREDENTIALS);
+}
+
+// src/types/health/index.ts
+var SERVER_STATUS = {
+  Healthy: "Healthy",
+  Unhealthy: "UnHealthy"
+};
+var DATABASE_STATUS = {
+  Unknown: "Unknown",
+  Connected: "Connected",
+  Disconnected: "Disconnected"
+};
+
+// src/types/image/index.ts
+var IMAGE_ENTITY_TYPE = {
+  USER_PROFILE: "USER_PROFILE",
+  PROPERTY: "PROPERTY",
+  COMPANY: "COMPANY",
+  CHECKLIST_ITEM: "CHECKLIST_ITEM",
+  PROPERTY_ROOM: "PROPERTY_ROOM",
+  MAINTENANCE_TICKET: "MAINTENANCE_TICKET",
+  WORK_REPORT: "WORK_REPORT",
+  CLEANING_REPORT: "CLEANING_REPORT",
+  TURNDOWN_DEFAULT: "TURNDOWN_DEFAULT"
+};
+
+// src/types/inventory/index.ts
+var INVENTORY_RESTOCK_ORDER_STATUS = {
+  PENDING: "PENDING",
+  ORDERED: "ORDERED",
+  SHIPPED: "SHIPPED",
+  RECEIVED: "RECEIVED"
+};
+var INVENTORY_UNITS = {
+  COUNT: "COUNT",
+  ROLLS: "ROLLS",
+  PODS: "PODS",
+  BOXES: "BOXES",
+  BOTTLES: "BOTTLES",
+  PACKS: "PACKS",
+  BAGS: "BAGS",
+  GALLONS: "GALLONS",
+  LITERS: "LITERS",
+  KILOGRAMS: "KILOGRAMS",
+  POUNDS: "POUNDS",
+  OUNCES: "OUNCES",
+  GRAMS: "GRAMS",
+  SHEETS: "SHEETS",
+  CASES: "CASES",
+  CARTONS: "CARTONS",
+  OTHER: "OTHER"
+};
+var INVENTORY_ITEM_TYPE = {
+  CONSUMABLE: "CONSUMABLE",
+  FIXED: "FIXED"
+};
+
+// src/types/property/constants.ts
+var PROPERTY_STATUS = {
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE"
+};
+var PropertyStatusOptions = [
+  {
+    label: "Active",
+    value: PROPERTY_STATUS.ACTIVE
+  },
+  {
+    label: "Inactive",
+    value: PROPERTY_STATUS.INACTIVE
+  }
+];
+var PROPERTY_TYPES = {
+  APARTMENT: "APARTMENT",
+  COMMERCIAL: "COMMERCIAL",
+  CONDO: "CONDO",
+  DUPLEX: "DUPLEX",
+  HOUSE: "HOUSE",
+  MULTI_FAMILY: "MULTI_FAMILY",
+  OFFICE: "OFFICE",
+  RETAIL: "RETAIL",
+  TOWNHOUSE: "TOWNHOUSE",
+  VACATION_RENTAL: "VACATION_RENTAL",
+  WAREHOUSE: "WAREHOUSE"
+};
+var PropertyTypeOptions = [
+  {
+    label: "Apartment",
+    value: PROPERTY_TYPES.APARTMENT
+  },
+  {
+    label: "Commercial",
+    value: PROPERTY_TYPES.COMMERCIAL
+  },
+  {
+    label: "Condo",
+    value: PROPERTY_TYPES.CONDO
+  },
+  {
+    label: "Duplex",
+    value: PROPERTY_TYPES.DUPLEX
+  },
+  {
+    label: "House",
+    value: PROPERTY_TYPES.HOUSE
+  },
+  {
+    label: "Multi-Family",
+    value: PROPERTY_TYPES.MULTI_FAMILY
+  },
+  {
+    label: "Office",
+    value: PROPERTY_TYPES.OFFICE
+  },
+  {
+    label: "Retail",
+    value: PROPERTY_TYPES.RETAIL
+  },
+  {
+    label: "Townhouse",
+    value: PROPERTY_TYPES.TOWNHOUSE
+  },
+  {
+    label: "Vacation Rental",
+    value: PROPERTY_TYPES.VACATION_RENTAL
+  },
+  {
+    label: "Warehouse",
+    value: PROPERTY_TYPES.WAREHOUSE
+  }
+];
+
+// 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",
+  KITCHEN: "KITCHEN",
+  LIVING_ROOM: "LIVING_ROOM",
+  DINING_ROOM: "DINING_ROOM",
+  OFFICE: "OFFICE",
+  GARAGE: "GARAGE",
+  LAUNDRY_ROOM: "LAUNDRY_ROOM",
+  BASEMENT: "BASEMENT",
+  ATTIC: "ATTIC",
+  BALCONY: "BALCONY",
+  PORCH: "PORCH",
+  GARDEN: "GARDEN",
+  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",
+  CANCELED: "CANCELED",
+  EXPIRED: "EXPIRED",
+  PAST_DUE: "PAST_DUE",
+  TRIALING: "TRIALING"
+};
+var SUBSCRIPTION_PROVIDER = {
+  STRIPE: "STRIPE",
+  APPLE: "APPLE",
+  GOOGLE: "GOOGLE"
+};
+var BILLING_PERIOD = {
+  MONTHLY: "MONTHLY",
+  YEARLY: "YEARLY"
+};
+
+// 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 = {
+  IN_PROGRESS: "IN_PROGRESS",
+  COMPLETED: "COMPLETED",
+  CANCELLED: "CANCELLED"
+};
+var CHECKLIST_EXECUTION_STATUS = {
+  PENDING: "PENDING",
+  IN_PROGRESS: "IN_PROGRESS",
+  COMPLETED: "COMPLETED",
+  SKIPPED: "SKIPPED"
+};
+//# sourceMappingURL=index.cjs.map