@wasto/sdk 1.0.3

package/dist/index.js

@@ -0,0 +1,2566 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AssetEventType: () => AssetEventType,
+  AssetStatus: () => AssetStatus,
+  AssetType: () => AssetType,
+  BookingStatus: () => BookingStatus,
+  CITEO_DOM_MULTIPLIERS: () => CITEO_DOM_MULTIPLIERS,
+  CalendoEventStatus: () => CalendoEventStatus,
+  CalendoEventType: () => CalendoEventType,
+  CalendoTicketSaleStatus: () => CalendoTicketSaleStatus,
+  ChatMessageRole: () => ChatMessageRole,
+  ChatStatus: () => ChatStatus,
+  CityGroupType: () => CityGroupType,
+  CityStatus: () => CityStatus,
+  CmsMenuLinkType: () => CmsMenuLinkType,
+  CmsSiteType: () => CmsSiteType,
+  DASHBOARD_APPS: () => DASHBOARD_APPS,
+  DASHBOARD_APP_BY_KEY: () => DASHBOARD_APP_BY_KEY,
+  DASHBOARD_APP_BY_SLUG: () => DASHBOARD_APP_BY_SLUG,
+  DEFAULT_ENABLED_DASHBOARD_APP_SLUGS: () => DEFAULT_ENABLED_DASHBOARD_APP_SLUGS,
+  DEFAULT_PAGE: () => DEFAULT_PAGE,
+  DEFAULT_PAGE_SIZE: () => DEFAULT_PAGE_SIZE,
+  DOM_INSEE_PREFIXES: () => DOM_INSEE_PREFIXES,
+  DashboardAppSlug: () => DashboardAppSlug,
+  FREE_SELF_SERVE_DASHBOARD_APP_SLUGS: () => FREE_SELF_SERVE_DASHBOARD_APP_SLUGS,
+  FREE_TIER_FEATURES: () => FREE_TIER_FEATURES,
+  FREE_TIER_FEATURE_KEYS: () => FREE_TIER_FEATURE_KEYS,
+  FREE_TIER_LIMITS: () => FREE_TIER_LIMITS,
+  FREE_TIER_RESOURCES: () => FREE_TIER_RESOURCES,
+  FieldReportFormStatus: () => FieldReportFormStatus,
+  FieldReportStatus: () => FieldReportStatus,
+  InterventionStatus: () => InterventionStatus,
+  InterventionType: () => InterventionType,
+  MAX_PAGE_SIZE: () => MAX_PAGE_SIZE,
+  MapEventStatus: () => MapEventStatus,
+  MapEventType: () => MapEventType,
+  MapPoiCategory: () => MapPoiCategory,
+  MapPoiStatus: () => MapPoiStatus,
+  MapZoneType: () => MapZoneType,
+  NotificationDeliveryStatus: () => NotificationDeliveryStatus,
+  NotificationStatus: () => NotificationStatus,
+  ONBOARDING_RESTRICTED_APP_SLUGS: () => ONBOARDING_RESTRICTED_APP_SLUGS,
+  OperationalZoneStatus: () => OperationalZoneStatus,
+  OperationalZoneType: () => OperationalZoneType,
+  PRESET_SLOTS: () => PRESET_SLOTS,
+  PermissionAction: () => PermissionAction,
+  PermissionResource: () => PermissionResource,
+  ProviderType: () => ProviderType,
+  QuestionType: () => QuestionType,
+  ROI_DEFAULTS: () => ROI_DEFAULTS,
+  ROI_DISCLAIMER: () => ROI_DISCLAIMER,
+  ROI_SCENARIO_DEFS: () => ROI_SCENARIO_DEFS,
+  RecipientGroupType: () => RecipientGroupType,
+  ResponseStatus: () => ResponseStatus,
+  SurveyMode: () => SurveyMode,
+  SurveyStatus: () => SurveyStatus,
+  TGAP_LANDFILL_EUR_PER_TONNE: () => TGAP_LANDFILL_EUR_PER_TONNE,
+  TerritoryActionStatus: () => TerritoryActionStatus,
+  TerritoryActionType: () => TerritoryActionType,
+  TicketFormStatus: () => TicketFormStatus,
+  TicketStatus: () => TicketStatus,
+  UserRole: () => UserRole,
+  WASTO_LANDINGS_DOMAIN: () => WASTO_LANDINGS_DOMAIN,
+  WASTO_LANDINGS_INDEX_HOST: () => WASTO_LANDINGS_INDEX_HOST,
+  WASTO_RESERVED_SUBDOMAINS: () => WASTO_RESERVED_SUBDOMAINS,
+  WASTO_SECTIONS: () => WASTO_SECTIONS,
+  WASTO_SECTION_BY_KEY: () => WASTO_SECTION_BY_KEY,
+  WEEKDAYS: () => WEEKDAYS,
+  WEEKDAY_INDEX: () => WEEKDAY_INDEX,
+  WEEKDAY_LABELS_FR: () => WEEKDAY_LABELS_FR,
+  WEEKDAY_LABELS_FR_SHORT: () => WEEKDAY_LABELS_FR_SHORT,
+  WEEKDAY_REF_DATES: () => WEEKDAY_REF_DATES,
+  WastoApiError: () => WastoApiError,
+  addDaysToIsoDate: () => addDaysToIsoDate,
+  adjustCostPerBadTonneForTgap: () => adjustCostPerBadTonneForTgap,
+  allocateSavingsByAction: () => allocateSavingsByAction,
+  applyCiteoDomMultiplier: () => applyCiteoDomMultiplier,
+  applyStackedErrorReductions: () => applyStackedErrorReductions,
+  buildBauVsRealSeries: () => buildBauVsRealSeries,
+  buildPaginationMeta: () => buildPaginationMeta,
+  computeActionImpactConfidence: () => computeActionImpactConfidence,
+  computeGec: () => computeGec,
+  computeOverallConfidence: () => computeOverallConfidence,
+  computePenetrationRate: () => computePenetrationRate,
+  computeRoiIndicators: () => computeRoiIndicators,
+  convertLocalToUtc: () => convertLocalToUtc,
+  convertUtcToLocal: () => convertUtcToLocal,
+  createEmptyLocalRules: () => createEmptyLocalRules,
+  createEmptyOpeningHours: () => createEmptyOpeningHours,
+  createWastoClient: () => createWastoClient,
+  currentFiscalYear: () => currentFiscalYear,
+  dashboardAppKeyFromLandingHost: () => dashboardAppKeyFromLandingHost,
+  dashboardAppKeyToSlug: () => dashboardAppKeyToSlug,
+  dashboardAppSlugToKey: () => dashboardAppSlugToKey,
+  detectDomTerritory: () => detectDomTerritory,
+  estimateHouseholds: () => estimateHouseholds,
+  formatOpeningHoursSummary: () => formatOpeningHoursSummary,
+  formatOpeningHoursWeekly: () => formatOpeningHoursWeekly,
+  formatTimeDisplay: () => formatTimeDisplay,
+  formatTimeMinutes: () => formatTimeMinutes,
+  formatWeeklyRow: () => formatWeeklyRow,
+  getBrowserTimeZone: () => getBrowserTimeZone,
+  getFreeTierLimit: () => getFreeTierLimit,
+  getFreeTierMediaBytesLimit: () => getFreeTierMediaBytesLimit,
+  getTgapEurPerTonne: () => getTgapEurPerTonne,
+  getTimezoneOffsetMinutes: () => getTimezoneOffsetMinutes,
+  isActionCountedInRoi: () => isActionCountedInRoi,
+  isDashboardAppLandingHost: () => isDashboardAppLandingHost,
+  isDomInseeCode: () => isDomInseeCode,
+  isFreeSelfServeAppAccess: () => isFreeSelfServeAppAccess,
+  isFreeTierFeatureEnabled: () => isFreeTierFeatureEnabled,
+  isOpenNow: () => isOpenNow,
+  localDateTimeToUtc: () => localDateTimeToUtc,
+  localRulesFromRange: () => localRulesFromRange,
+  nextWeekday: () => nextWeekday,
+  normalizeDashboardAppSlug: () => normalizeDashboardAppSlug,
+  openNowLabel: () => openNowLabel,
+  parseTimeMinutes: () => parseTimeMinutes,
+  refDateForWeekday: () => refDateForWeekday,
+  resolveDashboardAppLandingUrl: () => resolveDashboardAppLandingUrl,
+  resolveEnabledDashboardAppSlugs: () => resolveEnabledDashboardAppSlugs,
+  resolveHoursDisplay: () => resolveHoursDisplay,
+  resolveHoursMode: () => resolveHoursMode,
+  resolveHoursModeFromPoint: () => resolveHoursModeFromPoint,
+  resolveHoursText: () => resolveHoursText,
+  resolveOpeningHoursLocal: () => resolveOpeningHoursLocal,
+  resolveOpeningHoursUtc: () => resolveOpeningHoursUtc,
+  resolveWastoLandingsIndexUrl: () => resolveWastoLandingsIndexUrl,
+  roundEuro: () => roundEuro,
+  simulateTerritory100kExample: () => simulateTerritory100kExample,
+  slotsOverlap: () => slotsOverlap,
+  sortSlots: () => sortSlots,
+  utcDateIso: () => utcDateIso,
+  utcHhmmFromDate: () => utcHhmmFromDate,
+  validateLocalOpeningHours: () => validateLocalOpeningHours,
+  validateOpeningHours: () => validateOpeningHours,
+  weekdayFromUtcDate: () => weekdayFromUtcDate
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/enums.ts
+var UserRole = /* @__PURE__ */ ((UserRole2) => {
+  UserRole2["ADMIN"] = "ADMIN";
+  UserRole2["GESTIONNAIRE_COLLECTIVITE"] = "GESTIONNAIRE_COLLECTIVITE";
+  UserRole2["USER"] = "USER";
+  return UserRole2;
+})(UserRole || {});
+var CityGroupType = /* @__PURE__ */ ((CityGroupType2) => {
+  CityGroupType2["AGGLOMERATION"] = "AGGLOMERATION";
+  CityGroupType2["COMMUNAUTE"] = "COMMUNAUTE";
+  CityGroupType2["METROPOLE"] = "METROPOLE";
+  CityGroupType2["SYNDICAT"] = "SYNDICAT";
+  CityGroupType2["AUTRE"] = "AUTRE";
+  return CityGroupType2;
+})(CityGroupType || {});
+var CityStatus = /* @__PURE__ */ ((CityStatus2) => {
+  CityStatus2["NON_ACTIF"] = "NON_ACTIF";
+  CityStatus2["INCOMPLET"] = "INCOMPLET";
+  CityStatus2["ACTIF"] = "ACTIF";
+  CityStatus2["MAINTENANCE"] = "MAINTENANCE";
+  return CityStatus2;
+})(CityStatus || {});
+var RecipientGroupType = /* @__PURE__ */ ((RecipientGroupType2) => {
+  RecipientGroupType2["CITY"] = "CITY";
+  RecipientGroupType2["CITY_GROUP"] = "CITY_GROUP";
+  RecipientGroupType2["ZONE"] = "ZONE";
+  return RecipientGroupType2;
+})(RecipientGroupType || {});
+var NotificationStatus = /* @__PURE__ */ ((NotificationStatus2) => {
+  NotificationStatus2["DRAFT"] = "DRAFT";
+  NotificationStatus2["SCHEDULED"] = "SCHEDULED";
+  NotificationStatus2["SENT"] = "SENT";
+  NotificationStatus2["ARCHIVED"] = "ARCHIVED";
+  return NotificationStatus2;
+})(NotificationStatus || {});
+var NotificationDeliveryStatus = /* @__PURE__ */ ((NotificationDeliveryStatus2) => {
+  NotificationDeliveryStatus2["PENDING"] = "PENDING";
+  NotificationDeliveryStatus2["SENT"] = "SENT";
+  NotificationDeliveryStatus2["FAILED"] = "FAILED";
+  return NotificationDeliveryStatus2;
+})(NotificationDeliveryStatus || {});
+var CmsSiteType = /* @__PURE__ */ ((CmsSiteType2) => {
+  CmsSiteType2["SITE"] = "SITE";
+  CmsSiteType2["APP"] = "APP";
+  return CmsSiteType2;
+})(CmsSiteType || {});
+var CmsMenuLinkType = /* @__PURE__ */ ((CmsMenuLinkType2) => {
+  CmsMenuLinkType2["PAGE"] = "PAGE";
+  CmsMenuLinkType2["EXTERNAL"] = "EXTERNAL";
+  CmsMenuLinkType2["COMPONENT"] = "COMPONENT";
+  return CmsMenuLinkType2;
+})(CmsMenuLinkType || {});
+var ChatMessageRole = /* @__PURE__ */ ((ChatMessageRole2) => {
+  ChatMessageRole2["USER"] = "USER";
+  ChatMessageRole2["ASSISTANT"] = "ASSISTANT";
+  ChatMessageRole2["AGENT"] = "AGENT";
+  return ChatMessageRole2;
+})(ChatMessageRole || {});
+var ChatStatus = /* @__PURE__ */ ((ChatStatus2) => {
+  ChatStatus2["OPEN"] = "OPEN";
+  ChatStatus2["WAITING_AGENT"] = "WAITING_AGENT";
+  ChatStatus2["RESOLVED"] = "RESOLVED";
+  ChatStatus2["CLOSED"] = "CLOSED";
+  return ChatStatus2;
+})(ChatStatus || {});
+var PermissionAction = /* @__PURE__ */ ((PermissionAction2) => {
+  PermissionAction2["READ"] = "READ";
+  PermissionAction2["WRITE"] = "WRITE";
+  return PermissionAction2;
+})(PermissionAction || {});
+var PermissionResource = /* @__PURE__ */ ((PermissionResource2) => {
+  PermissionResource2["USERS"] = "USERS";
+  PermissionResource2["CITIES"] = "CITIES";
+  PermissionResource2["CITY_GROUPS"] = "CITY_GROUPS";
+  PermissionResource2["BLOG_POSTS"] = "BLOG_POSTS";
+  PermissionResource2["CHALLENGES"] = "CHALLENGES";
+  PermissionResource2["SERIES"] = "SERIES";
+  PermissionResource2["BADGES"] = "BADGES";
+  PermissionResource2["NOTIFICATIONS"] = "NOTIFICATIONS";
+  PermissionResource2["RECIPIENT_GROUPS"] = "RECIPIENT_GROUPS";
+  PermissionResource2["WASTE_TYPES"] = "WASTE_TYPES";
+  PermissionResource2["WASTE_COLLECTION_PLACES"] = "WASTE_COLLECTION_PLACES";
+  PermissionResource2["RECYCLING_POINTS"] = "RECYCLING_POINTS";
+  PermissionResource2["QUIZ_QUESTIONS"] = "QUIZ_QUESTIONS";
+  PermissionResource2["CHAT_CONVERSATIONS"] = "CHAT_CONVERSATIONS";
+  PermissionResource2["ANALYTICS"] = "ANALYTICS";
+  PermissionResource2["ASSETS"] = "ASSETS";
+  PermissionResource2["IOT_DEVICES"] = "IOT_DEVICES";
+  PermissionResource2["SURVEYS"] = "SURVEYS";
+  PermissionResource2["TICKETS"] = "TICKETS";
+  PermissionResource2["TICKET_FORMS"] = "TICKET_FORMS";
+  PermissionResource2["PROVIDERS"] = "PROVIDERS";
+  PermissionResource2["CMS_SITES"] = "CMS_SITES";
+  PermissionResource2["CMS_PAGES"] = "CMS_PAGES";
+  PermissionResource2["CMS_MEDIA"] = "CMS_MEDIA";
+  PermissionResource2["CALENDO_EVENTS"] = "CALENDO_EVENTS";
+  PermissionResource2["MAPSO_EVENTS"] = "MAPSO_EVENTS";
+  PermissionResource2["FIELD_REPORTS"] = "FIELD_REPORTS";
+  return PermissionResource2;
+})(PermissionResource || {});
+var TerritoryActionType = /* @__PURE__ */ ((TerritoryActionType2) => {
+  TerritoryActionType2["AWARENESS"] = "AWARENESS";
+  TerritoryActionType2["CONTROLS"] = "CONTROLS";
+  TerritoryActionType2["EQUIPMENT"] = "EQUIPMENT";
+  TerritoryActionType2["WASTO_APP"] = "WASTO_APP";
+  TerritoryActionType2["TRAINING"] = "TRAINING";
+  TerritoryActionType2["OTHER"] = "OTHER";
+  return TerritoryActionType2;
+})(TerritoryActionType || {});
+var TerritoryActionStatus = /* @__PURE__ */ ((TerritoryActionStatus2) => {
+  TerritoryActionStatus2["PLANNED"] = "PLANNED";
+  TerritoryActionStatus2["IN_PROGRESS"] = "IN_PROGRESS";
+  TerritoryActionStatus2["COMPLETED"] = "COMPLETED";
+  TerritoryActionStatus2["CANCELLED"] = "CANCELLED";
+  return TerritoryActionStatus2;
+})(TerritoryActionStatus || {});
+var AssetType = /* @__PURE__ */ ((AssetType2) => {
+  AssetType2["BENNE"] = "BENNE";
+  AssetType2["BORNE_VERRE"] = "BORNE_VERRE";
+  AssetType2["BORNE_TEMPORAIRE"] = "BORNE_TEMPORAIRE";
+  AssetType2["EPHEMERE"] = "EPHEMERE";
+  AssetType2["LOCATION"] = "LOCATION";
+  AssetType2["VEHICULE"] = "VEHICULE";
+  AssetType2["CAMION"] = "CAMION";
+  return AssetType2;
+})(AssetType || {});
+var AssetStatus = /* @__PURE__ */ ((AssetStatus2) => {
+  AssetStatus2["DISPONIBLE"] = "DISPONIBLE";
+  AssetStatus2["EN_LOCATION"] = "EN_LOCATION";
+  AssetStatus2["EN_MAINTENANCE"] = "EN_MAINTENANCE";
+  AssetStatus2["HORS_SERVICE"] = "HORS_SERVICE";
+  return AssetStatus2;
+})(AssetStatus || {});
+var BookingStatus = /* @__PURE__ */ ((BookingStatus2) => {
+  BookingStatus2["PENDING"] = "PENDING";
+  BookingStatus2["CONFIRMED"] = "CONFIRMED";
+  BookingStatus2["CANCELLED"] = "CANCELLED";
+  return BookingStatus2;
+})(BookingStatus || {});
+var SurveyStatus = /* @__PURE__ */ ((SurveyStatus2) => {
+  SurveyStatus2["DRAFT"] = "DRAFT";
+  SurveyStatus2["ACTIVE"] = "ACTIVE";
+  SurveyStatus2["ARCHIVED"] = "ARCHIVED";
+  return SurveyStatus2;
+})(SurveyStatus || {});
+var SurveyMode = /* @__PURE__ */ ((SurveyMode2) => {
+  SurveyMode2["FIELD"] = "FIELD";
+  SurveyMode2["ONLINE"] = "ONLINE";
+  SurveyMode2["PHONE"] = "PHONE";
+  return SurveyMode2;
+})(SurveyMode || {});
+var QuestionType = /* @__PURE__ */ ((QuestionType2) => {
+  QuestionType2["TEXT"] = "TEXT";
+  QuestionType2["NUMBER"] = "NUMBER";
+  QuestionType2["CHOICE"] = "CHOICE";
+  QuestionType2["MULTIPLE_CHOICE"] = "MULTIPLE_CHOICE";
+  QuestionType2["RATING"] = "RATING";
+  QuestionType2["DATE"] = "DATE";
+  QuestionType2["LOCATION"] = "LOCATION";
+  QuestionType2["PHOTO"] = "PHOTO";
+  QuestionType2["YES_NO"] = "YES_NO";
+  return QuestionType2;
+})(QuestionType || {});
+var ResponseStatus = /* @__PURE__ */ ((ResponseStatus2) => {
+  ResponseStatus2["DRAFT"] = "DRAFT";
+  ResponseStatus2["SUBMITTED"] = "SUBMITTED";
+  ResponseStatus2["SYNCED"] = "SYNCED";
+  return ResponseStatus2;
+})(ResponseStatus || {});
+var TicketFormStatus = /* @__PURE__ */ ((TicketFormStatus2) => {
+  TicketFormStatus2["DRAFT"] = "DRAFT";
+  TicketFormStatus2["ACTIVE"] = "ACTIVE";
+  TicketFormStatus2["ARCHIVED"] = "ARCHIVED";
+  return TicketFormStatus2;
+})(TicketFormStatus || {});
+var TicketStatus = /* @__PURE__ */ ((TicketStatus2) => {
+  TicketStatus2["OUVERT"] = "OUVERT";
+  TicketStatus2["EN_COURS"] = "EN_COURS";
+  TicketStatus2["RESOLU"] = "RESOLU";
+  TicketStatus2["FERME"] = "FERME";
+  return TicketStatus2;
+})(TicketStatus || {});
+var FieldReportFormStatus = /* @__PURE__ */ ((FieldReportFormStatus2) => {
+  FieldReportFormStatus2["DRAFT"] = "DRAFT";
+  FieldReportFormStatus2["ACTIVE"] = "ACTIVE";
+  FieldReportFormStatus2["ARCHIVED"] = "ARCHIVED";
+  return FieldReportFormStatus2;
+})(FieldReportFormStatus || {});
+var FieldReportStatus = /* @__PURE__ */ ((FieldReportStatus2) => {
+  FieldReportStatus2["OUVERT"] = "OUVERT";
+  FieldReportStatus2["EN_COURS"] = "EN_COURS";
+  FieldReportStatus2["RESOLU"] = "RESOLU";
+  FieldReportStatus2["FERME"] = "FERME";
+  return FieldReportStatus2;
+})(FieldReportStatus || {});
+var ProviderType = /* @__PURE__ */ ((ProviderType2) => {
+  ProviderType2["LOCATION_ASSETS"] = "LOCATION_ASSETS";
+  ProviderType2["ANIMATION_CHALLENGE"] = "ANIMATION_CHALLENGE";
+  ProviderType2["MAINTENANCE"] = "MAINTENANCE";
+  ProviderType2["AUTRE"] = "AUTRE";
+  return ProviderType2;
+})(ProviderType || {});
+var InterventionType = /* @__PURE__ */ ((InterventionType2) => {
+  InterventionType2["MAINTENANCE"] = "MAINTENANCE";
+  InterventionType2["INDISPO"] = "INDISPO";
+  InterventionType2["CONTROLE"] = "CONTROLE";
+  InterventionType2["OTHER"] = "OTHER";
+  return InterventionType2;
+})(InterventionType || {});
+var InterventionStatus = /* @__PURE__ */ ((InterventionStatus2) => {
+  InterventionStatus2["PLANNED"] = "PLANNED";
+  InterventionStatus2["IN_PROGRESS"] = "IN_PROGRESS";
+  InterventionStatus2["DONE"] = "DONE";
+  InterventionStatus2["CANCELLED"] = "CANCELLED";
+  return InterventionStatus2;
+})(InterventionStatus || {});
+var AssetEventType = /* @__PURE__ */ ((AssetEventType2) => {
+  AssetEventType2["LOCATION_CHANGE"] = "LOCATION_CHANGE";
+  AssetEventType2["STATUS_CHANGE"] = "STATUS_CHANGE";
+  AssetEventType2["MAINTENANCE"] = "MAINTENANCE";
+  AssetEventType2["INSPECTION"] = "INSPECTION";
+  AssetEventType2["OTHER"] = "OTHER";
+  return AssetEventType2;
+})(AssetEventType || {});
+var CalendoEventType = /* @__PURE__ */ ((CalendoEventType2) => {
+  CalendoEventType2["CONCERT"] = "CONCERT";
+  CalendoEventType2["ANIMATION"] = "ANIMATION";
+  CalendoEventType2["EXPOSITION"] = "EXPOSITION";
+  CalendoEventType2["OTHER"] = "OTHER";
+  return CalendoEventType2;
+})(CalendoEventType || {});
+var CalendoEventStatus = /* @__PURE__ */ ((CalendoEventStatus2) => {
+  CalendoEventStatus2["DRAFT"] = "DRAFT";
+  CalendoEventStatus2["PUBLISHED"] = "PUBLISHED";
+  CalendoEventStatus2["CANCELLED"] = "CANCELLED";
+  CalendoEventStatus2["SOLD_OUT"] = "SOLD_OUT";
+  return CalendoEventStatus2;
+})(CalendoEventStatus || {});
+var CalendoTicketSaleStatus = /* @__PURE__ */ ((CalendoTicketSaleStatus2) => {
+  CalendoTicketSaleStatus2["CONFIRMED"] = "CONFIRMED";
+  CalendoTicketSaleStatus2["CANCELLED"] = "CANCELLED";
+  CalendoTicketSaleStatus2["REFUNDED"] = "REFUNDED";
+  return CalendoTicketSaleStatus2;
+})(CalendoTicketSaleStatus || {});
+var MapEventType = /* @__PURE__ */ ((MapEventType2) => {
+  MapEventType2["FAIR"] = "FAIR";
+  MapEventType2["MARKET"] = "MARKET";
+  MapEventType2["FESTIVAL"] = "FESTIVAL";
+  MapEventType2["PERMANENT"] = "PERMANENT";
+  MapEventType2["OTHER"] = "OTHER";
+  return MapEventType2;
+})(MapEventType || {});
+var MapEventStatus = /* @__PURE__ */ ((MapEventStatus2) => {
+  MapEventStatus2["DRAFT"] = "DRAFT";
+  MapEventStatus2["PUBLISHED"] = "PUBLISHED";
+  MapEventStatus2["ARCHIVED"] = "ARCHIVED";
+  return MapEventStatus2;
+})(MapEventStatus || {});
+var MapPoiCategory = /* @__PURE__ */ ((MapPoiCategory2) => {
+  MapPoiCategory2["ATTRACTION_STAND"] = "ATTRACTION_STAND";
+  MapPoiCategory2["TOILET"] = "TOILET";
+  MapPoiCategory2["SECURITY"] = "SECURITY";
+  MapPoiCategory2["FOOD"] = "FOOD";
+  MapPoiCategory2["WATER_FOUNTAIN"] = "WATER_FOUNTAIN";
+  MapPoiCategory2["WASTO_RECYCLING"] = "WASTO_RECYCLING";
+  MapPoiCategory2["WASTO_BIOWASTE"] = "WASTO_BIOWASTE";
+  MapPoiCategory2["WASTO_RETURN"] = "WASTO_RETURN";
+  MapPoiCategory2["TRAVAUX"] = "TRAVAUX";
+  return MapPoiCategory2;
+})(MapPoiCategory || {});
+var MapZoneType = /* @__PURE__ */ ((MapZoneType2) => {
+  MapZoneType2["PARKING_PROVISOIRE"] = "PARKING_PROVISOIRE";
+  MapZoneType2["ZONE_INTERDITE"] = "ZONE_INTERDITE";
+  MapZoneType2["AUTRE"] = "AUTRE";
+  return MapZoneType2;
+})(MapZoneType || {});
+var MapPoiStatus = /* @__PURE__ */ ((MapPoiStatus2) => {
+  MapPoiStatus2["ACTIVE"] = "ACTIVE";
+  MapPoiStatus2["MAINTENANCE"] = "MAINTENANCE";
+  MapPoiStatus2["CLOSED"] = "CLOSED";
+  return MapPoiStatus2;
+})(MapPoiStatus || {});
+var OperationalZoneType = /* @__PURE__ */ ((OperationalZoneType2) => {
+  OperationalZoneType2["TRAVAUX"] = "TRAVAUX";
+  OperationalZoneType2["PARKING_PROVISOIRE"] = "PARKING_PROVISOIRE";
+  OperationalZoneType2["ZONE_INTERDITE"] = "ZONE_INTERDITE";
+  OperationalZoneType2["AUTRE"] = "AUTRE";
+  return OperationalZoneType2;
+})(OperationalZoneType || {});
+var OperationalZoneStatus = /* @__PURE__ */ ((OperationalZoneStatus2) => {
+  OperationalZoneStatus2["DRAFT"] = "DRAFT";
+  OperationalZoneStatus2["ACTIVE"] = "ACTIVE";
+  OperationalZoneStatus2["ARCHIVED"] = "ARCHIVED";
+  return OperationalZoneStatus2;
+})(OperationalZoneStatus || {});
+
+// src/dashboard-apps.ts
+var DashboardAppSlug = /* @__PURE__ */ ((DashboardAppSlug2) => {
+  DashboardAppSlug2["WORKSPACE"] = "WORKSPACE";
+  DashboardAppSlug2["WASTO"] = "WASTO";
+  DashboardAppSlug2["APPSO"] = "APPSO";
+  DashboardAppSlug2["CALENDO"] = "CALENDO";
+  DashboardAppSlug2["ACTO"] = "ACTO";
+  DashboardAppSlug2["ASSISTO"] = "ASSISTO";
+  DashboardAppSlug2["PLAYO"] = "PLAYO";
+  DashboardAppSlug2["MAPSO"] = "MAPSO";
+  DashboardAppSlug2["IAGO"] = "IAGO";
+  DashboardAppSlug2["PEDAGO"] = "PEDAGO";
+  DashboardAppSlug2["MARKETO"] = "MARKETO";
+  return DashboardAppSlug2;
+})(DashboardAppSlug || {});
+var WASTO_SECTIONS = [
+  {
+    slug: "WORKSPACE" /* WORKSPACE */,
+    key: "workspace",
+    label: "WORKSPACE",
+    sectionLabel: "Tableau de bord",
+    dashboardPath: "/dashboard"
+  },
+  {
+    slug: "WASTO" /* WASTO */,
+    key: "wasto",
+    label: "WAST'O",
+    sectionLabel: "R\xE9f\xE9rentiel & collecte",
+    dashboardPath: "/referentiel"
+  },
+  {
+    slug: "PLAYO" /* PLAYO */,
+    key: "playo",
+    label: "PLAY'O",
+    sectionLabel: "Engagement",
+    dashboardPath: "/engagement"
+  },
+  {
+    slug: "ACTO" /* ACTO */,
+    key: "acto",
+    label: "ACT'O",
+    sectionLabel: "Animation terrain",
+    dashboardPath: "/terrain/enquetes"
+  },
+  {
+    slug: "IAGO" /* IAGO */,
+    key: "iago",
+    label: "AGENT'O",
+    sectionLabel: "Scan & IA",
+    dashboardPath: "/scan",
+    isDevOnly: true
+  },
+  {
+    slug: "MAPSO" /* MAPSO */,
+    key: "mapso",
+    label: "MAPS'O",
+    sectionLabel: "Cartographie",
+    dashboardPath: "/cartographie/infrastructures"
+  },
+  {
+    slug: "CALENDO" /* CALENDO */,
+    key: "calendo",
+    label: "CALEND'O",
+    sectionLabel: "\xC9v\xE9nements",
+    dashboardPath: "/evenements"
+  },
+  {
+    slug: "APPSO" /* APPSO */,
+    key: "appso",
+    label: "APP'O",
+    sectionLabel: "Studio app",
+    dashboardPath: "/studio-app/apps"
+  },
+  {
+    slug: "PEDAGO" /* PEDAGO */,
+    key: "pedago",
+    label: "PEDAG'O",
+    sectionLabel: "Analyses & ROI",
+    dashboardPath: "/analyses",
+    isDevOnly: true
+  },
+  {
+    slug: "ASSISTO" /* ASSISTO */,
+    key: "assisto",
+    label: "ASSIST'O",
+    sectionLabel: "Support",
+    dashboardPath: "/support"
+  }
+];
+var DASHBOARD_APPS = [
+  {
+    slug: "WORKSPACE" /* WORKSPACE */,
+    key: "workspace",
+    label: "WORKSPACE",
+    dashboardPath: "/dashboard"
+  },
+  {
+    slug: "WASTO" /* WASTO */,
+    key: "wasto",
+    label: "WAST'O",
+    dashboardPath: "/referentiel"
+  },
+  {
+    slug: "APPSO" /* APPSO */,
+    key: "appso",
+    label: "APP'O",
+    dashboardPath: "/studio-app/apps"
+  },
+  {
+    slug: "CALENDO" /* CALENDO */,
+    key: "calendo",
+    label: "CALEND'O",
+    dashboardPath: "/evenements"
+  },
+  {
+    slug: "ACTO" /* ACTO */,
+    key: "acto",
+    label: "ACT'O",
+    dashboardPath: "/terrain/enquetes"
+  },
+  {
+    slug: "ASSISTO" /* ASSISTO */,
+    key: "assisto",
+    label: "ASSIST'O",
+    dashboardPath: "/support"
+  },
+  {
+    slug: "PLAYO" /* PLAYO */,
+    key: "playo",
+    label: "PLAY'O",
+    dashboardPath: "/engagement"
+  },
+  {
+    slug: "MAPSO" /* MAPSO */,
+    key: "mapso",
+    label: "MAPS'O",
+    dashboardPath: "/cartographie/infrastructures"
+  },
+  {
+    slug: "IAGO" /* IAGO */,
+    key: "iago",
+    label: "AGENT'O",
+    dashboardPath: "/scan",
+    isDevOnly: true
+  },
+  {
+    slug: "PEDAGO" /* PEDAGO */,
+    key: "pedago",
+    label: "PEDAG'O",
+    dashboardPath: "/analyses",
+    isDevOnly: true
+  },
+  {
+    slug: "MARKETO" /* MARKETO */,
+    key: "marketo",
+    label: "MARKET'O",
+    dashboardPath: "/analyses",
+    isDevOnly: true
+  }
+];
+var WASTO_SECTION_BY_KEY = Object.fromEntries(
+  WASTO_SECTIONS.map((s) => [s.key, s])
+);
+var DASHBOARD_APP_BY_SLUG = Object.fromEntries(
+  DASHBOARD_APPS.map((a) => [a.slug, a])
+);
+var DASHBOARD_APP_BY_KEY = Object.fromEntries(
+  DASHBOARD_APPS.map((a) => [a.key, a])
+);
+var DEFAULT_ENABLED_DASHBOARD_APP_SLUGS = DASHBOARD_APPS.filter(
+  (a) => !a.isDevOnly
+).map((a) => a.slug);
+var FREE_SELF_SERVE_DASHBOARD_APP_SLUGS = [
+  "WORKSPACE" /* WORKSPACE */,
+  "WASTO" /* WASTO */,
+  "APPSO" /* APPSO */
+];
+var FREE_SELF_SERVE_LEGACY_EXTRA_SLUGS = [
+  "PLAYO" /* PLAYO */
+];
+function normalizeDashboardAppSlug(value) {
+  const upper = value.toUpperCase();
+  if (DASHBOARD_APP_BY_SLUG[upper]) {
+    return upper;
+  }
+  return dashboardAppKeyToSlug(value.toLowerCase());
+}
+function isFreeSelfServeAppAccess(enabledSlugs) {
+  if (enabledSlugs.length === 0) return false;
+  const free = /* @__PURE__ */ new Set([
+    ...FREE_SELF_SERVE_DASHBOARD_APP_SLUGS,
+    ...FREE_SELF_SERVE_LEGACY_EXTRA_SLUGS
+  ]);
+  return enabledSlugs.every((slug) => {
+    const normalized = normalizeDashboardAppSlug(slug);
+    return normalized != null && free.has(normalized);
+  });
+}
+function resolveEnabledDashboardAppSlugs(rows) {
+  if (rows.length === 0) {
+    return [...DEFAULT_ENABLED_DASHBOARD_APP_SLUGS];
+  }
+  const enabled = rows.filter((r) => r.enabled).map((r) => r.appSlug).filter((slug) => DASHBOARD_APPS.some((a) => a.slug === slug));
+  return [...new Set(enabled)];
+}
+function dashboardAppSlugToKey(slug) {
+  return DASHBOARD_APP_BY_SLUG[slug]?.key ?? slug.toLowerCase();
+}
+function dashboardAppKeyToSlug(key) {
+  return DASHBOARD_APP_BY_KEY[key]?.slug ?? null;
+}
+var WASTO_LANDINGS_DOMAIN = "wasto.localhost";
+var WASTO_LANDINGS_INDEX_HOST = `apps.${WASTO_LANDINGS_DOMAIN}`;
+var WASTO_RESERVED_SUBDOMAINS = /* @__PURE__ */ new Set([
+  "api",
+  "admin",
+  "dashboard",
+  "docs",
+  "field-survey",
+  "apps"
+]);
+function isDashboardAppLandingHost(host) {
+  const normalized = host.split(":")[0]?.toLowerCase() ?? "";
+  if (normalized === WASTO_LANDINGS_INDEX_HOST) {
+    return true;
+  }
+  const match = normalized.match(/^([a-z]+)\.wasto\.localhost$/);
+  if (!match) {
+    return false;
+  }
+  const subdomain = match[1];
+  if (WASTO_RESERVED_SUBDOMAINS.has(subdomain)) {
+    return false;
+  }
+  return Boolean(DASHBOARD_APP_BY_KEY[subdomain]);
+}
+function dashboardAppKeyFromLandingHost(host) {
+  const normalized = host.split(":")[0]?.toLowerCase() ?? "";
+  if (normalized === WASTO_LANDINGS_INDEX_HOST) {
+    return null;
+  }
+  const match = normalized.match(/^([a-z]+)\.wasto\.localhost$/);
+  if (!match) {
+    return null;
+  }
+  const key = match[1];
+  if (WASTO_RESERVED_SUBDOMAINS.has(key) || !DASHBOARD_APP_BY_KEY[key]) {
+    return null;
+  }
+  return key;
+}
+function resolveDashboardAppLandingUrl(key, options) {
+  if (!DASHBOARD_APP_BY_KEY[key]) {
+    return null;
+  }
+  const domain = options?.domain ?? WASTO_LANDINGS_DOMAIN;
+  const protocol = options?.protocol ?? "http";
+  return `${protocol}://${key}.${domain}`;
+}
+function resolveWastoLandingsIndexUrl(options) {
+  const domain = options?.domain ?? WASTO_LANDINGS_DOMAIN;
+  const protocol = options?.protocol ?? "http";
+  return `${protocol}://apps.${domain}`;
+}
+
+// src/free-tier.ts
+var FREE_TIER_LIMITS = {
+  cmsApps: 1,
+  cmsPages: 5,
+  blogPosts: 10,
+  cmsMedia: 50,
+  cmsMediaBytesMb: 50,
+  wasteTypes: 15,
+  collectionPlaces: 10,
+  printCalendarTemplates: 3
+};
+var FREE_TIER_FEATURES = {
+  challenges: false,
+  roi: false,
+  notifications: false,
+  recyclingPoints: false,
+  assets: false,
+  nativeStorePublication: false,
+  inviteMembers: false
+};
+var FREE_TIER_RESOURCES = [
+  "cmsApps",
+  "cmsPages",
+  "blogPosts",
+  "cmsMedia",
+  "wasteTypes",
+  "collectionPlaces",
+  "printCalendarTemplates"
+];
+var FREE_TIER_FEATURE_KEYS = [
+  "challenges",
+  "roi",
+  "notifications",
+  "recyclingPoints",
+  "assets",
+  "nativeStorePublication",
+  "inviteMembers"
+];
+function getFreeTierLimit(resource) {
+  return FREE_TIER_LIMITS[resource];
+}
+function getFreeTierMediaBytesLimit() {
+  return FREE_TIER_LIMITS.cmsMediaBytesMb * 1024 * 1024;
+}
+function isFreeTierFeatureEnabled(feature) {
+  return FREE_TIER_FEATURES[feature] === true;
+}
+
+// src/types/pagination.types.ts
+var DEFAULT_PAGE = 1;
+var DEFAULT_PAGE_SIZE = 20;
+var MAX_PAGE_SIZE = 100;
+function buildPaginationMeta(page, pageSize, total) {
+  return {
+    page,
+    pageSize,
+    total,
+    totalPages: Math.ceil(total / pageSize) || 1
+  };
+}
+
+// src/types/onboarding.types.ts
+var ONBOARDING_RESTRICTED_APP_SLUGS = FREE_SELF_SERVE_DASHBOARD_APP_SLUGS;
+
+// src/roi/calculations.ts
+var ROI_DEFAULTS = {
+  annualTonnage: 12e3,
+  errorRatePercent: 25,
+  costPerBadTonne: 300,
+  /** Habitants par foyer (proxy si householdCount absent). */
+  peoplePerHousehold: 2.2
+};
+var CITEO_DOM_MULTIPLIERS = {
+  lightPackaging: 2.3,
+  glass: 1.9,
+  paper: 4.3,
+  communication: 1.25,
+  ambassadors: 1.25,
+  /** Facteur composite simplifié pour majorer un soutien Citeo agrégé saisi. */
+  compositeSupport: 2.3
+};
+var DOM_INSEE_PREFIXES = [
+  "971",
+  // Guadeloupe
+  "972",
+  // Martinique
+  "973",
+  // Guyane
+  "974",
+  // La Réunion
+  "976"
+  // Mayotte
+];
+var TGAP_LANDFILL_EUR_PER_TONNE = {
+  2024: 61,
+  2025: 65,
+  2026: 69,
+  2027: 73,
+  2028: 77,
+  2029: 81,
+  2030: 85
+};
+function currentFiscalYear(now = /* @__PURE__ */ new Date()) {
+  return now.getFullYear();
+}
+function getTgapEurPerTonne(fiscalYear) {
+  if (TGAP_LANDFILL_EUR_PER_TONNE[fiscalYear] != null) {
+    return TGAP_LANDFILL_EUR_PER_TONNE[fiscalYear];
+  }
+  if (fiscalYear < 2024) return 61;
+  if (fiscalYear > 2030) return 85;
+  const base = 65;
+  return base + (fiscalYear - 2025) * 4;
+}
+function adjustCostPerBadTonneForTgap(opts) {
+  const nonTgap = Math.max(
+    0,
+    opts.previousCostPerBadTonne - opts.previousTgapEurPerTonne
+  );
+  return roundEuro(nonTgap + opts.nextTgapEurPerTonne);
+}
+function buildBauVsRealSeries(opts) {
+  const byYear = new Map(opts.years.map((y) => [y.fiscalYear, y]));
+  const points = [];
+  for (let y = opts.fromYear; y <= opts.toYear; y++) {
+    const tgap = getTgapEurPerTonne(y);
+    const bauCost = adjustCostPerBadTonneForTgap({
+      previousCostPerBadTonne: opts.reference.costPerBadTonne,
+      previousTgapEurPerTonne: opts.reference.tgapEurPerTonne,
+      nextTgapEurPerTonne: tgap
+    });
+    const bau = computeGec(
+      opts.reference.tonnageOmr,
+      opts.reference.errorRatePercent,
+      bauCost
+    );
+    const snap = byYear.get(y);
+    if (snap) {
+      points.push({
+        fiscalYear: y,
+        tonnageOmr: snap.tonnageOmr,
+        errorRatePercent: snap.errorRatePercent,
+        costPerBadTonne: snap.costPerBadTonne,
+        tgapEurPerTonne: snap.tgapEurPerTonne,
+        realGecEur: snap.gecEur,
+        bauGecEur: bau.gecEur,
+        cenEur: snap.cenEur,
+        hasSnapshot: true,
+        annualBilanConfirmed: snap.annualBilanConfirmed === true
+      });
+    } else {
+      points.push({
+        fiscalYear: y,
+        tonnageOmr: opts.reference.tonnageOmr,
+        errorRatePercent: opts.reference.errorRatePercent,
+        costPerBadTonne: bauCost,
+        tgapEurPerTonne: tgap,
+        realGecEur: bau.gecEur,
+        bauGecEur: bau.gecEur,
+        cenEur: null,
+        hasSnapshot: false,
+        annualBilanConfirmed: false
+      });
+    }
+  }
+  return points;
+}
+var ROI_SCENARIO_DEFS = [
+  {
+    id: "awareness",
+    label: "Sensibilisation seule",
+    errorReductionFactor: 0.12,
+    costBase: 8e3,
+    costPerTonne: 0.35
+  },
+  {
+    id: "controls",
+    label: "Formation + contr\xF4les",
+    errorReductionFactor: 0.28,
+    costBase: 45e3,
+    costPerTonne: 1.8
+  },
+  {
+    id: "wasto",
+    label: "Wast-O (app + IA + pilotage)",
+    errorReductionFactor: 0.45,
+    costBase: 18e3,
+    costPerTonne: 0.9
+  }
+];
+var ROI_DISCLAIMER = "Ordres de grandeur p\xE9dagogiques fond\xE9s sur des hypoth\xE8ses d\xE9claratives (tonnages, taux d\u2019erreur, budgets). Non contractuels \u2014 \xE0 affiner avec les donn\xE9es exploitant / SITOM / TGAP.";
+function clamp(n, min, max) {
+  return Math.min(max, Math.max(min, n));
+}
+function roundEuro(n) {
+  return Math.round(n);
+}
+function isDomInseeCode(codeInsee) {
+  if (!codeInsee) return false;
+  const normalized = codeInsee.trim();
+  return DOM_INSEE_PREFIXES.some((p) => normalized.startsWith(p));
+}
+function detectDomTerritory(opts) {
+  if (opts.cityInseeCodes?.some((c) => isDomInseeCode(c))) return true;
+  const code = (opts.cityGroupCode ?? "").toUpperCase();
+  const name = (opts.cityGroupName ?? "").toUpperCase();
+  if (name.includes("CINOR") || name.includes("REUNION") || name.includes("R\xC9UNION")) {
+    return true;
+  }
+  if (code.includes("974") || code.includes("CINOR")) return true;
+  return false;
+}
+function applyCiteoDomMultiplier(baseCiteoEur, isDom) {
+  const baseEur = roundEuro(baseCiteoEur);
+  const multiplier = isDom ? CITEO_DOM_MULTIPLIERS.compositeSupport : 1;
+  return {
+    baseEur,
+    multiplier,
+    effectiveEur: roundEuro(baseEur * multiplier)
+  };
+}
+function computeGec(annualTonnage, errorRatePercent, costPerBadTonne) {
+  const badTonnes = annualTonnage * (errorRatePercent / 100);
+  return {
+    badTonnes: Math.round(badTonnes * 10) / 10,
+    gecEur: roundEuro(badTonnes * costPerBadTonne)
+  };
+}
+function applyStackedErrorReductions(baselineErrorRatePercent, reductionsPercent) {
+  let rate = baselineErrorRatePercent;
+  for (const r of reductionsPercent) {
+    const factor = clamp(r, 0, 95) / 100;
+    rate = rate * (1 - factor);
+  }
+  return clamp(Math.round(rate * 10) / 10, 1, 99);
+}
+function isActionCountedInRoi(status) {
+  if (!status) return true;
+  return status !== "CANCELLED" && status !== "PLANNED";
+}
+function computeActionImpactConfidence(action, live) {
+  const type = (action.type ?? "OTHER").toUpperCase();
+  const isApp = type === "WASTO_APP";
+  const hasLiveDigital = live.penetrationRatePercent > 0 || live.activeDevices30d > 0 || live.validatedVisionScans > 0 || live.challengeCompletions > 0;
+  if (isApp && !hasLiveDigital) {
+    return {
+      level: 1,
+      label: "Confiance faible",
+      tone: "low",
+      message: "Impact th\xE9orique (0 utilisateur actif)",
+      impactFactor: 0.25
+    };
+  }
+  if (isApp && live.penetrationRatePercent < 2) {
+    return {
+      level: 1,
+      label: "Confiance faible",
+      tone: "low",
+      message: `P\xE9n\xE9tration faible (${live.penetrationRatePercent} %) \u2014 impact brid\xE9`,
+      impactFactor: 0.5
+    };
+  }
+  if (isApp && live.penetrationRatePercent >= 5) {
+    return {
+      level: 2,
+      label: "Confiance moyenne",
+      tone: "medium",
+      message: "Proxy live app disponible",
+      impactFactor: 1
+    };
+  }
+  if (type === "AWARENESS" || type === "TRAINING" || type === "CONTROLS") {
+    if (live.terrainResponses > 0) {
+      return {
+        level: 2,
+        label: "Confiance moyenne",
+        tone: "medium",
+        message: "Appuy\xE9 par des donn\xE9es terrain",
+        impactFactor: 1
+      };
+    }
+    return {
+      level: 1,
+      label: "Confiance faible",
+      tone: "low",
+      message: "Impact d\xE9claratif (pas encore de preuve mesur\xE9e)",
+      impactFactor: 0.85
+    };
+  }
+  return {
+    level: 1,
+    label: "Confiance faible",
+    tone: "low",
+    message: "Impact d\xE9claratif",
+    impactFactor: 0.85
+  };
+}
+function computeOverallConfidence(actionConfidences, opts) {
+  if (opts?.annualBilanConfirmed) {
+    return {
+      level: 3,
+      label: "Confiance \xE9lev\xE9e",
+      tone: "high",
+      message: "Bilan annuel consolid\xE9 (TGAP / exploitant / co\xFBt du service) \u2014 niveau d\xE9cideurs",
+      impactFactor: 1
+    };
+  }
+  if (actionConfidences.length === 0) {
+    return {
+      level: 1,
+      label: "Confiance faible",
+      tone: "low",
+      message: "Aucune action active",
+      impactFactor: 1
+    };
+  }
+  const minLevel = Math.min(
+    ...actionConfidences.map((c) => c.level)
+  );
+  if (minLevel === 1) {
+    return {
+      level: 1,
+      label: "Confiance faible",
+      tone: "low",
+      message: "ROI en partie th\xE9orique \u2014 au moins une action sans preuve live",
+      impactFactor: 1
+    };
+  }
+  if (minLevel === 2) {
+    return {
+      level: 2,
+      label: "Confiance moyenne",
+      tone: "medium",
+      message: "ROI appuy\xE9 par des proxies live",
+      impactFactor: 1
+    };
+  }
+  return {
+    level: 3,
+    label: "Confiance \xE9lev\xE9e",
+    tone: "high",
+    message: "ROI adoss\xE9 \xE0 des preuves repr\xE9sentatives",
+    impactFactor: 1
+  };
+}
+function computeRoiIndicators(economics, actions, live) {
+  const baselineRate = economics.baselineErrorRatePercent ?? economics.errorRatePercent;
+  const baselineTonnage = economics.baselineAnnualTonnageOmr ?? economics.annualTonnageOmr;
+  const cost = economics.costPerBadTonne;
+  const liveSignals = live ?? {
+    penetrationRatePercent: 0,
+    activeDevices30d: 0,
+    validatedVisionScans: 0,
+    challengeCompletions: 0,
+    terrainResponses: 0
+  };
+  const before = computeGec(baselineTonnage, baselineRate, cost);
+  const counted = actions.filter((a) => isActionCountedInRoi(a.status));
+  const confidences = counted.map(
+    (a) => computeActionImpactConfidence(a, liveSignals)
+  );
+  const reductions = counted.map((a, i) => {
+    const factor = confidences[i]?.impactFactor ?? 1;
+    return Math.max(0, a.errorReductionPercent) * factor;
+  });
+  const afterRate = reductions.length > 0 ? applyStackedErrorReductions(baselineRate, reductions) : economics.errorRatePercent;
+  const combinedErrorReductionPoints = Math.round((baselineRate - afterRate) * 10) / 10;
+  const combinedErrorReductionPercent = baselineRate > 0 ? Math.round((1 - afterRate / baselineRate) * 1e3) / 10 : 0;
+  const after = computeGec(economics.annualTonnageOmr, afterRate, cost);
+  const grossSavingsEur = roundEuro(before.gecEur - after.gecEur);
+  const actionsBudgetEur = roundEuro(
+    counted.reduce(
+      (sum, a) => sum + (a.budgetCapexEur || 0) + (a.budgetOpexEur || 0),
+      0
+    )
+  );
+  const wastoAnnualCostEur = roundEuro(economics.wastoAnnualCostEur ?? 0);
+  const totalActionBudgetsEur = roundEuro(actionsBudgetEur + wastoAnnualCostEur);
+  const isDomTerritory = economics.isDomTerritory === true;
+  const citeo = applyCiteoDomMultiplier(
+    economics.citeoSupportGainEur ?? 0,
+    isDomTerritory
+  );
+  const cenEur = roundEuro(
+    grossSavingsEur + citeo.effectiveEur - totalActionBudgetsEur
+  );
+  const roiMultiple = totalActionBudgetsEur > 0 ? Math.round(
+    (grossSavingsEur + citeo.effectiveEur) / totalActionBudgetsEur * 10
+  ) / 10 : null;
+  const overallConfidence = computeOverallConfidence(confidences, {
+    annualBilanConfirmed: economics.annualBilanConfirmed === true || liveSignals.annualBilanConfirmed === true
+  });
+  const stackingParts = reductions.map((r) => `(1 \u2212 ${Math.round(r * 10) / 10}/100)`).join(" \xD7 ");
+  return {
+    gecEur: before.gecEur,
+    baselineBadTonnes: before.badTonnes,
+    baselineErrorRatePercent: baselineRate,
+    afterErrorRatePercent: afterRate,
+    combinedErrorReductionPoints,
+    combinedErrorReductionPercent,
+    stackingFormula: reductions.length > 0 ? `taux_apr\xE8s = ${baselineRate} % \xD7 ${stackingParts}` : "Aucune r\xE9duction active",
+    afterAnnualLossEur: after.gecEur,
+    afterBadTonnes: after.badTonnes,
+    grossSavingsEur,
+    actionsBudgetEur,
+    wastoAnnualCostEur,
+    totalActionBudgetsEur,
+    citeoSupportGainEur: citeo.effectiveEur,
+    citeoSupportBaseEur: citeo.baseEur,
+    citeoDomMultiplier: citeo.multiplier,
+    isDomTerritory,
+    cenEur,
+    roiMultiple,
+    overallConfidence,
+    disclaimer: ROI_DISCLAIMER
+  };
+}
+function allocateSavingsByAction(grossSavingsEur, actions, live) {
+  const liveSignals = live ?? {
+    penetrationRatePercent: 0,
+    activeDevices30d: 0,
+    validatedVisionScans: 0,
+    challengeCompletions: 0,
+    terrainResponses: 0
+  };
+  const counted = actions.filter((a) => isActionCountedInRoi(a.status));
+  const enriched = counted.map((a) => {
+    const confidence = computeActionImpactConfidence(a, liveSignals);
+    return {
+      action: a,
+      confidence,
+      effectiveReductionPercent: Math.max(0, a.errorReductionPercent) * confidence.impactFactor
+    };
+  });
+  const totalReduction = enriched.reduce(
+    (s, e) => s + e.effectiveReductionPercent,
+    0
+  );
+  if (totalReduction <= 0 || enriched.length === 0) {
+    return enriched.map((e) => ({
+      id: e.action.id,
+      name: e.action.name,
+      type: e.action.type,
+      shareEur: 0,
+      budgetEur: roundEuro(
+        (e.action.budgetCapexEur || 0) + (e.action.budgetOpexEur || 0)
+      ),
+      confidence: e.confidence,
+      effectiveReductionPercent: e.effectiveReductionPercent
+    }));
+  }
+  return enriched.map((e) => {
+    const weight = e.effectiveReductionPercent / totalReduction;
+    return {
+      id: e.action.id,
+      name: e.action.name,
+      type: e.action.type,
+      shareEur: roundEuro(grossSavingsEur * weight),
+      budgetEur: roundEuro(
+        (e.action.budgetCapexEur || 0) + (e.action.budgetOpexEur || 0)
+      ),
+      confidence: e.confidence,
+      effectiveReductionPercent: Math.round(e.effectiveReductionPercent * 10) / 10
+    };
+  });
+}
+function estimateHouseholds(householdCount, population) {
+  if (householdCount && householdCount > 0) return householdCount;
+  if (population && population > 0) {
+    return Math.round(population / ROI_DEFAULTS.peoplePerHousehold);
+  }
+  return 0;
+}
+function computePenetrationRate(activeHouseholdsProxy, householdCount) {
+  if (householdCount <= 0) return 0;
+  return Math.round(activeHouseholdsProxy / householdCount * 1e3) / 10;
+}
+function simulateTerritory100kExample() {
+  const economics = {
+    annualTonnageOmr: 24e3,
+    errorRatePercent: 25,
+    costPerBadTonne: 300,
+    wastoAnnualCostEur: 18e3,
+    citeoSupportGainEur: 4e4,
+    baselineErrorRatePercent: 25,
+    baselineAnnualTonnageOmr: 24e3
+  };
+  const actions = [
+    {
+      id: "1",
+      name: "Campagne sensibilisation",
+      type: "AWARENESS",
+      status: "IN_PROGRESS",
+      budgetCapexEur: 0,
+      budgetOpexEur: 12e3,
+      errorReductionPercent: 12
+    },
+    {
+      id: "2",
+      name: "Contr\xF4les de bac",
+      type: "CONTROLS",
+      status: "IN_PROGRESS",
+      budgetCapexEur: 5e3,
+      budgetOpexEur: 35e3,
+      errorReductionPercent: 18
+    },
+    {
+      id: "3",
+      name: "Wast-O app",
+      type: "WASTO_APP",
+      status: "IN_PROGRESS",
+      budgetCapexEur: 0,
+      budgetOpexEur: 0,
+      errorReductionPercent: 20
+    }
+  ];
+  const live = {
+    penetrationRatePercent: 3,
+    activeDevices30d: 1200,
+    validatedVisionScans: 400,
+    challengeCompletions: 80,
+    terrainResponses: 50
+  };
+  const indicators = computeRoiIndicators(economics, actions, live);
+  const households = estimateHouseholds(null, 1e5);
+  return {
+    population: 1e5,
+    households,
+    economics,
+    actions,
+    indicators,
+    contributions: allocateSavingsByAction(
+      indicators.grossSavingsEur,
+      actions,
+      live
+    )
+  };
+}
+
+// src/opening-hours/types.ts
+var WEEKDAYS = [
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+  "sunday"
+];
+
+// src/opening-hours/constants.ts
+var WEEKDAY_REF_DATES = {
+  monday: "2024-01-01",
+  tuesday: "2024-01-02",
+  wednesday: "2024-01-03",
+  thursday: "2024-01-04",
+  friday: "2024-01-05",
+  saturday: "2024-01-06",
+  sunday: "2024-01-07"
+};
+var WEEKDAY_LABELS_FR = {
+  monday: "Lundi",
+  tuesday: "Mardi",
+  wednesday: "Mercredi",
+  thursday: "Jeudi",
+  friday: "Vendredi",
+  saturday: "Samedi",
+  sunday: "Dimanche"
+};
+var WEEKDAY_LABELS_FR_SHORT = {
+  monday: "Lun",
+  tuesday: "Mar",
+  wednesday: "Mer",
+  thursday: "Jeu",
+  friday: "Ven",
+  saturday: "Sam",
+  sunday: "Dim"
+};
+var WEEKDAY_INDEX = {
+  monday: 0,
+  tuesday: 1,
+  wednesday: 2,
+  thursday: 3,
+  friday: 4,
+  saturday: 5,
+  sunday: 6
+};
+var PRESET_SLOTS = {
+  morning: { open: "08:00", close: "12:00" },
+  afternoon: { open: "14:00", close: "18:00" },
+  fullDay: { open: "08:00", close: "18:00" }
+};
+
+// src/opening-hours/time.ts
+var TIME_RE = /^([01]\d|2[0-3]):([0-5]\d)$/;
+function parseTimeMinutes(value) {
+  const m = TIME_RE.exec(value.trim());
+  if (!m) return null;
+  return Number(m[1]) * 60 + Number(m[2]);
+}
+function formatTimeMinutes(totalMinutes) {
+  const normalized = (totalMinutes % (24 * 60) + 24 * 60) % (24 * 60);
+  const h = Math.floor(normalized / 60);
+  const min = normalized % 60;
+  return `${String(h).padStart(2, "0")}:${String(min).padStart(2, "0")}`;
+}
+function formatTimeDisplay(value) {
+  const minutes = parseTimeMinutes(value);
+  if (minutes == null) return value;
+  const h = Math.floor(minutes / 60);
+  const min = minutes % 60;
+  return min === 0 ? `${h}h` : `${h}h${String(min).padStart(2, "0")}`;
+}
+function slotsOverlap(a, b) {
+  const aOpen = parseTimeMinutes(a.open);
+  const aClose = parseTimeMinutes(a.close);
+  const bOpen = parseTimeMinutes(b.open);
+  const bClose = parseTimeMinutes(b.close);
+  if (aOpen == null || aClose == null || bOpen == null || bClose == null) return false;
+  if (aClose <= aOpen || bClose <= bOpen) return false;
+  return aOpen < bClose && bOpen < aClose;
+}
+function sortSlots(slots) {
+  return [...slots].sort(
+    (a, b) => (parseTimeMinutes(a.open) ?? 0) - (parseTimeMinutes(b.open) ?? 0)
+  );
+}
+function nextWeekday(day) {
+  const idx = (WEEKDAY_INDEX[day] + 1) % 7;
+  return WEEKDAYS[idx];
+}
+function addDaysToIsoDate(isoDate, days) {
+  const [y, mo, d] = isoDate.split("-").map(Number);
+  const dt = new Date(Date.UTC(y, mo - 1, d + days));
+  return dt.toISOString().slice(0, 10);
+}
+function weekdayFromUtcDate(date) {
+  const jsDay = date.getUTCDay();
+  const map = [
+    "sunday",
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday"
+  ];
+  return map[jsDay];
+}
+function utcHhmmFromDate(date) {
+  return formatTimeMinutes(date.getUTCHours() * 60 + date.getUTCMinutes());
+}
+function refDateForWeekday(day) {
+  return WEEKDAY_REF_DATES[day];
+}
+
+// src/opening-hours/timezone.ts
+function getTimezoneOffsetMinutes(timeZone, at) {
+  const utc = new Date(at.toLocaleString("en-US", { timeZone: "UTC" }));
+  const zoned = new Date(at.toLocaleString("en-US", { timeZone }));
+  return (zoned.getTime() - utc.getTime()) / 6e4;
+}
+function localDateTimeToUtc(dateIso, time, timeZone) {
+  const [y, mo, d] = dateIso.split("-").map(Number);
+  const [h, mi] = time.split(":").map(Number);
+  let utcMs = Date.UTC(y, mo - 1, d, h, mi, 0);
+  for (let i = 0; i < 2; i++) {
+    const offset = getTimezoneOffsetMinutes(timeZone, new Date(utcMs));
+    utcMs = Date.UTC(y, mo - 1, d, h, mi, 0) - offset * 6e4;
+  }
+  return new Date(utcMs);
+}
+function getBrowserTimeZone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+function utcDateIso(at) {
+  return at.toISOString().slice(0, 10);
+}
+
+// src/opening-hours/validate.ts
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+function isPlainObject(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v);
+}
+function validateTimeSlot(slot, path, errors) {
+  if (!isPlainObject(slot)) {
+    errors.push(`${path} : cr\xE9neau invalide`);
+    return false;
+  }
+  const open = slot.open;
+  const close = slot.close;
+  if (typeof open !== "string" || parseTimeMinutes(open) == null) {
+    errors.push(`${path}.open : heure invalide (HH:mm)`);
+    return false;
+  }
+  if (typeof close !== "string" || parseTimeMinutes(close) == null) {
+    errors.push(`${path}.close : heure invalide (HH:mm)`);
+    return false;
+  }
+  const openMin = parseTimeMinutes(open);
+  const closeMin = parseTimeMinutes(close);
+  if (closeMin <= openMin) {
+    errors.push(`${path} : l'heure de fermeture doit \xEAtre apr\xE8s l'ouverture (UTC)`);
+    return false;
+  }
+  return true;
+}
+function validateRule(rule, index, errors) {
+  if (!isPlainObject(rule)) {
+    errors.push(`rules[${index}] : r\xE8gle invalide`);
+    return false;
+  }
+  if (!Array.isArray(rule.days) || rule.days.length === 0) {
+    errors.push(`rules[${index}].days : au moins un jour requis`);
+    return false;
+  }
+  for (const day of rule.days) {
+    if (typeof day !== "string" || !WEEKDAYS.includes(day)) {
+      errors.push(`rules[${index}].days : jour invalide (${String(day)})`);
+    }
+  }
+  if (!Array.isArray(rule.slots) || rule.slots.length === 0) {
+    errors.push(`rules[${index}].slots : au moins un cr\xE9neau requis`);
+    return false;
+  }
+  const slots = [];
+  rule.slots.forEach((slot, slotIndex) => {
+    if (validateTimeSlot(slot, `rules[${index}].slots[${slotIndex}]`, errors)) {
+      slots.push(slot);
+    }
+  });
+  const sorted = sortSlots(slots);
+  for (let i = 0; i < sorted.length - 1; i++) {
+    if (slotsOverlap(sorted[i], sorted[i + 1])) {
+      errors.push(`rules[${index}].slots : cr\xE9neaux qui se chevauchent`);
+      break;
+    }
+  }
+  return errors.length === 0;
+}
+function validateException(exc, index, errors) {
+  if (!isPlainObject(exc)) {
+    errors.push(`exceptions[${index}] : exception invalide`);
+    return false;
+  }
+  if (typeof exc.date !== "string" || !DATE_RE.test(exc.date)) {
+    errors.push(`exceptions[${index}].date : date invalide (YYYY-MM-DD)`);
+    return false;
+  }
+  if (exc.closed === true) return true;
+  if (exc.closed === false) {
+    if (!Array.isArray(exc.slots) || exc.slots.length === 0) {
+      errors.push(`exceptions[${index}].slots : requis si non ferm\xE9`);
+      return false;
+    }
+    exc.slots.forEach((slot, slotIndex) => {
+      validateTimeSlot(slot, `exceptions[${index}].slots[${slotIndex}]`, errors);
+    });
+    return true;
+  }
+  errors.push(`exceptions[${index}].closed : bool\xE9en requis`);
+  return false;
+}
+function validateOpeningHours(input) {
+  const errors = [];
+  if (!isPlainObject(input)) {
+    return { ok: false, errors: ["Horaires : objet attendu"] };
+  }
+  if (input.version !== 1) {
+    errors.push("version : doit \xEAtre 1");
+  }
+  if (input.storage !== "utc") {
+    errors.push('storage : doit \xEAtre "utc"');
+  }
+  if (!Array.isArray(input.rules)) {
+    errors.push("rules : tableau attendu");
+    return { ok: false, errors };
+  }
+  input.rules.forEach((rule, index) => validateRule(rule, index, errors));
+  const daySet = /* @__PURE__ */ new Set();
+  if (Array.isArray(input.rules)) {
+    for (const rule of input.rules) {
+      if (!isPlainObject(rule) || !Array.isArray(rule.days)) continue;
+      for (const day of rule.days) {
+        if (typeof day === "string" && WEEKDAYS.includes(day)) {
+          const wd = day;
+          if (daySet.has(wd)) {
+            errors.push(`rules : le jour ${wd} appara\xEEt dans plusieurs r\xE8gles`);
+          }
+          daySet.add(wd);
+        }
+      }
+    }
+  }
+  if (input.exceptions != null) {
+    if (!Array.isArray(input.exceptions)) {
+      errors.push("exceptions : tableau attendu");
+    } else {
+      input.exceptions.forEach((exc, index) => validateException(exc, index, errors));
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return {
+    ok: true,
+    value: {
+      version: 1,
+      storage: "utc",
+      rules: input.rules.map((r) => ({
+        days: [...r.days],
+        slots: sortSlots([...r.slots])
+      })),
+      exceptions: input.exceptions
+    }
+  };
+}
+function validateLocalOpeningHours(input) {
+  return validateOpeningHours({
+    version: 1,
+    storage: "utc",
+    rules: input.rules,
+    exceptions: input.exceptions
+  });
+}
+function createEmptyOpeningHours() {
+  return { version: 1, storage: "utc", rules: [] };
+}
+function createEmptyLocalRules() {
+  return [];
+}
+
+// src/opening-hours/convert.ts
+function addSlotToMap(map, day, slot) {
+  const existing = map.get(day) ?? [];
+  existing.push(slot);
+  map.set(day, existing);
+}
+function mergeSlots(slots) {
+  const sorted = sortSlots(slots);
+  const merged = [];
+  for (const slot of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && last.close === slot.open) {
+      merged[merged.length - 1] = { open: last.open, close: slot.close };
+    } else {
+      merged.push({ ...slot });
+    }
+  }
+  return merged.filter((s) => {
+    const o = parseTimeMinutes(s.open);
+    const c = parseTimeMinutes(s.close);
+    return o != null && c != null && c > o;
+  });
+}
+function mapToRules(map) {
+  const rules = [];
+  for (const day of WEEKDAYS) {
+    const slots = map.get(day);
+    if (!slots?.length) continue;
+    rules.push({ days: [day], slots: mergeSlots(slots) });
+  }
+  return coalesceDayRules(rules);
+}
+function coalesceDayRules(rules) {
+  const bySignature = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    const sig = JSON.stringify(rule.slots);
+    const days = bySignature.get(sig) ?? [];
+    days.push(...rule.days);
+    bySignature.set(sig, days);
+  }
+  const out = [];
+  for (const [sig, days] of bySignature) {
+    out.push({
+      days: sortWeekdays([...new Set(days)]),
+      slots: JSON.parse(sig)
+    });
+  }
+  return out;
+}
+function sortWeekdays(days) {
+  const order = new Map(WEEKDAYS.map((d, i) => [d, i]));
+  return [...days].sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
+}
+function convertLocalSlotToUtcFixed(map, localDay, slot, timeZone) {
+  const openMin = parseTimeMinutes(slot.open);
+  const closeMin = parseTimeMinutes(slot.close);
+  if (openMin == null || closeMin == null) return;
+  const openDate = refDateForWeekday(localDay);
+  let closeDate = openDate;
+  const closeTime = slot.close;
+  if (closeMin <= openMin) {
+    closeDate = addDaysToIsoDate(openDate, 1);
+  }
+  const openUtc = localDateTimeToUtc(openDate, slot.open, timeZone);
+  const closeUtc = localDateTimeToUtc(closeDate, closeTime, timeZone);
+  const openDay = weekdayFromUtcDate(openUtc);
+  const closeDay = weekdayFromUtcDate(closeUtc);
+  const openStr = utcHhmmFromDate(openUtc);
+  const closeStr = utcHhmmFromDate(closeUtc);
+  if (openDay === closeDay) {
+    if (openStr !== closeStr) {
+      addSlotToMap(map, openDay, { open: openStr, close: closeStr });
+    }
+    return;
+  }
+  addSlotToMap(map, openDay, { open: openStr, close: "23:59" });
+  if (closeStr !== "00:00") {
+    addSlotToMap(map, closeDay, { open: "00:00", close: closeStr });
+  }
+}
+function convertUtcSlotToLocal(map, utcDay, slot, timeZone) {
+  const openMin = parseTimeMinutes(slot.open);
+  const closeMin = parseTimeMinutes(slot.close);
+  if (openMin == null || closeMin == null) return;
+  const openDate = refDateForWeekday(utcDay);
+  let closeDate = openDate;
+  const closeTime = slot.close;
+  if (closeMin <= openMin) {
+    closeDate = addDaysToIsoDate(openDate, 1);
+  }
+  const openUtc = /* @__PURE__ */ new Date(`${openDate}T${slot.open}:00.000Z`);
+  const closeUtc = /* @__PURE__ */ new Date(`${closeDate}T${closeTime}:00.000Z`);
+  const openLocal = formatZoned(openUtc, timeZone);
+  const closeLocal = formatZoned(closeUtc, timeZone);
+  if (openLocal.day === closeLocal.day) {
+    if (openLocal.time !== closeLocal.time) {
+      addSlotToMap(map, openLocal.day, { open: openLocal.time, close: closeLocal.time });
+    }
+    return;
+  }
+  addSlotToMap(map, openLocal.day, { open: openLocal.time, close: "23:59" });
+  if (closeLocal.time !== "00:00") {
+    addSlotToMap(map, closeLocal.day, { open: "00:00", close: closeLocal.time });
+  }
+}
+function formatZoned(utc, timeZone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    weekday: "long",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  }).formatToParts(utc);
+  const weekdayRaw = parts.find((p) => p.type === "weekday")?.value?.toLowerCase();
+  const hour = parts.find((p) => p.type === "hour")?.value ?? "00";
+  const minute = parts.find((p) => p.type === "minute")?.value ?? "00";
+  const dayMap = {
+    monday: "monday",
+    tuesday: "tuesday",
+    wednesday: "wednesday",
+    thursday: "thursday",
+    friday: "friday",
+    saturday: "saturday",
+    sunday: "sunday"
+  };
+  const day = dayMap[weekdayRaw ?? "monday"] ?? "monday";
+  return { day, time: `${hour.padStart(2, "0")}:${minute.padStart(2, "0")}` };
+}
+function convertLocalToUtc(local, timeZone) {
+  const map = /* @__PURE__ */ new Map();
+  for (const rule of local.rules) {
+    for (const day of rule.days) {
+      for (const slot of rule.slots) {
+        convertLocalSlotToUtcFixed(map, day, slot, timeZone);
+      }
+    }
+  }
+  const exceptions = local.exceptions?.map((exc) => {
+    if (exc.closed) return exc;
+    const excMap = /* @__PURE__ */ new Map();
+    for (const slot of exc.slots) {
+      convertLocalSlotToUtcFixed(excMap, "monday", slot, timeZone);
+    }
+    const merged = [...excMap.values()].flat();
+    return { ...exc, slots: merged.length ? mergeSlots(merged) : exc.slots };
+  });
+  return {
+    version: 1,
+    storage: "utc",
+    rules: mapToRules(map),
+    exceptions
+  };
+}
+function convertUtcToLocal(utc, timeZone) {
+  const map = /* @__PURE__ */ new Map();
+  for (const rule of utc.rules) {
+    for (const day of rule.days) {
+      for (const slot of rule.slots) {
+        convertUtcSlotToLocal(map, day, slot, timeZone);
+      }
+    }
+  }
+  const exceptions = utc.exceptions?.map((exc) => {
+    if (exc.closed) return exc;
+    const excMap = /* @__PURE__ */ new Map();
+    for (const slot of exc.slots) {
+      convertUtcSlotToLocal(excMap, "monday", slot, timeZone);
+    }
+    const merged = [...excMap.values()].flat();
+    return { ...exc, slots: merged.length ? mergeSlots(merged) : exc.slots };
+  });
+  return {
+    rules: mapToRules(map),
+    exceptions
+  };
+}
+function localRulesFromRange(fromDay, toDay, slots, exceptDays = []) {
+  const fromIdx = WEEKDAYS.indexOf(fromDay);
+  const toIdx = WEEKDAYS.indexOf(toDay);
+  const except = new Set(exceptDays);
+  const days = [];
+  if (fromIdx <= toIdx) {
+    for (let i = fromIdx; i <= toIdx; i++) {
+      const d = WEEKDAYS[i];
+      if (!except.has(d)) days.push(d);
+    }
+  } else {
+    for (let i = fromIdx; i < 7; i++) {
+      const d = WEEKDAYS[i];
+      if (!except.has(d)) days.push(d);
+    }
+    for (let i = 0; i <= toIdx; i++) {
+      const d = WEEKDAYS[i];
+      if (!except.has(d)) days.push(d);
+    }
+  }
+  return { days, slots: [...slots] };
+}
+
+// src/opening-hours/format.ts
+function formatSlots(slots) {
+  return slots.map((s) => `${formatTimeDisplay(s.open)}\u2013${formatTimeDisplay(s.close)}`).join(", ");
+}
+function compressDayRanges(days) {
+  if (days.length === 0) return [];
+  const order = new Map(WEEKDAYS.map((d, i) => [d, i]));
+  const sorted = [...days].sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
+  const ranges = [];
+  let start = sorted[0];
+  let prev = sorted[0];
+  let prevIdx = order.get(prev) ?? 0;
+  const flush = (from, to) => {
+    if (from === to) {
+      ranges.push(WEEKDAY_LABELS_FR_SHORT[from]);
+    } else {
+      ranges.push(`${WEEKDAY_LABELS_FR_SHORT[from]}\u2013${WEEKDAY_LABELS_FR_SHORT[to]}`);
+    }
+  };
+  for (let i = 1; i < sorted.length; i++) {
+    const day = sorted[i];
+    const idx = order.get(day) ?? 0;
+    if (idx === prevIdx + 1) {
+      prev = day;
+      prevIdx = idx;
+    } else {
+      flush(start, prev);
+      start = day;
+      prev = day;
+      prevIdx = idx;
+    }
+  }
+  flush(start, prev);
+  return ranges;
+}
+function formatRulesSummary(rules) {
+  const parts = [];
+  for (const rule of rules) {
+    if (!rule.days.length || !rule.slots.length) continue;
+    const dayPart = compressDayRanges(rule.days).join(", ");
+    const slotPart = formatSlots(rule.slots);
+    parts.push(`${dayPart} ${slotPart}`);
+  }
+  return parts.join(" \xB7 ");
+}
+function formatOpeningHoursSummary(hours, timeZone) {
+  const rules = "storage" in hours && hours.storage === "utc" && timeZone ? convertUtcToLocal(hours, timeZone).rules : hours.rules;
+  return formatRulesSummary(rules);
+}
+function formatOpeningHoursWeekly(hours, timeZone) {
+  const rules = timeZone != null ? convertUtcToLocal(hours, timeZone).rules : hours.rules;
+  const byDay = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    for (const day of rule.days) {
+      const existing = byDay.get(day) ?? [];
+      byDay.set(day, [...existing, ...rule.slots]);
+    }
+  }
+  return WEEKDAYS.map((day) => {
+    const slots = byDay.get(day) ?? [];
+    return {
+      day,
+      label: WEEKDAY_LABELS_FR[day],
+      closed: slots.length === 0,
+      slots
+    };
+  });
+}
+function formatWeeklyRow(row) {
+  if (row.closed) return "Ferm\xE9";
+  return formatSlots(row.slots);
+}
+
+// src/opening-hours/resolve.ts
+function resolveHoursMode(details) {
+  if (!details) return "text";
+  const mode = details.hoursMode;
+  if (mode === "structured" || mode === "text") return mode;
+  if (details.openingHours != null) return "structured";
+  return "text";
+}
+function resolveOpeningHoursUtc(point) {
+  const details = point.details;
+  if (!details || resolveHoursMode(details) !== "structured") return null;
+  const raw = details.openingHours;
+  if (!raw || typeof raw !== "object") return null;
+  return raw;
+}
+function resolveOpeningHoursLocal(point, timeZone) {
+  const utc = resolveOpeningHoursUtc(point);
+  if (!utc) return null;
+  const tz = timeZone ?? getBrowserTimeZone();
+  return convertUtcToLocal(utc, tz);
+}
+function resolveHoursText(point) {
+  const details = point.details;
+  if (resolveHoursMode(details) === "text") {
+    const fromDetails = details?.hours;
+    if (typeof fromDetails === "string" && fromDetails.trim()) return fromDetails.trim();
+    if (typeof point.hours === "string" && point.hours.trim()) return point.hours.trim();
+    return null;
+  }
+  return null;
+}
+function resolveHoursDisplay(point, timeZone) {
+  const text = resolveHoursText(point);
+  if (text) return text;
+  const utc = resolveOpeningHoursUtc(point);
+  if (!utc) {
+    if (typeof point.hours === "string" && point.hours.trim()) return point.hours.trim();
+    return null;
+  }
+  const tz = timeZone ?? getBrowserTimeZone();
+  const summary = formatOpeningHoursSummary(utc, tz);
+  return summary || null;
+}
+function resolveHoursModeFromPoint(point) {
+  return resolveHoursMode(point.details ?? void 0);
+}
+
+// src/opening-hours/is-open-now.ts
+function isOpenNow(hours, at = /* @__PURE__ */ new Date()) {
+  const dateIso = utcDateIso(at);
+  const exceptions = hours.exceptions ?? [];
+  for (const exc of exceptions) {
+    if (exc.date !== dateIso) continue;
+    if (exc.closed) return false;
+    return isWithinSlots(exc.slots, at);
+  }
+  const weekday = weekdayFromUtcDate(at);
+  const rules = hours.rules.filter((r) => r.days.includes(weekday));
+  for (const rule of rules) {
+    if (isWithinSlots(rule.slots, at)) return true;
+  }
+  return false;
+}
+function isWithinSlots(slots, at) {
+  const nowMin = at.getUTCHours() * 60 + at.getUTCMinutes();
+  for (const slot of slots) {
+    const open = parseTimeMinutes(slot.open);
+    const close = parseTimeMinutes(slot.close);
+    if (open == null || close == null) continue;
+    if (nowMin >= open && nowMin < close) return true;
+  }
+  return false;
+}
+function openNowLabel(hours, at) {
+  return isOpenNow(hours, at) ? "Ouvert" : "Ferm\xE9";
+}
+
+// src/client.ts
+var WastoApiError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "WastoApiError";
+  }
+};
+function getHeaders(config, init) {
+  const token = config.getToken?.();
+  const headers = {
+    ...config.defaultHeaders ?? {},
+    ...init
+  };
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  const body = init?.body;
+  if (!headers["Content-Type"] && !(typeof FormData !== "undefined" && body instanceof FormData)) {
+    headers["Content-Type"] = "application/json";
+  }
+  return headers;
+}
+async function handleResponse(res) {
+  if (!res.ok) {
+    let message = `HTTP ${res.status}`;
+    try {
+      const text = await res.text();
+      if (text) {
+        try {
+          const json = JSON.parse(text);
+          message = json.message ?? json.error ?? text;
+        } catch {
+          message = text;
+        }
+      }
+    } catch {
+    }
+    throw new WastoApiError(message, res.status, void 0);
+  }
+  const contentType = res.headers.get("content-type");
+  if (contentType?.includes("application/json")) {
+    return res.json();
+  }
+  return res.text();
+}
+function createWastoClient(config) {
+  const base = config.baseUrl.replace(/\/$/, "");
+  const notifyRequestError = (err, context) => {
+    if (!config.onRequestError) return;
+    const error = err instanceof Error ? err : new Error(String(err));
+    const status = context.status ?? (error instanceof WastoApiError ? error.status : void 0);
+    try {
+      config.onRequestError(error, {
+        method: context.method,
+        url: context.url,
+        path: context.path,
+        status
+      });
+    } catch {
+    }
+  };
+  const request = async (path, options = {}) => {
+    const url = path.startsWith("http") ? path : `${base}${path.startsWith("/") ? path : `/${path}`}`;
+    const method = (options.method ?? "GET").toUpperCase();
+    try {
+      const res = await fetch(url, {
+        ...options,
+        headers: getHeaders(config, options.headers)
+      });
+      return await handleResponse(res);
+    } catch (err) {
+      notifyRequestError(err, { method, url, path });
+      throw err;
+    }
+  };
+  const requestPublic = async (path, options = {}) => {
+    const url = path.startsWith("http") ? path : `${base}${path.startsWith("/") ? path : `/${path}`}`;
+    const method = (options.method ?? "GET").toUpperCase();
+    const headers = {
+      ...options.headers
+    };
+    const body = options?.body;
+    if (!headers["Content-Type"] && !(typeof FormData !== "undefined" && body instanceof FormData)) {
+      headers["Content-Type"] = "application/json";
+    }
+    try {
+      const res = await fetch(url, { ...options, headers });
+      return await handleResponse(res);
+    } catch (err) {
+      notifyRequestError(err, { method, url, path });
+      throw err;
+    }
+  };
+  return {
+    request,
+    auth: {
+      login: (email, password) => request("/auth/login", {
+        method: "POST",
+        body: JSON.stringify({ email, password })
+      }),
+      register: (data) => request("/auth/register", {
+        method: "POST",
+        body: JSON.stringify(data)
+      }),
+      forgotPassword: (email) => request("/auth/forgot-password", {
+        method: "POST",
+        body: JSON.stringify({ email })
+      }),
+      resetPassword: (token, password) => request("/auth/reset-password", {
+        method: "POST",
+        body: JSON.stringify({ token, password })
+      }),
+      acceptInvite: (data) => request("/auth/accept-invite", {
+        method: "POST",
+        body: JSON.stringify(data)
+      }),
+      verify2fa: (pendingToken, code) => request("/auth/verify-2fa", {
+        method: "POST",
+        body: JSON.stringify({ pendingToken, code })
+      })
+    },
+    users: {
+      findAll: (params) => {
+        const q = new URLSearchParams();
+        if (params?.page != null) q.set("page", String(params.page));
+        if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+        const query = q.toString();
+        return request(`/users${query ? `?${query}` : ""}`);
+      },
+      getById: (id) => request(`/users/${id}`),
+      getMe: () => request("/users/me"),
+      create: (data) => request("/users", { method: "POST", body: JSON.stringify(data) }),
+      invite: (data) => request("/users/invite", { method: "POST", body: JSON.stringify(data) }),
+      update: (id, data) => request(`/users/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
+      updateMe: (data) => request("/users/me", { method: "PATCH", body: JSON.stringify(data) }),
+      remove: (id) => request(`/users/${id}`, { method: "DELETE" })
+    },
+    assets: {
+      findAll: (params) => {
+        const q = new URLSearchParams();
+        if (params?.page != null) q.set("page", String(params.page));
+        if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+        if (params?.cityId) q.set("cityId", params.cityId);
+        if (params?.cityGroupId) q.set("cityGroupId", params.cityGroupId);
+        if (params?.type) q.set("type", params.type);
+        if (params?.status) q.set("status", params.status);
+        const query = q.toString();
+        return request(`/assets${query ? `?${query}` : ""}`);
+      },
+      getMapLocations: (params) => {
+        const q = new URLSearchParams();
+        if (params?.page != null) q.set("page", String(params.page));
+        if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+        if (params?.cityId) q.set("cityId", params.cityId);
+        if (params?.cityGroupId) q.set("cityGroupId", params.cityGroupId);
+        if (params?.type) q.set("type", params.type);
+        if (params?.status) q.set("status", params.status);
+        const query = q.toString();
+        return request(`/assets/map/locations${query ? `?${query}` : ""}`);
+      },
+      getById: (id) => request(`/assets/${id}`),
+      create: (data) => request("/assets", { method: "POST", body: JSON.stringify(data) }),
+      update: (id, data) => request(`/assets/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
+      remove: (id) => request(`/assets/${id}`, { method: "DELETE" })
+    },
+    cities: {
+      findAll: (params) => {
+        const q = new URLSearchParams();
+        if (params?.page != null) q.set("page", String(params.page));
+        if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+        const query = q.toString();
+        return request(`/cities${query ? `?${query}` : ""}`);
+      },
+      getById: (id) => request(`/cities/${id}`),
+      create: (data) => request("/cities", { method: "POST", body: JSON.stringify(data) }),
+      update: (id, data) => request(`/cities/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
+      remove: (id) => request(`/cities/${id}`, { method: "DELETE" }),
+      wasteTypes: (cityId) => ({
+        /** @deprecated Préférez cityGroups.wasteTypes pour la gestion du catalogue. */
+        list: (params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return request(`/cities/${cityId}/waste-types${query ? `?${query}` : ""}`);
+        },
+        /** @deprecated Préférez cityGroups.wasteTypes.create */
+        create: (data) => request(`/cities/${cityId}/waste-types`, {
+          method: "POST",
+          body: JSON.stringify(data)
+        }),
+        getById: (id) => request(`/cities/${cityId}/waste-types/${id}`),
+        /** @deprecated Préférez cityGroups.wasteTypes.update */
+        update: (id, data) => request(`/cities/${cityId}/waste-types/${id}`, {
+          method: "PATCH",
+          body: JSON.stringify(data)
+        }),
+        /** @deprecated Délie la ville ; préférez cityGroups.wasteTypes.unlinkCity ou remove */
+        remove: (id) => request(`/cities/${cityId}/waste-types/${id}`, {
+          method: "DELETE"
+        })
+      }),
+      wasteCollectionPlaces: (cityId) => ({
+        list: (params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return request(`/cities/${cityId}/waste-collection-places${query ? `?${query}` : ""}`);
+        },
+        create: (data) => request(`/cities/${cityId}/waste-collection-places`, {
+          method: "POST",
+          body: JSON.stringify(data)
+        }),
+        getById: (id) => request(`/cities/${cityId}/waste-collection-places/${id}`),
+        update: (id, data) => request(`/cities/${cityId}/waste-collection-places/${id}`, {
+          method: "PATCH",
+          body: JSON.stringify(data)
+        }),
+        remove: (id) => request(`/cities/${cityId}/waste-collection-places/${id}`, {
+          method: "DELETE"
+        })
+      }),
+      quizQuestions: (cityId) => ({
+        list: (params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return request(`/cities/${cityId}/quiz-questions${query ? `?${query}` : ""}`);
+        },
+        create: (data) => request(`/cities/${cityId}/quiz-questions`, {
+          method: "POST",
+          body: JSON.stringify(data)
+        }),
+        getById: (id) => request(`/cities/${cityId}/quiz-questions/${id}`),
+        update: (id, data) => request(`/cities/${cityId}/quiz-questions/${id}`, {
+          method: "PATCH",
+          body: JSON.stringify(data)
+        }),
+        remove: (id) => request(`/cities/${cityId}/quiz-questions/${id}`, {
+          method: "DELETE"
+        })
+      }),
+      recyclingPoints: (cityId) => ({
+        list: (params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return request(`/cities/${cityId}/recycling-points${query ? `?${query}` : ""}`);
+        },
+        create: (data) => request(`/cities/${cityId}/recycling-points`, {
+          method: "POST",
+          body: JSON.stringify(data)
+        }),
+        getById: (id) => request(`/cities/${cityId}/recycling-points/${id}`),
+        update: (id, data) => request(`/cities/${cityId}/recycling-points/${id}`, {
+          method: "PATCH",
+          body: JSON.stringify(data)
+        }),
+        remove: (id) => request(`/cities/${cityId}/recycling-points/${id}`, {
+          method: "DELETE"
+        })
+      })
+    },
+    wasteTypeDetails: (wasteTypeId) => ({
+      list: (params) => {
+        const q = new URLSearchParams();
+        if (params?.page != null) q.set("page", String(params.page));
+        if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+        const query = q.toString();
+        return request(`/waste-types/${wasteTypeId}/details${query ? `?${query}` : ""}`);
+      },
+      create: (data) => request(`/waste-types/${wasteTypeId}/details`, {
+        method: "POST",
+        body: JSON.stringify(data)
+      }),
+      update: (id, data) => request(`/waste-types/${wasteTypeId}/details/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(data)
+      }),
+      remove: (id) => request(`/waste-types/${wasteTypeId}/details/${id}`, {
+        method: "DELETE"
+      })
+    }),
+    cityGroups: {
+      findAll: (params) => {
+        const q = new URLSearchParams();
+        if (params?.page != null) q.set("page", String(params.page));
+        if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+        const query = q.toString();
+        return request(`/city-groups${query ? `?${query}` : ""}`);
+      },
+      getById: (id) => request(`/city-groups/${id}`),
+      create: (data) => request("/city-groups", { method: "POST", body: JSON.stringify(data) }),
+      update: (id, data) => request(`/city-groups/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
+      remove: (id) => request(`/city-groups/${id}`, { method: "DELETE" }),
+      wasteTypes: (cityGroupId) => ({
+        list: (params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return request(
+            `/city-groups/${cityGroupId}/waste-types${query ? `?${query}` : ""}`
+          );
+        },
+        getById: (id) => request(`/city-groups/${cityGroupId}/waste-types/${id}`),
+        create: (data) => request(`/city-groups/${cityGroupId}/waste-types`, {
+          method: "POST",
+          body: JSON.stringify(data)
+        }),
+        update: (id, data) => request(`/city-groups/${cityGroupId}/waste-types/${id}`, {
+          method: "PATCH",
+          body: JSON.stringify(data)
+        }),
+        remove: (id) => request(`/city-groups/${cityGroupId}/waste-types/${id}`, {
+          method: "DELETE"
+        }),
+        linkCity: (wasteTypeId, cityId) => request(
+          `/city-groups/${cityGroupId}/waste-types/${wasteTypeId}/cities/${cityId}`,
+          { method: "POST" }
+        ),
+        unlinkCity: (wasteTypeId, cityId) => request(
+          `/city-groups/${cityGroupId}/waste-types/${wasteTypeId}/cities/${cityId}`,
+          { method: "DELETE" }
+        )
+      })
+    },
+    public: {
+      cities: {
+        findAll: (params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return requestPublic(`/public/cities${query ? `?${query}` : ""}`);
+        },
+        getById: (id) => requestPublic(`/public/cities/${id}`),
+        getWasteTypes: (cityId, params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return requestPublic(`/public/cities/${encodeURIComponent(cityId)}/waste-types${query ? `?${query}` : ""}`);
+        },
+        getWasteCollectionPlaces: (cityId, params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return requestPublic(`/public/cities/${encodeURIComponent(cityId)}/waste-collection-places${query ? `?${query}` : ""}`);
+        },
+        getRecyclingPoints: (cityId, params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return requestPublic(`/public/cities/${encodeURIComponent(cityId)}/recycling-points${query ? `?${query}` : ""}`);
+        },
+        getChallenges: (cityId, params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return requestPublic(`/public/cities/${encodeURIComponent(cityId)}/challenges${query ? `?${query}` : ""}`);
+        },
+        getBadges: (cityId, params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return requestPublic(`/public/cities/${encodeURIComponent(cityId)}/badges${query ? `?${query}` : ""}`);
+        },
+        getOperationalZones: (cityId, params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return requestPublic(`/public/cities/${encodeURIComponent(cityId)}/operational-zones${query ? `?${query}` : ""}`);
+        },
+        searchStreetSectors: (cityId, params) => {
+          const q = new URLSearchParams();
+          q.set("q", params.q);
+          if (params.cityGroupId) q.set("cityGroupId", params.cityGroupId);
+          return requestPublic(
+            `/public/cities/${encodeURIComponent(cityId)}/street-sectors?${q.toString()}`
+          );
+        },
+        getCalendarPdfUrl: (cityId, placeId, year) => {
+          const q = new URLSearchParams();
+          if (year != null) q.set("year", String(year));
+          const query = q.toString();
+          return `${base}/public/cities/${encodeURIComponent(cityId)}/places/${encodeURIComponent(placeId)}/calendar-pdf${query ? `?${query}` : ""}`;
+        },
+        getCalendarPrintUrl: (cityId, placeId, year, preview = false) => {
+          const q = new URLSearchParams();
+          if (year != null) q.set("year", String(year));
+          if (preview) q.set("preview", "1");
+          const query = q.toString();
+          return `${base}/public/cities/${encodeURIComponent(cityId)}/places/${encodeURIComponent(placeId)}/calendar-print${query ? `?${query}` : ""}`;
+        }
+      },
+      challenges: {
+        list: (cityId, params) => {
+          const q = new URLSearchParams();
+          if (cityId != null) q.set("cityId", cityId);
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return requestPublic(`/public/challenges${query ? `?${query}` : ""}`);
+        },
+        getById: (id) => requestPublic(`/public/challenges/${id}`),
+        getSeries: (id) => requestPublic(`/public/challenges/${id}/series`),
+        complete: (id, body) => requestPublic(`/public/challenges/${id}/complete`, {
+          method: "POST",
+          body: JSON.stringify(body)
+        }),
+        getProgress: (deviceId) => requestPublic(`/public/challenges/progress/${encodeURIComponent(deviceId)}`)
+      },
+      blogPosts: {
+        list: (cityGroupId, params) => {
+          const q = new URLSearchParams();
+          if (cityGroupId != null) q.set("cityGroupId", cityGroupId);
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return requestPublic(`/public/blog-posts${query ? `?${query}` : ""}`);
+        },
+        getById: (id) => requestPublic(`/public/blog-posts/${id}`)
+      },
+      announcements: {
+        listForCity: (cityId) => requestPublic(`/public/announcements?cityId=${encodeURIComponent(cityId)}`)
+      },
+      cityGroups: {
+        searchStreetSectors: (cityGroupId, params) => {
+          const q = new URLSearchParams();
+          q.set("q", params.q);
+          return requestPublic(
+            `/public/city-groups/${encodeURIComponent(cityGroupId)}/street-sectors?${q.toString()}`
+          );
+        }
+      },
+      tickets: {
+        getForms: (params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return requestPublic(`/public/tickets/forms${query ? `?${query}` : ""}`);
+        },
+        getForm: (id) => requestPublic(`/public/tickets/forms/${id}`),
+        create: (data) => requestPublic("/public/tickets", {
+          method: "POST",
+          body: JSON.stringify(data)
+        }),
+        getByAccessKey: (accessKey) => requestPublic(`/public/tickets/${encodeURIComponent(accessKey)}`)
+      },
+      chat: {
+        getAvailability: (params) => {
+          const q = new URLSearchParams();
+          if (typeof params === "string") {
+            q.set("cityId", params);
+          } else {
+            if (params.cityGroupId) q.set("cityGroupId", params.cityGroupId);
+            if (params.cityId) q.set("cityId", params.cityId);
+          }
+          return requestPublic(`/public/chat/availability?${q.toString()}`);
+        },
+        createConversation: (body) => requestPublic("/public/chat/conversations", {
+          method: "POST",
+          body: JSON.stringify(body)
+        }),
+        setConversationLocation: (conversationId, body) => requestPublic(
+          `/public/chat/conversations/${encodeURIComponent(conversationId)}/location`,
+          {
+            method: "PATCH",
+            body: JSON.stringify(body)
+          }
+        ),
+        getConversations: (deviceId, params) => {
+          const q = new URLSearchParams();
+          if (params?.page != null) q.set("page", String(params.page));
+          if (params?.pageSize != null) q.set("pageSize", String(params.pageSize));
+          const query = q.toString();
+          return requestPublic(`/public/chat/conversations/${encodeURIComponent(deviceId)}${query ? `?${query}` : ""}`);
+        },
+        getMessages: (conversationId) => requestPublic(`/public/chat/conversations/${conversationId}/messages`),
+        sendMessage: (conversationId, body) => requestPublic(`/public/chat/conversations/${conversationId}/messages`, {
+          method: "POST",
+          body: JSON.stringify(body)
+        })
+      },
+      devices: {
+        registerPushToken: (deviceId, body) => requestPublic(`/public/devices/${encodeURIComponent(deviceId)}/push-token`, {
+          method: "POST",
+          body: JSON.stringify(body)
+        })
+      },
+      analytics: {
+        track: (payload) => requestPublic("/public/analytics/track", {
+          method: "POST",
+          body: JSON.stringify(payload)
+        }),
+        delete: (deviceId) => requestPublic(`/public/analytics/delete/${encodeURIComponent(deviceId)}`, {
+          method: "DELETE"
+        })
+      },
+      cms: {
+        getPageById: (id) => requestPublic(`/public/cms/pages/${encodeURIComponent(id)}`),
+        getSiteBySlug: (slug) => requestPublic(`/public/cms/sites/${encodeURIComponent(slug)}`),
+        getAppBySlug: (slug) => requestPublic(`/public/cms/apps/${encodeURIComponent(slug)}`),
+        getAppMenuById: (appSlug, menuId) => requestPublic(
+          `/public/cms/apps/${encodeURIComponent(appSlug)}/menus/by-id/${encodeURIComponent(menuId)}`
+        )
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssetEventType,
+  AssetStatus,
+  AssetType,
+  BookingStatus,
+  CITEO_DOM_MULTIPLIERS,
+  CalendoEventStatus,
+  CalendoEventType,
+  CalendoTicketSaleStatus,
+  ChatMessageRole,
+  ChatStatus,
+  CityGroupType,
+  CityStatus,
+  CmsMenuLinkType,
+  CmsSiteType,
+  DASHBOARD_APPS,
+  DASHBOARD_APP_BY_KEY,
+  DASHBOARD_APP_BY_SLUG,
+  DEFAULT_ENABLED_DASHBOARD_APP_SLUGS,
+  DEFAULT_PAGE,
+  DEFAULT_PAGE_SIZE,
+  DOM_INSEE_PREFIXES,
+  DashboardAppSlug,
+  FREE_SELF_SERVE_DASHBOARD_APP_SLUGS,
+  FREE_TIER_FEATURES,
+  FREE_TIER_FEATURE_KEYS,
+  FREE_TIER_LIMITS,
+  FREE_TIER_RESOURCES,
+  FieldReportFormStatus,
+  FieldReportStatus,
+  InterventionStatus,
+  InterventionType,
+  MAX_PAGE_SIZE,
+  MapEventStatus,
+  MapEventType,
+  MapPoiCategory,
+  MapPoiStatus,
+  MapZoneType,
+  NotificationDeliveryStatus,
+  NotificationStatus,
+  ONBOARDING_RESTRICTED_APP_SLUGS,
+  OperationalZoneStatus,
+  OperationalZoneType,
+  PRESET_SLOTS,
+  PermissionAction,
+  PermissionResource,
+  ProviderType,
+  QuestionType,
+  ROI_DEFAULTS,
+  ROI_DISCLAIMER,
+  ROI_SCENARIO_DEFS,
+  RecipientGroupType,
+  ResponseStatus,
+  SurveyMode,
+  SurveyStatus,
+  TGAP_LANDFILL_EUR_PER_TONNE,
+  TerritoryActionStatus,
+  TerritoryActionType,
+  TicketFormStatus,
+  TicketStatus,
+  UserRole,
+  WASTO_LANDINGS_DOMAIN,
+  WASTO_LANDINGS_INDEX_HOST,
+  WASTO_RESERVED_SUBDOMAINS,
+  WASTO_SECTIONS,
+  WASTO_SECTION_BY_KEY,
+  WEEKDAYS,
+  WEEKDAY_INDEX,
+  WEEKDAY_LABELS_FR,
+  WEEKDAY_LABELS_FR_SHORT,
+  WEEKDAY_REF_DATES,
+  WastoApiError,
+  addDaysToIsoDate,
+  adjustCostPerBadTonneForTgap,
+  allocateSavingsByAction,
+  applyCiteoDomMultiplier,
+  applyStackedErrorReductions,
+  buildBauVsRealSeries,
+  buildPaginationMeta,
+  computeActionImpactConfidence,
+  computeGec,
+  computeOverallConfidence,
+  computePenetrationRate,
+  computeRoiIndicators,
+  convertLocalToUtc,
+  convertUtcToLocal,
+  createEmptyLocalRules,
+  createEmptyOpeningHours,
+  createWastoClient,
+  currentFiscalYear,
+  dashboardAppKeyFromLandingHost,
+  dashboardAppKeyToSlug,
+  dashboardAppSlugToKey,
+  detectDomTerritory,
+  estimateHouseholds,
+  formatOpeningHoursSummary,
+  formatOpeningHoursWeekly,
+  formatTimeDisplay,
+  formatTimeMinutes,
+  formatWeeklyRow,
+  getBrowserTimeZone,
+  getFreeTierLimit,
+  getFreeTierMediaBytesLimit,
+  getTgapEurPerTonne,
+  getTimezoneOffsetMinutes,
+  isActionCountedInRoi,
+  isDashboardAppLandingHost,
+  isDomInseeCode,
+  isFreeSelfServeAppAccess,
+  isFreeTierFeatureEnabled,
+  isOpenNow,
+  localDateTimeToUtc,
+  localRulesFromRange,
+  nextWeekday,
+  normalizeDashboardAppSlug,
+  openNowLabel,
+  parseTimeMinutes,
+  refDateForWeekday,
+  resolveDashboardAppLandingUrl,
+  resolveEnabledDashboardAppSlugs,
+  resolveHoursDisplay,
+  resolveHoursMode,
+  resolveHoursModeFromPoint,
+  resolveHoursText,
+  resolveOpeningHoursLocal,
+  resolveOpeningHoursUtc,
+  resolveWastoLandingsIndexUrl,
+  roundEuro,
+  simulateTerritory100kExample,
+  slotsOverlap,
+  sortSlots,
+  utcDateIso,
+  utcHhmmFromDate,
+  validateLocalOpeningHours,
+  validateOpeningHours,
+  weekdayFromUtcDate
+});