@jjlmoya/utils-pets 1.19.0 → 1.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-pets",
-    "version": "1.19.0",
+    "version": "1.20.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -3,10 +3,11 @@ import { petAge } from '../tool/petAge/entry';
 import { petRation } from '../tool/petRation/entry';
 import { petGestation } from '../tool/petGestation/entry';
 import { petToxicity } from '../tool/petToxicity/entry';
+import { petWaterIntake } from '../tool/petWaterIntake/entry';
 
 export const petsCategory: PetCategoryEntry = {
   icon: 'mdi:paw',
-  tools: [petAge, petRation, petGestation, petToxicity],
+  tools: [petAge, petRation, petGestation, petToxicity, petWaterIntake],
   i18n: {
     en: () => import('./i18n/en').then((m) => m.content),
     es: () => import('./i18n/es').then((m) => m.content),

package/src/entries.ts

@@ -4,9 +4,12 @@ export { petRation } from './tool/petRation/entry';
 export type { PetRationUI, PetRationLocaleContent } from './tool/petRation/entry';
 export { petToxicity } from './tool/petToxicity/entry';
 export type { PetToxicityUI, PetToxicityLocaleContent } from './tool/petToxicity/entry';
+export { petWaterIntake } from './tool/petWaterIntake/entry';
+export type { PetWaterIntakeUI, PetWaterIntakeLocaleContent } from './tool/petWaterIntake/entry';
 export { petsCategory } from './category';
 import { petAge } from './tool/petAge/entry';
 import { petRation } from './tool/petRation/entry';
 import { petGestation } from './tool/petGestation/entry';
 import { petToxicity } from './tool/petToxicity/entry';
-export const ALL_ENTRIES = [petAge, petRation, petGestation, petToxicity];
+import { petWaterIntake } from './tool/petWaterIntake/entry';
+export const ALL_ENTRIES = [petAge, petRation, petGestation, petToxicity, petWaterIntake];

package/src/tests/locale_completeness.test.ts

@@ -26,6 +26,6 @@ describe('Locale Completeness Validation', () => {
   });
 
   it('all tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(4);
+    expect(ALL_TOOLS.length).toBe(5);
   });
 });

package/src/tests/tool_validation.test.ts

@@ -55,7 +55,7 @@ describe('Tool Validation Suite', () => {
         });
 
         it('should have valid ID in kebab-case', () => {
-          expect(entry.id).toMatch(/^[a-z0-9]+-?[a-z0-9]*$/);
+          expect(entry.id).toMatch(/^[a-z0-9]+(-[a-z0-9]+)*$/);
         });
 
         it('should have valid icons with bg and fg', () => {
@@ -71,7 +71,7 @@ describe('Tool Validation Suite', () => {
               expect(content.slug).toMatch(/^[a-z0-9]+(-[a-z0-9]+)*$/);
 
               if (locale === 'es') {
-                const validSlugs = ['calculadora-edad-mascotas', 'calculadora-racion-diaria-mascotas', 'calculadora-gestacion-mascotas', 'buscador-alimentos-toxicos-perros-gatos'];
+                const validSlugs = ['calculadora-edad-mascotas', 'calculadora-racion-diaria-mascotas', 'calculadora-gestacion-mascotas', 'buscador-alimentos-toxicos-perros-gatos', 'calculadora-agua-diaria-perros-gatos'];
                 expect(validSlugs).toContain(content.slug);
               }
             });
@@ -96,12 +96,12 @@ describe('Tool Validation Suite', () => {
   });
 
   describe('Library Registration', () => {
-    it('should have 4 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(4);
+    it('should have 5 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(5);
     });
 
     it('should have all tools in petsCategory', () => {
-      expect(petsCategory.tools.length).toBe(4);
+      expect(petsCategory.tools.length).toBe(5);
       ALL_TOOLS.forEach(({ entry }) => {
         const exists = petsCategory.tools.some((t: any) => t.id === entry.id);
         expect(exists).toBe(true);

package/src/tool/petWaterIntake/bibliography.astro

@@ -0,0 +1,6 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { bibliography } from './bibliography';
+---
+
+<SharedBibliography links={bibliography} />

package/src/tool/petWaterIntake/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'AAHA Anesthesia and Monitoring Guidelines for Dogs and Cats: Fluid Therapy and Maintenance Guidelines',
+    url: 'https://www.aaha.org/resources/fluid-therapy-guidelines/',
+  },
+  {
+    name: 'Merck Veterinary Manual: Management of Fluid Therapy in Dogs and Cats',
+    url: 'https://www.merckvetmanual.com/emergency-medicine-and-critical-care/fluid-therapy/fluid-therapy-in-animals',
+  },
+  {
+    name: 'WSAVA Global Nutrition Committee: Recommendations for Water Needs in Companion Animals',
+    url: 'https://wsava.org/global-guidelines/global-nutrition-guidelines/',
+  },
+];

package/src/tool/petWaterIntake/component.astro

@@ -0,0 +1,103 @@
+---
+import './pet-water-intake.css';
+import { calculatePetWaterIntake } from './logic';
+import { renderResult, renderScene } from './dom-views';
+import { petWaterIntake } from './entry';
+
+const content = await petWaterIntake.i18n.en?.();
+if (!content) return null;
+const { ui } = content;
+
+const defaultSpecies = 'dog';
+const defaultWeight = 10;
+const defaultDiet = 'dry';
+const defaultActivity = 'typical';
+const defaultHeat = 'normal';
+
+const initialRes = calculatePetWaterIntake({
+  species: defaultSpecies,
+  weightKg: defaultWeight,
+  diet: defaultDiet,
+  activity: defaultActivity,
+  heat: defaultHeat,
+});
+
+const config = { ui };
+---
+
+<section class="pet-water-intake" data-pet-water-root aria-label={content.title}>
+  <div class="pet-water-journey">
+    <span class="pet-water-journey-mark" aria-hidden="true">
+      <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <path d="M12 2.69l5.66 5.66a8 8 0 1 1-11.31 0z"></path>
+      </svg>
+    </span>
+    <p>{ui.journeyHint}</p>
+  </div>
+  <div class="pet-water-workbench">
+    <form class="pet-water-controls" data-water-form onsubmit="return false;">
+      <div class="pet-water-control">
+        <span class="pet-water-label">{ui.speciesLegend}</span>
+        <div class="pet-water-radio-group">
+          <label>
+            <input type="radio" name="species" value="dog" checked />
+            {ui.speciesDog}
+          </label>
+          <label>
+            <input type="radio" name="species" value="cat" />
+            {ui.speciesCat}
+          </label>
+        </div>
+      </div>
+      <div class="pet-water-control">
+        <label for="pet-water-weight-input" class="pet-water-label">{ui.weightLabel} ({ui.weightKg})</label>
+        <input
+          id="pet-water-weight-input"
+          type="number"
+          name="weight"
+          class="pet-water-input"
+          value={defaultWeight}
+          min="0.5"
+          max="100"
+          step="0.5"
+        />
+        <small>{ui.weightHint}</small>
+      </div>
+      <div class="pet-water-control">
+        <label for="pet-water-diet-select" class="pet-water-label">{ui.dietLegend}</label>
+        <select id="pet-water-diet-select" name="diet" class="pet-water-select">
+          <option value="dry" selected>{ui.dietDry}</option>
+          <option value="mixed">{ui.dietMixed}</option>
+          <option value="wet">{ui.dietWet}</option>
+        </select>
+      </div>
+      <div class="pet-water-control">
+        <label for="pet-water-activity-select" class="pet-water-label">{ui.activityLegend}</label>
+        <select id="pet-water-activity-select" name="activity" class="pet-water-select">
+          <option value="calm">{ui.activityCalm}</option>
+          <option value="typical" selected>{ui.activityTypical}</option>
+          <option value="active">{ui.activityActive}</option>
+        </select>
+      </div>
+      <div class="pet-water-control">
+        <label for="pet-water-heat-select" class="pet-water-label">{ui.heatLegend}</label>
+        <select id="pet-water-heat-select" name="heat" class="pet-water-select">
+          <option value="normal" selected>{ui.heatNormal}</option>
+          <option value="warm">{ui.heatWarm}</option>
+          <option value="hot">{ui.heatHot}</option>
+        </select>
+      </div>
+    </form>
+    <div class="pet-water-visual" data-scene set:html={renderScene(initialRes, ui)}></div>
+  </div>
+  <div class="pet-water-result" data-result aria-live="polite" set:html={renderResult(initialRes, ui)}></div>
+</section>
+
+<script is:inline type="application/json" data-pet-water-config set:html={JSON.stringify(config)}></script>
+<script>
+  import { mountPetWaterIntake } from './controller';
+
+  const root = document.querySelector<HTMLElement>('[data-pet-water-root]');
+  const configElement = document.querySelector<HTMLScriptElement>('[data-pet-water-config]');
+  if (root && configElement?.textContent) mountPetWaterIntake(root, JSON.parse(configElement.textContent));
+</script>

package/src/tool/petWaterIntake/controller.ts

@@ -0,0 +1,47 @@
+import type { WaterCalculationInput } from './logic';
+import { calculatePetWaterIntake } from './logic';
+import { renderResult, renderScene } from './dom-views';
+import type { PetWaterIntakeUI } from './ui';
+
+export interface PetWaterIntakeConfig {
+  ui: PetWaterIntakeUI;
+}
+
+function parseFormString(data: FormData, key: string, fallback: string): string {
+  const val = data.get(key);
+  return typeof val === 'string' && val.length > 0 ? val : fallback;
+}
+
+function getWaterInput(form: HTMLFormElement): WaterCalculationInput | null {
+  const data = new FormData(form);
+  const weightVal = parseFloat(parseFormString(data, 'weight', '0'));
+  if (isNaN(weightVal) || weightVal <= 0 || weightVal > 100) return null;
+
+  return {
+    species: parseFormString(data, 'species', 'dog') as WaterCalculationInput['species'],
+    weightKg: weightVal,
+    diet: parseFormString(data, 'diet', 'dry') as WaterCalculationInput['diet'],
+    activity: parseFormString(data, 'activity', 'typical') as WaterCalculationInput['activity'],
+    heat: parseFormString(data, 'heat', 'normal') as WaterCalculationInput['heat'],
+  };
+}
+
+export function mountPetWaterIntake(root: HTMLElement, config: PetWaterIntakeConfig): void {
+  const { ui } = config;
+  const form = root.querySelector<HTMLFormElement>('[data-water-form]');
+  const sceneEl = root.querySelector<HTMLElement>('[data-scene]');
+  const resultEl = root.querySelector<HTMLElement>('[data-result]');
+
+  if (!form || !sceneEl || !resultEl) return;
+
+  function update(): void {
+    const input = getWaterInput(form!);
+    const res = input ? calculatePetWaterIntake(input) : null;
+    sceneEl!.innerHTML = renderScene(res, ui);
+    resultEl!.innerHTML = renderResult(res, ui);
+  }
+
+  form.addEventListener('input', update);
+  form.addEventListener('change', update);
+  update();
+}

package/src/tool/petWaterIntake/dom-views.ts

@@ -0,0 +1,54 @@
+import type { WaterCalculationResult } from './logic';
+import type { PetWaterIntakeUI } from './ui';
+
+export function renderScene(res: WaterCalculationResult | null, ui: PetWaterIntakeUI): string {
+  if (!res) {
+    return `<div class="pet-water-scene-empty">${ui.resultEmpty}</div>`;
+  }
+  const pct = Math.min(100, Math.max(15, Math.round((res.totalMlMax / 1500) * 100)));
+  return `
+    <div class="pet-water-scene" aria-label="${ui.sceneAria}">
+      <div class="pet-water-reservoir">
+        <div class="pet-water-fill" style="height: ${pct}%">
+          <div class="pet-water-wave"></div>
+        </div>
+      </div>
+      <div class="pet-water-badge">
+        <span class="pet-water-badge-label">${ui.sceneTotal}</span>
+        <span class="pet-water-badge-value">${res.totalMlMin} - ${res.totalMlMax} mL</span>
+      </div>
+    </div>
+  `;
+}
+
+export function renderResult(res: WaterCalculationResult | null, ui: PetWaterIntakeUI): string {
+  if (!res) return `<div class="pet-water-result-placeholder">${ui.resultEmpty}</div>`;
+
+  const metrics = `
+    <div class="pet-water-metrics">
+      <div class="pet-water-metric">
+        <span class="pet-water-metric-label">${ui.totalRangeLabel}</span>
+        <span class="pet-water-metric-value">${res.totalMlMin} - ${res.totalMlMax} mL/día</span>
+        <small>${ui.totalRangeHint}</small>
+      </div>
+      <div class="pet-water-metric">
+        <span class="pet-water-metric-label">${ui.drinkingRangeLabel}</span>
+        <span class="pet-water-metric-value">${res.bowlMlMin} - ${res.bowlMlMax} mL/día</span>
+        <small>${ui.drinkingRangeHint}</small>
+      </div>
+    </div>`;
+
+  return `
+    <div class="pet-water-result-card">
+      <span class="pet-water-eyebrow">${ui.resultEyebrow}</span>
+      ${metrics}
+      <div class="pet-water-status">
+        <strong>${ui[res.statusKey] || ''}</strong>
+        <p>${ui[res.statusDetailKey] || ''}</p>
+      </div>
+      <div class="pet-water-notes">
+        <h4>${ui.noteTitle}</h4>
+        <p>${ui.noteText}</p>
+      </div>
+    </div>`;
+}

package/src/tool/petWaterIntake/entry.ts

@@ -0,0 +1,33 @@
+import type { PetToolEntry, ToolLocaleContent } from '../../types';
+import type { PetWaterIntakeUI } from './ui';
+
+export type { PetWaterIntakeUI } from './ui';
+
+export type PetWaterIntakeLocaleContent = ToolLocaleContent<PetWaterIntakeUI>;
+
+export const petWaterIntake: PetToolEntry<PetWaterIntakeUI> = {
+  id: 'pet-water-intake',
+  icons: {
+    bg: 'mdi:paw',
+    fg: 'mdi:water',
+  },
+  i18n: {
+    de: () => import('./i18n/de').then((module) => module.content),
+    en: () => import('./i18n/en').then((module) => module.content),
+    es: () => import('./i18n/es').then((module) => module.content),
+    fr: () => import('./i18n/fr').then((module) => module.content),
+    id: () => import('./i18n/id').then((module) => module.content),
+    it: () => import('./i18n/it').then((module) => module.content),
+    ja: () => import('./i18n/ja').then((module) => module.content),
+    ko: () => import('./i18n/ko').then((module) => module.content),
+    nl: () => import('./i18n/nl').then((module) => module.content),
+    pl: () => import('./i18n/pl').then((module) => module.content),
+    pt: () => import('./i18n/pt').then((module) => module.content),
+    ru: () => import('./i18n/ru').then((module) => module.content),
+    sv: () => import('./i18n/sv').then((module) => module.content),
+    tr: () => import('./i18n/tr').then((module) => module.content),
+    zh: () => import('./i18n/zh').then((module) => module.content),
+  },
+};
+
+export { bibliography } from './bibliography';

package/src/tool/petWaterIntake/i18n/de.ts

@@ -0,0 +1,205 @@
+import { bibliography } from '../bibliography';
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { PetWaterIntakeLocaleContent, PetWaterIntakeUI } from '../entry';
+
+const slug = 'wasserbedarf-rechner-hunde-katzen';
+const title = 'Täglicher Wasserbedarf Rechner für Hunde und Katzen';
+const description = 'Berechnen Sie den täglichen Wasserbedarf Ihres Hundes oder Ihrer Katze basierend auf Gewicht, Fütterung, Aktivität und Umgebungstemperatur.';
+
+const ui: PetWaterIntakeUI = {
+  journeyHint: 'Wählen Sie das Tier aus, geben Sie das Körpergewicht ein und stellen Sie Futterart und Klima ein.',
+  instantHint: 'Jede Option passt den Wasserstand sofort an. Es handelt sich um eine Richtlinie.',
+  unitLegend: 'Einheiten',
+  metricUnit: 'Metrisch',
+  imperialUnit: 'Imperial',
+  speciesLegend: 'Für wen ist der Wassernapf?',
+  speciesDog: 'Hund',
+  speciesCat: 'Katze',
+  speciesDogMeta: 'Richtwert 60 mL pro kg',
+  speciesCatMeta: 'Richtwert 40 mL pro kg',
+  weightLabel: 'Körpergewicht',
+  weightHint: 'Geben Sie das aktuelle gesunde Gewicht an.',
+  weightKg: 'kg',
+  weightLb: 'lb',
+  dietLegend: 'Wie viel Wasser liefert das Futter?',
+  dietDry: 'Überwiegend Trockenfutter',
+  dietDryMeta: 'Der Großteil des Wassers wird getrunken',
+  dietMixed: 'Mischfütterung',
+  dietMixedMeta: 'Ein Teil des Wassers stammt aus den Mahlzeiten',
+  dietWet: 'Überwiegend Nassfutter',
+  dietWetMeta: 'Nassfutter liefert einen großen Teil der Feuchtigkeit',
+  activityLegend: 'Aktivität heute',
+  activityCalm: 'Ruhig',
+  activityTypical: 'Normal',
+  activityActive: 'Sehr aktiv',
+  heatLegend: 'Wetter und Temperatur',
+  heatNormal: 'Normal',
+  heatWarm: 'Warm',
+  heatHot: 'Sehr heiß',
+  resultEyebrow: 'Wasserstandsanzeige',
+  totalRangeLabel: 'Gesamter Wasserbedarf (alle Quellen)',
+  drinkingRangeLabel: 'Richtwert für den Wassernapf',
+  totalRangeHint: 'Täglicher Zielbereich inklusive Futterfeuchtigkeit.',
+  drinkingRangeHint: 'Geschätzter Anteil, der getrunken werden sollte.',
+  statusEveryday: 'Standardbedingungen',
+  statusActive: 'Aktiver Tag',
+  statusWarm: 'Warmes Wetter',
+  statusDemanding: 'Hohe Anforderungen',
+  statusDetailEveryday: 'Nutzt den Grundbedarf ohne zusätzliche Hitze- oder Aktivitätsfaktoren.',
+  statusDetailActive: 'Bewegung erhöht den Bedarf. Stellen Sie stets frisches Wasser bereit.',
+  statusDetailWarm: 'Hitze steigert den Verlust durch Hecheln. Schatten hat Priorität.',
+  statusDetailDemanding: 'Kombination aus hoher Aktivität und Hitze. Beobachten Sie das Tier genau.',
+  resultEmpty: 'Geben Sie ein gültiges Gewicht ein, um den Wasserbedarf anzuzeigen.',
+  sceneAria: 'Wasserbehälter für das ausgewählte Tier',
+  sceneTotal: 'GESAMTWASSER',
+  sceneBowl: 'Mitte des täglichen Bereichs',
+  methodTitle: 'Berechnungsmethode',
+  methodText: 'Basiert auf den AAHA-Richtwerten von 60 mL/kg für Hunde und 40 mL/kg für Katzen mit Anpassung an Futter und Wetter.',
+  noteTitle: 'Wassernäpfe ersetzen keine Diagnostik',
+  noteText: 'Halten Sie immer frisches Wasser bereit. Bei plötzlichen Veränderungen der Trinkmenge suchen Sie einen Tierarzt auf.',
+  invalidWeight: 'Bitte geben Sie ein gültiges Körpergewicht ein.',
+  weightRange: 'Das Gewicht muss zwischen 0.5 kg und 100 kg liegen.',
+};
+
+const faq: PetWaterIntakeLocaleContent['faq'] = [
+  {
+    question: 'Wie viel Wasser sollte ein Hund oder eine Katze am Tag trinken?',
+    answer: 'Tierärztliche Richtlinien der AAHA empfehlen einen Erhaltungsbedarf von ca. 60 mL pro kg Körpergewicht bei Hunden und 40 mL pro kg bei Katzen pro Tag. Die tatsächliche Trinkmenge schwankt je nach Futterart, Temperatur und Bewegung.',
+  },
+  {
+    question: 'Reduziert Nassfutter die Trinkmenge aus dem Napf?',
+    answer: 'Ja, Nassfutter besteht zu 75% bis 82% aus Feuchtigkeit und deckt einen Großteil des Tagesbedarfs ab. Tiere bei Nassfütterung trinken daher deutlich seltener zusätzlich aus der Wasserschale.',
+  },
+  {
+    question: 'Wann sollte ich mir wegen des Trinkverhaltens Sorgen machen?',
+    answer: 'Suchen Sie einen Tierarzt auf, wenn Sie plötzlichen extremen Durst (Polydipsie) oder völlige Wasserverweigerung (Adipsia) bemerken. Dies können Anzeichen für Diabetes oder Nierenerkrankungen sein.',
+  },
+  {
+    question: 'Können Hitze und Bewegung den Wasserbedarf verdoppeln?',
+    answer: 'Ja. Hohe Temperaturen und Bewegung erhöhen den Verdunstungsverlust durch Hecheln erheblich. Schattige Ruheplätze und kühles Trinkwasser sind dann essenziell.',
+  },
+];
+
+const howTo: PetWaterIntakeLocaleContent['howTo'] = [
+  { name: 'Tierart und Gewicht wählen', text: 'Wählen Sie Hund oder Katze und tragen Sie das aktuelle gesunde Körpergewicht in kg oder lb ein.' },
+  { name: 'Futterart angeben', text: 'Wählen Sie Trockenfutter, Mischfütterung oder Nassfutter, um die Feuchtigkeit aus den Mahlzeiten einzurechnen.' },
+  { name: 'Aktivität und Klima anpassen', text: 'Stellen Sie das Bewegungslevel und die Temperatur ein, um den Verlust durch Hecheln zu berücksichtigen.' },
+  { name: 'Empfehlungen ablesen', text: 'Prüfen Sie den Gesamtwasserbedarf sowie den geschätzten Richtwert für die reine Trinkmenge aus dem Napf.' },
+];
+
+const seo: PetWaterIntakeLocaleContent['seo'] = [
+  {
+    type: 'summary',
+    title: 'Wichtige Richtlinien für den täglichen Wasserbedarf von Haustieren',
+    items: [
+      'Grundlegende Erhaltung: Hunde benötigen täglich ca. 60 mL/kg Körpergewicht; Katzen benötigen ca. 40 mL/kg gemäß AAHA-Empfehlungen.',
+      'Einfluss der Ernährung: Feuchtfutter liefert 70-80% Feuchtigkeit und reduziert die Besuche am Wassernapf erheblich.',
+      'Hitze & Bewegung: Durch Hecheln steigt der Verdunstungsverlust, was den täglichen Hydratationsbedarf spürbar erhöht.',
+      'Gesundheitliche Warnzeichen: Plötzlicher starker Durst oder Verweigerung von Wasser erfordert sofortige tierärztliche Abklärung.',
+      'Zugang zu Frischwasser: Mehrere saubere Wassernäpfe an ruhigen Orten fördern ein gesundes und regelmäßiges Trinkverhalten.',
+    ],
+  },
+  {
+    type: 'title',
+    text: 'Tägliche Flüssigkeitsberechnung und Hydratation für Hunde und Katzen',
+    level: 2,
+  },
+  {
+    type: 'paragraph',
+    html: 'Eine ausreichende und kontinuierliche Hydratation von Hunden und Katzen ist eine grundlegende Voraussetzung für den Stoffwechsel, die Verdauung, die Gelenkschmierung, die Thermoregulation und die langfristige Nierenfunktion. Wasser macht etwa 60% bis 70% des gesamten Körpergewichts eines ausgewachsenen Haustieres aus, und selbst ein geringfügiges Flüssigkeitsdefizit kann lebenswichtige physiologische Prozesse beeinträchtigen. Die veterinärmedizinische Fachliteratur der American Animal Hospital Association (AAHA) legt den täglichen Grundbedarf auf ca. 60 mL pro Kilogramm Körpergewicht bei Hunden und 40 mL pro Kilogramm bei Katzen fest.',
+  },
+  {
+    type: 'paragraph',
+    html: 'Diese wissenschaftlichen Orientierungswerte stellen jedoch den Gesamtwasserbedarf dar und nicht die reine Trinkmenge aus der Wasserschale. Die tägliche Flüssigkeitsaufnahme eines Tieres setzt sich aus drei Hauptquellen zusammen: dem direkt getrunkenen Wasser, der im kommerziellen oder selbst zubereiteten Futter enthaltenen Feuchtigkeit sowie einer kleineren Menge an Stoffwechselwasser, das bei der zellulären Atmung entsteht. Dieses Verständnis hilft Haltern, das Trinkverhalten realistisch einzuschätzen und unnötige Sorgen bei Fütterung feuchter Nahrung zu vermeiden.',
+  },
+  {
+    type: 'title',
+    text: 'Gesamtwasserbedarf versus reine Trinkmenge aus dem Wassernapf',
+    level: 2,
+  },
+  {
+    type: 'paragraph',
+    html: 'Die Futterform spielt eine entscheidende Rolle bei der Bestimmung, wie viel Wasser ein Haustier aktiv aus dem Napf aufnehmen muss. Herkömmliches Trockenfutter enthält meist nur 6% bis 10% Feuchtigkeit, weshalb das Tier fast seinen gesamten täglichen Flüssigkeitsbedarf über den Wassernapf decken muss. Nassfutter aus Dosen oder Beuteln hingegen besteht zu 75% bis 82% aus Wasser. Eine Katze oder ein Hund bei reiner Nassfütterung deckt somit bereits den Großteil des Tagesbedarfs über die Mahlzeiten ab, wodurch zusätzliche Trinkversuche selten werden.',
+  },
+  {
+    type: 'table',
+    headers: ['Einflussfaktor', 'Wirkung auf Hydratation', 'Wichtiger klinischer Kernaspekt'],
+    rows: [
+      ['Tierart & Rasse', 'Bestimmt den Grundbedarf pro kg', 'Hunde-Basis ~60 mL/kg; Katzen-Basis ~40 mL/kg'],
+      ['Körpergewicht', 'Skaliert die benötigte Gesamtmenge', 'Bei Übergewicht das gesundes Zielgewicht als Basis nutzen'],
+      ['Futterfeuchtigkeit', 'Verändert die Wasserzufuhr über Mahlzeiten', 'Nassfutter deckt bis zu 80% des täglichen Flüssigkeitsbedarfs'],
+      ['Klima & Aktivität', 'Erhöht den Verlust durch Atmung & Hecheln', 'Höhere Temperaturen erfordern deutlich mehr frisches Trinkwasser'],
+    ],
+  },
+  {
+    type: 'title',
+    text: 'Praktische Empfehlungen für das tägliche Hydratationsmanagement',
+    level: 2,
+  },
+  {
+    type: 'paragraph',
+    html: 'Tierhalter sollten sich darauf konzentrieren, stets freien und uneingeschränkten Zugang zu sauberem, frischem Wasser zu gewährleisten, anstatt zu versuchen, eine starre numerische Zielmenge zu erzwingen. Wassernäpfe sollten täglich gründlich gereinigt und mit neuem Wasser befüllt werden. Insbesondere bei Katzen, die von wüstenbewohnenden Vorfahren abstammen und oft ein geringes Durstgefühl zeigen, können Trinkbrunnen, breite flache Schalen gegen Schnurrhaarreizung und mehrere Trinkstationen im Haus das freiwillige Trinken wirksam fördern.',
+  },
+  {
+    type: 'card',
+    title: 'Management bei Trockenfütterung',
+    icon: 'mdi:food-drumstick',
+    html: 'Tiere bei Trockenfütterung sind vollständig auf das Trinken aus der Wasserschale angewiesen. Sorgen Sie dafür, dass die Näpfe an ruhigen, gut zugänglichen Orten abseits von Katzentoiletten stehen.',
+  },
+  {
+    type: 'card',
+    title: 'Management bei Nassfütterung',
+    icon: 'mdi:food-drumstick',
+    html: 'Nassfutter bietet eine hervorragende kontinuierliche Hydratation. Auch wenn die Tiere seltener am Napf trinken, muss rund um die Uhr frisches Trinkwasser zur Verfügung stehen.',
+  },
+  {
+    type: 'card',
+    title: 'Hitze und sportliche Aktivität',
+    icon: 'mdi:weather-sunny',
+    html: 'Bei hohen Sommerwerten oder intensiver Bewegung steigt der Flüssigkeitsverlust durch Hecheln rasch an. Stellen Sie schattige Ruheplätze und kühles Wasser bereit.',
+  },
+  {
+    type: 'tip',
+    title: 'Tierärztliche Warnsignale und Symptome',
+    html: 'Eine plötzliche Veränderung des Trinkverhaltens - sei es stark gesteigerter Durst (Polydipsie) oder völlige Wasserverweigerung - ist ein wichtiges klinisches Symptom. Erkrankungen wie Niereninsuffizienz, Diabetes mellitus oder Schilddrüsenüberfunktion äußern sich häufig über den Durst. Suchen Sie bei anhaltenden Auffälligkeiten sofort einen Tierarzt auf.',
+  },
+];
+
+const schemas: PetWaterIntakeLocaleContent['schemas'] = [
+  {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: title,
+    description,
+    applicationCategory: 'HealthApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  } as WithContext<SoftwareApplication>,
+  {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faq.map((item) => ({
+      '@type': 'Question',
+      name: item.question,
+      acceptedAnswer: { '@type': 'Answer', text: item.answer },
+    })),
+  } as WithContext<FAQPage>,
+  {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: title,
+    step: howTo.map((step) => ({ '@type': 'HowToStep', name: step.name, text: step.text })),
+  } as WithContext<HowTo>,
+];
+
+export const content: PetWaterIntakeLocaleContent = {
+  slug,
+  title,
+  description,
+  ui,
+  seo,
+  faq,
+  bibliography,
+  howTo,
+  schemas,
+};