@jjlmoya/utils-civic 1.7.0 → 1.9.0

package/src/tool/access-to-information-request-builder/controller.ts

@@ -0,0 +1,135 @@
+import { createPreset, emptyDraft, type RequestDraft } from './logic';
+import { renderRequest } from './dom-views';
+import { clearDraft, loadDraft, saveDraft } from './storage';
+import type { AccessRequestUI } from './ui';
+
+interface ControllerState {
+  draft: RequestDraft;
+  ui: AccessRequestUI;
+  root: HTMLElement;
+}
+
+export function mountAccessRequestBuilder(root: HTMLElement, ui: AccessRequestUI): void {
+  const state: ControllerState = { draft: loadDraft() ?? cloneDraft(emptyDraft), ui, root };
+  bindInputs(state);
+  bindPresets(state);
+  bindActions(state);
+  renderState(state);
+}
+
+function cloneDraft(draft: RequestDraft): RequestDraft {
+  return { ...draft, items: [...draft.items] };
+}
+
+function bindInputs(state: ControllerState): void {
+  const fields = state.root.querySelectorAll<HTMLInputElement | HTMLTextAreaElement>('[data-field]');
+  fields.forEach((field) => field.addEventListener('input', () => {
+    updateField(state, field);
+    renderState(state);
+  }));
+  state.root.querySelectorAll<HTMLButtonElement>('[data-format-option]').forEach((button) => button.addEventListener('click', () => {
+    state.draft.preferredFormat = button.dataset.formatOption ?? '';
+    syncFormatMenu(state);
+    renderState(state);
+  }));
+  state.root.querySelector<HTMLButtonElement>('[data-format-trigger]')?.addEventListener('click', () => toggleFormatMenu(state));
+  document.addEventListener('click', (event) => closeFormatMenu(state, event));
+}
+
+function updateField(state: ControllerState, field: HTMLInputElement | HTMLTextAreaElement): void {
+  const key = field.dataset.field as keyof RequestDraft;
+  if (key === 'items') return;
+  if (key === 'noAttachments' || key === 'savedCopy') state.draft[key] = (field as HTMLInputElement).checked;
+  else state.draft[key] = field.value as never;
+}
+
+function bindPresets(state: ControllerState): void {
+  state.root.querySelectorAll<HTMLButtonElement>('[data-preset]').forEach((button) => button.addEventListener('click', () => {
+    const preset = button.dataset.preset;
+    if (preset === 'records' || preset === 'spending' || preset === 'meetings') {
+      state.draft = createPreset(preset);
+      syncForm(state);
+      renderItems(state);
+      renderState(state);
+    }
+  }));
+}
+
+function bindActions(state: ControllerState): void {
+  state.root.querySelector<HTMLButtonElement>('[data-generate]')?.addEventListener('click', () => renderState(state));
+  state.root.querySelector<HTMLButtonElement>('[data-add-item]')?.addEventListener('click', () => {
+    state.draft.items.push('');
+    renderItems(state);
+    renderState(state);
+  });
+  state.root.addEventListener('click', (event) => {
+    const target = event.target as HTMLElement;
+    const removeButton = target.closest<HTMLButtonElement>('[data-remove-item]');
+    if (!removeButton) return;
+    const index = Number(removeButton.dataset.removeItem);
+    if (state.draft.items.length > 1) state.draft.items.splice(index, 1);
+    renderItems(state);
+    renderState(state);
+  });
+  state.root.querySelector<HTMLButtonElement>('[data-reset]')?.addEventListener('click', () => {
+    state.draft = cloneDraft(emptyDraft);
+    clearDraft();
+    syncForm(state);
+    renderItems(state);
+    renderState(state);
+  });
+}
+
+function renderState(state: ControllerState): void {
+  saveDraft(state.draft);
+  renderRequest(state.root.querySelector<HTMLElement>('[data-request-result]') as HTMLElement, state.draft, state.ui);
+  syncChecklist(state);
+}
+
+function renderItems(state: ControllerState): void {
+  const list = state.root.querySelector<HTMLElement>('[data-request-lines]');
+  if (!list) return;
+  list.innerHTML = state.draft.items.map((item, index) => `<div class="request-line"><label for="request-item-${index}">${state.ui.itemNumber} ${index + 1}</label><textarea id="request-item-${index}" data-item-index="${index}" rows="3" placeholder="${state.ui.itemPlaceholder}">${item.replace(/&/g, '&amp;').replace(/</g, '&lt;')}</textarea>${state.draft.items.length > 1 ? `<button type="button" data-remove-item="${index}">${state.ui.removeItem}</button>` : ''}</div>`).join('');
+  list.querySelectorAll<HTMLTextAreaElement>('[data-item-index]').forEach((field) => field.addEventListener('input', () => {
+    state.draft.items[Number(field.dataset.itemIndex)] = field.value;
+    renderState(state);
+  }));
+}
+
+function syncForm(state: ControllerState): void {
+  state.root.querySelectorAll<HTMLInputElement | HTMLTextAreaElement>('[data-field]').forEach((field) => {
+    const key = field.dataset.field as keyof RequestDraft;
+    if (key === 'noAttachments' || key === 'savedCopy') (field as HTMLInputElement).checked = Boolean(state.draft[key]);
+    else if (key !== 'items') field.value = String(state.draft[key] ?? '');
+  });
+  syncFormatMenu(state);
+}
+
+function syncFormatMenu(state: ControllerState): void {
+  const trigger = state.root.querySelector<HTMLButtonElement>('[data-format-trigger]');
+  const options = state.root.querySelectorAll<HTMLButtonElement>('[data-format-option]');
+  const chosen = Array.from(options).find((option) => option.dataset.formatOption === state.draft.preferredFormat);
+  if (trigger) trigger.textContent = chosen?.textContent?.trim() || state.ui.formatPlaceholder;
+  options.forEach((option) => option.setAttribute('aria-selected', String(option.dataset.formatOption === state.draft.preferredFormat)));
+}
+
+function toggleFormatMenu(state: ControllerState): void {
+  const menu = state.root.querySelector<HTMLElement>('[data-format-menu]');
+  const trigger = state.root.querySelector<HTMLButtonElement>('[data-format-trigger]');
+  if (!menu || !trigger) return;
+  const open = menu.hidden;
+  menu.hidden = !open;
+  trigger.setAttribute('aria-expanded', String(open));
+}
+
+function closeFormatMenu(state: ControllerState, event: Event): void {
+  const menu = state.root.querySelector<HTMLElement>('[data-format-menu]');
+  if (!menu || menu.hidden || (event.target as HTMLElement).closest('[data-format-picker]')) return;
+  menu.hidden = true;
+  state.root.querySelector<HTMLButtonElement>('[data-format-trigger]')?.setAttribute('aria-expanded', 'false');
+}
+
+function syncChecklist(state: ControllerState): void {
+  const values: Record<string, string> = { recipient: state.draft.recipient, subject: state.draft.subject, geography: state.draft.geography, delivery: state.draft.delivery };
+  Object.entries(values).forEach(([key, value]) => state.root.querySelector(`[data-filled="${key}"]`)?.classList.toggle('is-filled', Boolean(value.trim())));
+}

package/src/tool/access-to-information-request-builder/dom-views.ts

@@ -0,0 +1,59 @@
+import { buildRequestMarkdown, type ChecklistItem, type RequestDraft } from './logic';
+import { evaluateForDisplay } from './evaluator';
+import type { AccessRequestUI } from './ui';
+
+function escapeHtml(value: string): string {
+  return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+function checklistLabel(item: ChecklistItem, ui: AccessRequestUI): string {
+  const labels = { recipient: ui.checklistRecipient, scope: ui.checklistScope, period: ui.checklistPeriod, format: ui.checklistFormat, attachments: ui.checklistAttachments, copy: ui.checklistCopy };
+  return labels[item.key];
+}
+
+function checklistState(item: ChecklistItem): string {
+  if (item.complete) return 'complete';
+  if (item.caution) return 'caution';
+  return 'review';
+}
+
+function checklistMarker(item: ChecklistItem): string {
+  if (item.complete) return 'OK';
+  if (item.caution) return '!';
+  return '.';
+}
+
+function renderChecklist(items: ChecklistItem[], ui: AccessRequestUI): string {
+  return items.map((item) => {
+    const state = checklistState(item);
+    const marker = checklistMarker(item);
+    return `<li class="trail-check trail-check-${state}"><span aria-hidden="true">${marker}</span><span>${escapeHtml(checklistLabel(item, ui))}</span><strong>${item.complete ? escapeHtml(ui.completeLabel) : escapeHtml(ui.reviewLabel)}</strong></li>`;
+  }).join('');
+}
+
+function renderWarnings(messages: { text: string; severity: string }[], ui: AccessRequestUI): string {
+  if (messages.length === 0) return '';
+  return `<div class="trail-warnings" role="status"><p class="trail-warnings-title">${escapeHtml(ui.reviewWarningsHeading)}</p><ul>${messages.map((message) => `<li class="trail-warning-${message.severity}">${escapeHtml(message.text)}</li>`).join('')}</ul></div>`;
+}
+
+export function renderRequest(root: HTMLElement, draft: RequestDraft, ui: AccessRequestUI): void {
+  const evaluation = evaluateForDisplay(draft, ui);
+  const markdown = buildRequestMarkdown(draft);
+  const hasContent = Boolean(draft.subject.trim() || draft.items.some((item) => item.trim()));
+  const output = hasContent ? `<textarea class="request-markdown" data-request-markdown rows="18" spellcheck="false">${escapeHtml(markdown)}</textarea>` : `<p class="request-empty">${escapeHtml(ui.noResult)}</p>`;
+  root.innerHTML = `<div class="request-output"><div class="output-heading"><div><span class="eyebrow">${escapeHtml(ui.resultHeading)}</span><p>${escapeHtml(ui.resultIntro)}</p></div><div class="output-actions"><button type="button" data-copy-request ${hasContent ? '' : 'disabled'}>${escapeHtml(ui.copyAction)}</button><button type="button" data-print-request ${hasContent ? '' : 'disabled'}>${escapeHtml(ui.printAction)}</button></div></div>${output}<p class="copy-confirmation" data-copy-confirmation hidden>${escapeHtml(ui.copied)}</p></div><div class="trace-strip"><div class="trace-heading"><span class="eyebrow">${escapeHtml(ui.checklistHeading)}</span><strong>${evaluation.valid ? escapeHtml(ui.statusReady) : escapeHtml(ui.statusReview)}</strong></div><ul class="trail-checklist">${renderChecklist(evaluation.checklist, ui)}</ul>${renderWarnings(evaluation.messages, ui)}</div>`;
+  root.querySelector<HTMLButtonElement>('[data-copy-request]')?.addEventListener('click', () => copyRequest(root, markdown, ui));
+  root.querySelector<HTMLButtonElement>('[data-print-request]')?.addEventListener('click', () => window.print());
+}
+
+async function copyRequest(root: HTMLElement, markdown: string, ui: AccessRequestUI): Promise<void> {
+  try {
+    const editable = root.querySelector<HTMLTextAreaElement>('[data-request-markdown]');
+    await navigator.clipboard.writeText(editable?.value ?? markdown);
+    const confirmation = root.querySelector<HTMLElement>('[data-copy-confirmation]');
+    if (confirmation) {
+      confirmation.textContent = ui.copied;
+      confirmation.hidden = false;
+    }
+  } catch {}
+}

package/src/tool/access-to-information-request-builder/entry.ts

@@ -0,0 +1,27 @@
+import type { CivicToolEntry, ToolLocaleContent } from '../../types';
+import type { AccessRequestUI } from './ui';
+
+export type AccessRequestLocaleContent = ToolLocaleContent<AccessRequestUI>;
+
+export const accessToInformationRequestBuilder: CivicToolEntry<AccessRequestUI> = {
+  id: 'access-to-information-request-builder',
+  phase: 'localized',
+  icons: { bg: 'mdi:file-document-edit-outline', fg: 'mdi:arrow-right-bold' },
+  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),
+  },
+};

package/src/tool/access-to-information-request-builder/evaluator.ts

@@ -0,0 +1,27 @@
+import type { AccessRequestUI } from './ui';
+import { evaluateDraft, type DraftEvaluation, type RequestDraft } from './logic';
+
+export interface WarningMessage {
+  text: string;
+  severity: 'review' | 'caution';
+}
+
+const warningText: Record<string, keyof AccessRequestUI> = {
+  'missing-recipient': 'missingRecipient',
+  'missing-items': 'missingItems',
+  'missing-period': 'missingPeriod',
+  'broad-item': 'broadItem',
+  'missing-format': 'missingFormat',
+  'missing-geography': 'missingGeography',
+  'missing-delivery': 'missingDelivery',
+  'no-copy': 'noCopyWarning',
+};
+
+export function evaluateForDisplay(draft: RequestDraft, ui: AccessRequestUI): DraftEvaluation & { messages: WarningMessage[] } {
+  const evaluation = evaluateDraft(draft);
+  const messages = evaluation.warnings.map((code) => ({
+    text: ui[warningText[code] ?? 'statusReview'] ?? ui.statusReview,
+    severity: code === 'broad-item' ? 'caution' as const : 'review' as const,
+  }));
+  return { ...evaluation, messages };
+}

package/src/tool/access-to-information-request-builder/i18n/de.ts

@@ -0,0 +1,52 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { AccessRequestLocaleContent } from '../entry';
+import type { AccessRequestUI } from '../ui';
+
+const ui: AccessRequestUI = {
+  eyebrow: 'CIVIC PAPER TRAIL', introHeading: 'Formuliere die Frage, bevor sie deinen Schreibtisch verlässt.', introText: 'Beginne mit dem Ziel, nenne pro Zeile genau einen anfragbaren Datensatz und ergänze die Grenzen, die das Auffinden erleichtern.', targetHeading: 'Ziel festlegen', targetPrompt: 'Wer kann antworten?', questionPrompt: 'Ein Datensatz pro Zeile', boundaryHeading: 'Grenzen ziehen', boundaryPrompt: 'Was macht ihn auffindbar?', reviewWarningsHeading: 'Vor dem Senden prüfen',
+  recipientLabel: 'Behörde oder Empfänger', recipientPlaceholder: 'Amt, Behörde, Archiv oder Organisation', subjectLabel: 'Thema', subjectPlaceholder: 'Die Unterlagen oder Informationen, die du finden möchtest', itemsLabel: 'Angeforderte Informationen', itemPlaceholder: 'Frage nach einem identifizierbaren Datensatz, Dokument oder Feld', addItem: 'Weitere Anfragezeile hinzufügen', removeItem: 'Diese Zeile entfernen', periodLabel: 'Zeitraum', periodFrom: 'Von', periodTo: 'Bis', geographyLabel: 'Geografischer Umfang', geographyPlaceholder: 'Stadt, Bezirk, Standort, Programmgebiet oder landesweit', formatLabel: 'Bevorzugtes Format', formatPlaceholder: 'Lieferformat auswählen', formatEmail: 'Elektronische Kopie per E-Mail', formatCsv: 'Maschinenlesbare Tabelle wie CSV', formatPdf: 'Durchsuchbares PDF oder Dokument', formatOriginal: 'Von der Behörde gespeichertes Originalformat', deliveryLabel: 'Antwortdetails', deliveryPlaceholder: 'E-Mail-Adresse, Postanschrift oder sicherer Antwortweg', contactLabel: 'Optionale Kontaktdaten', contactPlaceholder: 'Telefon, Aktenzeichen oder bevorzugter Antwortkanal', attachmentsLabel: 'Anhänge oder Kennungen', attachmentsPlaceholder: 'Dateinamen, Aktenzeichen, Links oder Kontext zum Auffinden', noAttachments: 'Keine Anhänge oder Kennungen erforderlich', savedCopy: 'Ich habe eine Kopie des fertigen Textes gespeichert', presetLabel: 'Mit einem fokussierten Beispiel beginnen', presetRecords: 'Sitzungsunterlagen', presetSpending: 'Ausgabenunterlagen', presetMeetings: 'Dienstleistungsbeschwerden', generateAction: 'Anfrageentwurf erstellen', resetAction: 'Entwurf löschen', resultHeading: 'Anfrageentwurf', resultIntro: 'Prüfe alle Angaben und bearbeite den finalen Text vor dem Kopieren. Hinweise und Warnungen bleiben außerhalb des gesendeten Textes.', copyAction: 'Markdown kopieren', printAction: 'Drucken oder als PDF speichern', copied: 'In die Zwischenablage kopiert', noResult: 'Füge einen Empfänger, ein Thema und mindestens eine Anfragezeile hinzu, um die Spur zu sehen.', checklistHeading: 'Nachvollziehbarkeit vor dem Senden', completeLabel: 'Bereit', reviewLabel: 'Prüfen', checklistRecipient: 'Empfänger genannt', checklistScope: 'Jede Zeile bezeichnet einen anfragbaren Datensatz', checklistPeriod: 'Zeitraum begrenzt', checklistFormat: 'Bevorzugtes Format genannt', checklistAttachments: 'Anhänge und Kennungen berücksichtigt', checklistCopy: 'Kopie für die eigenen Unterlagen gespeichert', methodHeading: 'Angewandte Methode', methodText: 'Der Builder macht aus einem breiten Thema eine nachvollziehbare Anfrage: ein Datensatz pro Zeile, ein benannter Empfänger, ein klarer Zeitraum, eine geografische Grenze, ein bevorzugtes Format und ein nutzbarer Antwortweg. Er ordnet nur deine Angaben und ergänzt niemals Rechtsgrundlage, Frist, Behörde oder Tatsachenbehauptung.', limitsHeading: 'Was dieses Tool nicht entscheidet', limitsText: 'Es ermittelt nicht die zuständige Behörde, keine gesetzliche Frist, keine Offenlegungsgarantie und reicht die Anfrage nicht ein. Es ordnet Unterlagen nicht nach lokalem Recht ein und bietet keine Rechtsberatung. Prüfe vor dem Senden die aktuellen Hinweise der empfangenden Stelle.', edgeCasesHeading: 'Sonderfälle und Datenhinweise', edgeCasesText: 'Breite Formulierungen wie "alle Dokumente" sind schwer zu durchsuchen. Vermeide undefinierte Begriffe, uneinheitliche Datumsbedeutungen, unnötige personenbezogene Daten und die Bitte um eine neue Analyse, wenn du einen vorhandenen Datensatz brauchst. Formate sind möglicherweise nicht verfügbar.', statusReady: 'Der Entwurf enthält die vollständige Mindestspur.', statusReview: 'Der Entwurf ist ein brauchbarer Anfang, muss aber geprüft werden.', missingRecipient: 'Nenne vor dem Senden die Behörde oder den Empfänger.', missingItems: 'Füge mindestens einen konkreten Datensatz hinzu.', missingPeriod: 'Füge Anfang und Ende hinzu oder erkläre die fehlende Grenze.', broadItem: 'Diese Zeile könnte zu breit sein. Nenne Datensatztyp, Feld, Ereignis oder messbare Menge.', missingFormat: 'Wähle, wie die Information geliefert werden soll.', missingGeography: 'Nenne einen Ort oder erkläre, warum die Anfrage landesweit gilt.', missingDelivery: 'Nenne einen Antwortweg für den Empfänger.', noCopyWarning: 'Speichere den finalen Text und die Einreichungsdaten vor dem Senden.', itemNumber: 'Anfragezeile',
+};
+
+const softwareApplication: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Builder für Informationszugangsanfragen', applicationCategory: 'UtilitiesApplication', operatingSystem: 'Any', description: 'Erstelle einen präzisen, nachvollziehbaren Antrag mit Umfang, Zeitraum, Format und Antwortweg.', url: 'https://gamebob.dev/de/antrag-informationszugang-erstellen', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } };
+const faqPage: FAQPage = { '@type': 'FAQPage', mainEntity: [
+  { '@type': 'Question', name: 'Was sollte ich anfordern?', acceptedAnswer: { '@type': 'Answer', text: 'Frage nach einem identifizierbaren Datensatz, Dokument, Feld oder messbaren Zähler. Trenne unabhängige Datensätze in verschiedene Anfragezeilen.' } },
+  { '@type': 'Question', name: 'Kennt das Tool die zuständige Behörde?', acceptedAnswer: { '@type': 'Answer', text: 'Nein. Du musst den wahrscheinlichen Empfänger ermitteln und seine aktuellen Hinweise prüfen. Der Builder bestimmt weder Zuständigkeit noch Fristen oder Ausnahmen.' } },
+  { '@type': 'Question', name: 'Warum sind Zeitraum und geografischer Umfang wichtig?', acceptedAnswer: { '@type': 'Answer', text: 'Sie begrenzen die Suche und verringern Mehrdeutigkeit. Verwende an beiden Enden dieselbe Datumsbedeutung und nenne den betroffenen Ort oder das Programm.' } },
+  { '@type': 'Question', name: 'Kann ich personenbezogene oder sensible Daten anfordern?', acceptedAnswer: { '@type': 'Answer', text: 'Füge nur notwendige und angemessene Angaben ein. Zugangs- und Datenschutzregeln unterscheiden sich, daher solltest du die aktuellen Hinweise des Empfängers prüfen.' } },
+] };
+const howTo: HowTo = { '@type': 'HowTo', name: 'Eine präzise Informationsanfrage formulieren', step: [
+  { '@type': 'HowToStep', name: 'Empfänger nennen', text: 'Trage die Behörde, Abteilung, das Archiv oder die Organisation ein, die die Information vermutlich besitzt, und prüfe ihren aktuellen Anfrageweg.' },
+  { '@type': 'HowToStep', name: 'Information aufteilen', text: 'Schreibe pro Zeile genau einen anfragbaren Datensatz. Nenne Datensatztyp, Felder, Ereignis oder Zähler statt eines ganzen Themenbereichs.' },
+  { '@type': 'HowToStep', name: 'Suche begrenzen', text: 'Ergänze Anfangsdatum, Enddatum, geografischen Umfang und Kennungen, die beim Auffinden helfen.' },
+  { '@type': 'HowToStep', name: 'Antwortdetails wählen', text: 'Nenne ein bevorzugtes Format und einen zuverlässigen Antwortweg, ohne die Verfügbarkeit eines Formats vorauszusetzen.' },
+  { '@type': 'HowToStep', name: 'Prüfen und Kopie behalten', text: 'Lies das Markdown, bearbeite Prüfpunkte, speichere Text und Einreichungsdaten und sende über den bestätigten Kanal.' },
+] };
+
+export const content: AccessRequestLocaleContent = { slug: 'antrag-informationszugang-erstellen', title: 'Builder für Informationszugangsanfragen', description: 'Formuliere eine präzise Informationsanfrage mit Empfänger, einzelnen Anfragezeilen, Zeitraum, geografischem Umfang, Lieferformat und Prüfliste.', ui, seo: [
+  { type: 'title', text: 'Eine auffindbare Informationsanfrage schreiben', level: 2 },
+  { type: 'paragraph', html: 'Eine Anfrage kann höflich und dennoch schwer zu beantworten sein, wenn ihr Thema zu breit ist, Daten fehlen oder mehrere unabhängige Fragen vermischt werden. Dieser Builder macht aus deinen Angaben eine prüfbare Spur: Empfänger, gesuchte Unterlagen, Zeitraum, Ort und möglicher Antwortweg.' },
+  { type: 'title', text: 'Der Suche eine Grenze geben', level: 2 },
+  { type: 'paragraph', html: 'Verwende an beiden Enden dieselbe Bedeutung für das Datum, etwa Veröffentlichungsdatum, Sitzungstag oder Zahlungsdatum. Ergänze Ort, Programm, Standort oder Organisation. Wenn eine Grenze wirklich unbekannt ist, zeige sie in der Prüfliste und rate nicht.' },
+  { type: 'table', headers: ['Anfragedetail', 'Nützliche Formulierung', 'Unterstützte Entscheidung'], rows: [['Informationssatz', 'Endgültige Tagesordnungen und genehmigte Protokolle', 'Welche Unterlagen sollen gesucht werden?'], ['Zeitraum', 'Vom 01.01.2025 bis 31.12.2025', 'Welche Unterlagen gehören dazu?'], ['Geografischer Umfang', 'Dienstleistungsbereich Nordbezirk', 'Welcher Ort ist gemeint?'], ['Format', 'Maschinenlesbare Tabelle wie CSV', 'Wie kann das Ergebnis geprüft werden?']] },
+  { type: 'title', text: 'Den Entwurf vor dem Senden prüfen', level: 2 },
+  { type: 'paragraph', html: 'Der erzeugte Text hält deine Fakten zusammen und trennt Hinweise von dem Text, den du sendest. Ein vollständiger Prüfpunk bedeutet, dass das Mindestdetail vorhanden ist. Eine Warnung zu breiter Sprache fordert dich auf, Datensatz, Feld, Ereignis oder messbare Menge genauer zu benennen.' },
+  { type: 'list', items: ['Bestätige, dass der Empfänger diese Art Anfrage aktuell annimmt.', 'Prüfe, dass jede Zeile genau einen identifizierbaren Datensatz verlangt.', 'Verwende einen geschlossenen Zeitraum und eine passende geografische Grenze.', 'Nenne ein bevorzugtes Format, ohne die Erstellung einer neuen Datei vorauszusetzen.', 'Speichere Anhänge, Kennungen, finalen Text und Einreichungskanal.'] },
+  { type: 'tip', title: 'Präzise bedeutet nicht vollständig', html: 'Eine kurze Anfrage mit Datensatztyp, Zeitraum und Kennungen ist oft leichter zu suchen als eine lange Erzählung. Behalte Kontext, der beim Auffinden hilft, und entferne Hintergrund ohne Einfluss auf die Frage.' },
+  { type: 'title', text: 'Was der Builder nicht entscheiden kann', level: 2 },
+  { type: 'paragraph', html: 'Dies ist ein länderübergreifendes Schreibwerkzeug. Es findet weder die zuständige Behörde noch eine gesetzliche Frist, garantiert Offenlegung oder ein Format, reicht die Anfrage ein oder bietet Rechtsberatung. Für diese Fragen gelten die aktuellen Regeln der empfangenden Stelle.' },
+  { type: 'tip', title: 'Die Beweisspur aufbewahren', html: 'Speichere den genauen Text, Datum, Empfänger, Anhänge und eine Bestätigung. So kannst du die Antwort mit der tatsächlich gestellten Frage vergleichen.' },
+  { type: 'title', text: 'Eine brauchbare Antwort vorbereiten', level: 2 },
+  { type: 'paragraph', html: 'Nenne die Felder oder den Dokumenttyp, die für dein Ziel wichtig sind, und bewahre Anfrage und Antwort gemeinsam auf.' },
+], faq: [
+  { question: 'Was sollte ich anfordern?', answer: 'Frage nach einem identifizierbaren Datensatz, Dokument, Feld oder messbaren Zähler und trenne unabhängige Datensätze.' },
+  { question: 'Kennt das Tool die zuständige Behörde?', answer: 'Nein. Prüfe Empfänger, Zuständigkeit, Frist, Ausnahmen und Kanal anhand aktueller lokaler Hinweise.' },
+  { question: 'Warum sind Zeitraum und Ort wichtig?', answer: 'Sie begrenzen die Suche. Nutze dieselbe Datumsbedeutung und nenne den betroffenen Ort oder das Programm.' },
+  { question: 'Kann ich sensible Daten anfordern?', answer: 'Füge nur notwendige Angaben ein und prüfe die aktuellen Zugangs- und Datenschutzhinweise.' },
+], bibliography, howTo: [
+  { name: 'Empfänger nennen', text: 'Trage die wahrscheinliche Behörde ein und prüfe ihren aktuellen Anfrageweg.' },
+  { name: 'Information aufteilen', text: 'Schreibe pro Zeile einen identifizierbaren Datensatz, ein Feld oder einen Zähler.' },
+  { name: 'Suche begrenzen', text: 'Ergänze passende Anfangs- und Enddaten, Ort und Kennungen.' },
+  { name: 'Antwortdetails wählen', text: 'Nenne Format und Antwortweg, ohne eine neue Datei vorauszusetzen.' },
+  { name: 'Prüfen und Kopie behalten', text: 'Bearbeite Warnungen und speichere Text und Einreichungsdaten.' },
+], schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[] };

package/src/tool/access-to-information-request-builder/i18n/en.ts

@@ -0,0 +1,76 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { AccessRequestLocaleContent } from '../entry';
+import { ui } from '../ui';
+
+const softwareApplication: SoftwareApplication = {
+  '@type': 'SoftwareApplication',
+  name: 'Access to Information Request Builder',
+  applicationCategory: 'UtilitiesApplication',
+  operatingSystem: 'Any',
+  description: 'Draft a precise, traceable information request with clear scope, dates, format, and delivery details.',
+  url: 'https://gamebob.dev/en/access-to-information-request-builder',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+};
+
+const faqPage: FAQPage = {
+  '@type': 'FAQPage',
+  mainEntity: [
+    { '@type': 'Question', name: 'What should I ask for?', acceptedAnswer: { '@type': 'Answer', text: 'Ask for an identifiable information set, record, field, or measurable count. Separate unrelated sets into different request lines so the recipient can search and answer each one.' } },
+    { '@type': 'Question', name: 'Does this tool know which authority to contact?', acceptedAnswer: { '@type': 'Answer', text: 'No. You must identify the likely recipient and check its current instructions. The builder does not determine jurisdiction, deadlines, exemptions, or filing channels.' } },
+    { '@type': 'Question', name: 'Why do dates and geographic scope matter?', acceptedAnswer: { '@type': 'Answer', text: 'They narrow the search boundary and reduce ambiguity. Use a start and end date with the same meaning, and name the place, programme area, or organisation covered by the request.' } },
+    { '@type': 'Question', name: 'Can I request personal or sensitive information?', acceptedAnswer: { '@type': 'Answer', text: 'Only include personal details that are necessary and appropriate for your situation. Access rules and privacy limits differ by jurisdiction, so review the recipient\'s guidance before sending.' } },
+  ],
+};
+
+const howTo: HowTo = {
+  '@type': 'HowTo',
+  name: 'Draft a precise information request',
+  step: [
+    { '@type': 'HowToStep', name: 'Name the recipient', text: 'Enter the authority, department, archive, or organisation you believe holds the information, then verify its current request channel.' },
+    { '@type': 'HowToStep', name: 'Split the information', text: 'Write one requestable set per line. Name the record type, fields, event, or count instead of asking for everything about a topic.' },
+    { '@type': 'HowToStep', name: 'Bound the search', text: 'Add a start date, end date, geographic scope, and any record identifiers that help the recipient find the material.' },
+    { '@type': 'HowToStep', name: 'Choose delivery details', text: 'State a preferred format and a reliable reply route, while recognising that the available format may depend on the records held.' },
+    { '@type': 'HowToStep', name: 'Review and keep a copy', text: 'Read the generated Markdown, resolve the review items, save the final text and submission details, then send it through the verified channel.' },
+  ],
+};
+
+export const content: AccessRequestLocaleContent = {
+  slug: 'access-to-information-request-builder',
+  title: 'Access to Information Request Builder',
+  description: 'Draft a precise information request with a named recipient, specific request lines, clear dates, geographic scope, delivery format, and a pre-send checklist.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Write an Information Request Someone Can Find', level: 2 },
+    { type: 'paragraph', html: 'A request can be polite and still be difficult to answer when its subject is broad, its dates are missing, or it combines several unrelated questions. This builder turns the details you already know into a reviewable paper trail: who should receive the request, what records are sought, which period and place matter, and how a reply could be delivered.' },
+    { type: 'paragraph', html: 'The strongest input is not a legal phrase. It is a concrete description of an information set, such as a transaction table with named fields, approved minutes for a defined period, or a monthly count for a named service. Separate lines make it easier to spot an unclear noun, an unbounded date, or a request for a new analysis rather than an existing record.' },
+    { type: 'title', text: 'Give the Search a Boundary', level: 2 },
+    { type: 'paragraph', html: 'Use the same time meaning at both ends of the period: publication date, meeting date, payment date, or another meaning that you can explain. Add a place, programme, site, or organisation when the topic could otherwise refer to several areas. If a boundary is genuinely unknown, leave it visible in the checklist and resolve it before sending instead of guessing.' },
+    { type: 'table', headers: ['Request detail', 'Useful wording', 'Decision it supports'], rows: [['Information set', 'Final agendas and approved minutes', 'Which records should be searched?'], ['Time period', 'From 2025-01-01 to 2025-12-31', 'Which records are inside the request?'], ['Geographic scope', 'North district service area', 'Which place or programme is relevant?'], ['Format', 'Machine-readable table such as CSV', 'How can the result be reused or checked?']] },
+    { type: 'title', text: 'Review the Draft Before You Send It', level: 2 },
+    { type: 'paragraph', html: 'The generated text keeps your facts together and places guidance in a separate review strip. A green checklist item means the minimum detail is present; a review item means you should supply or confirm a boundary. A warning about broad wording is a prompt to name the record, field, event, or measurable set more precisely.' },
+    { type: 'list', items: ['Confirm that the recipient is the body currently accepting this kind of request.', 'Check that every line asks for one identifiable information set rather than a whole subject area.', 'Use a closed date range and a geographic boundary that match the question.', 'State a preferred format without assuming the recipient must create a new file.', 'Record attachments, identifiers, the final text, and the channel used to submit it.'] },
+    { type: 'tip', title: 'Specific does not mean exhaustive', html: 'A short request with a named record type, bounded period, and useful identifiers is often easier to search than a long narrative. Keep context that helps locate the records, but remove background that does not change what you are asking for.' },
+    { type: 'title', text: 'Know What the Builder Cannot Decide', level: 2 },
+    { type: 'paragraph', html: 'This is a country-agnostic writing aid. It does not identify the competent authority, calculate a statutory deadline, decide whether information must be disclosed, guarantee a particular format, file the request, or provide legal advice. The receiving body\'s current rules remain the source for those questions.' },
+    { type: 'paragraph', html: 'Take extra care with personal or sensitive data, undefined terms, mixed date meanings, and requests that ask an organisation to create an opinion or analysis it may not hold. The tool can make those risks visible, but only you and the relevant authority can decide what is appropriate under the applicable regime.' },
+    { type: 'tip', title: 'Keep the evidence trail', html: 'Save the exact text you submitted, the date, the destination, attachments, and any acknowledgement. That record helps you compare the reply with the question you actually asked and correct the next request without relying on memory.' },
+  ],
+  faq: [
+    { question: 'What should I ask for?', answer: 'Ask for an identifiable information set, record, field, or measurable count. Separate unrelated sets into different request lines.' },
+    { question: 'Does this tool know which authority to contact?', answer: 'No. Verify the recipient, jurisdiction, deadline, exemptions, and filing channel using current local guidance.' },
+    { question: 'Why do dates and geographic scope matter?', answer: 'They narrow the search boundary and reduce ambiguity. Use matching date meanings and name the place or programme covered.' },
+    { question: 'Can I request personal or sensitive information?', answer: 'Include only details that are necessary and appropriate, then check the recipient\'s current privacy and access guidance.' },
+  ],
+  bibliography,
+  howTo: [
+    { name: 'Name the recipient', text: 'Enter the likely authority or organisation and verify its current request channel.' },
+    { name: 'Split the information', text: 'Write one identifiable record, field, information set, or count per line.' },
+    { name: 'Bound the search', text: 'Add matching start and end dates, geographic scope, and useful identifiers.' },
+    { name: 'Choose delivery details', text: 'State a preferred format and a reply route without assuming a new format can be created.' },
+    { name: 'Review and keep a copy', text: 'Resolve checklist warnings and save the final text with the submission details.' },
+  ],
+  schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[],
+};
+
+export const englishContent = content;

package/src/tool/access-to-information-request-builder/i18n/es.ts

@@ -0,0 +1,52 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { AccessRequestLocaleContent } from '../entry';
+import type { AccessRequestUI } from '../ui';
+
+const ui: AccessRequestUI = {
+  eyebrow: 'CIVIC PAPER TRAIL', introHeading: 'Da forma a la pregunta antes de enviarla.', introText: 'Empieza por el destino, nombra un conjunto de información por línea y añade los límites que permiten localizar el registro.', targetHeading: 'Fija el destino', targetPrompt: '¿Quién puede responder?', questionPrompt: 'Un conjunto cada vez', boundaryHeading: 'Dibuja los límites', boundaryPrompt: '¿Qué lo hace localizable?', reviewWarningsHeading: 'Revisar antes de enviar',
+  recipientLabel: 'Autoridad o destinatario', recipientPlaceholder: 'Departamento, organismo, archivo u organización', subjectLabel: 'Asunto', subjectPlaceholder: 'Los registros o datos que quieres localizar', itemsLabel: 'Información solicitada', itemPlaceholder: 'Pide un conjunto de información, registro o campo identificable', addItem: 'Añadir otra línea de solicitud', removeItem: 'Eliminar esta línea', periodLabel: 'Periodo', periodFrom: 'Desde', periodTo: 'Hasta', geographyLabel: 'Ámbito geográfico', geographyPlaceholder: 'Ciudad, distrito, sede, zona del programa o nacional', formatLabel: 'Formato preferido', formatPlaceholder: 'Elige un formato de entrega', formatEmail: 'Copia electrónica por correo', formatCsv: 'Tabla legible por máquinas como CSV', formatPdf: 'PDF o documento con búsqueda', formatOriginal: 'Formato original que conserve la autoridad', deliveryLabel: 'Datos de entrega', deliveryPlaceholder: 'Correo, dirección postal o una vía segura de respuesta', contactLabel: 'Contacto opcional', contactPlaceholder: 'Teléfono, referencia o canal de respuesta preferido', attachmentsLabel: 'Adjuntos o identificadores', attachmentsPlaceholder: 'Nombres de archivo, números de registro, enlaces o contexto útil', noAttachments: 'No hacen falta adjuntos ni identificadores', savedCopy: 'He guardado una copia del texto final', presetLabel: 'Empieza con un ejemplo concreto', presetRecords: 'Registros de reuniones', presetSpending: 'Registros de gastos', presetMeetings: 'Quejas sobre servicios', generateAction: 'Crear borrador de solicitud', resetAction: 'Borrar borrador', resultHeading: 'Borrador de solicitud', resultIntro: 'Revisa cada dato y edita el texto final antes de copiarlo. Las orientaciones y advertencias quedan fuera del texto que enviarás.', copyAction: 'Copiar Markdown', printAction: 'Imprimir o guardar como PDF', copied: 'Copiado al portapapeles', noResult: 'Añade un destinatario, un asunto y al menos una línea para ver la trazabilidad.', checklistHeading: 'Trazabilidad antes del envío', completeLabel: 'Listo', reviewLabel: 'Revisar', checklistRecipient: 'El destinatario está nombrado', checklistScope: 'Cada línea identifica un conjunto solicitables', checklistPeriod: 'El periodo está acotado', checklistFormat: 'El formato preferido está indicado', checklistAttachments: 'Adjuntos e identificadores están contemplados', checklistCopy: 'Hay una copia guardada', methodHeading: 'Método aplicado', methodText: 'El creador convierte un tema amplio en una solicitud trazable: un conjunto por línea, un destinatario, un intervalo de fechas, un límite geográfico, un formato preferido y una vía de respuesta. Solo ordena los datos que aportas y nunca añade una base legal, un plazo, una autoridad o un hecho.', limitsHeading: 'Lo que esta herramienta no decide', limitsText: 'No identifica la autoridad competente, calcula plazos legales, garantiza la divulgación, presenta la solicitud, clasifica registros según la ley local ni ofrece asesoramiento jurídico. Comprueba las instrucciones vigentes del organismo receptor antes de enviarla.', edgeCasesHeading: 'Casos especiales y avisos de datos', edgeCasesText: 'Expresiones amplias como "todos los documentos" pueden ser difíciles de buscar. Evita términos indefinidos, significados mezclados de las fechas, datos personales innecesarios y peticiones de un análisis nuevo cuando necesitas un registro existente. Puede que algunos formatos no estén disponibles.', statusReady: 'El borrador contiene la trazabilidad mínima completa.', statusReview: 'El borrador sirve como punto de partida, pero necesita revisión.', missingRecipient: 'Nombra la autoridad o el destinatario antes de enviar.', missingItems: 'Añade al menos un conjunto de información específico.', missingPeriod: 'Añade fecha inicial y final o explica el límite que falta.', broadItem: 'Esta línea puede ser demasiado amplia. Nombra un tipo de registro, campo, evento o conjunto medible.', missingFormat: 'Elige cómo quieres recibir la información.', missingGeography: 'Añade un lugar o explica por qué la solicitud es nacional.', missingDelivery: 'Añade una vía para que el destinatario responda.', noCopyWarning: 'Guarda el texto final y los datos del envío antes de enviarlo.', itemNumber: 'Línea de solicitud',
+};
+
+const softwareApplication: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Creador de solicitudes de acceso a la información', applicationCategory: 'UtilitiesApplication', operatingSystem: 'Any', description: 'Redacta una solicitud precisa y trazable con alcance, fechas, formato y vía de respuesta.', url: 'https://gamebob.dev/es/redactor-solicitud-acceso-informacion', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } };
+const faqPage: FAQPage = { '@type': 'FAQPage', mainEntity: [
+  { '@type': 'Question', name: '¿Qué debería solicitar?', acceptedAnswer: { '@type': 'Answer', text: 'Pide un conjunto de información, registro, campo o recuento medible que se pueda identificar. Separa los conjuntos independientes en líneas distintas.' } },
+  { '@type': 'Question', name: '¿La herramienta sabe a qué autoridad debo escribir?', acceptedAnswer: { '@type': 'Answer', text: 'No. Debes identificar al destinatario probable y comprobar sus instrucciones actuales. El creador no determina la jurisdicción, los plazos ni las excepciones.' } },
+  { '@type': 'Question', name: '¿Por qué importan las fechas y el ámbito geográfico?', acceptedAnswer: { '@type': 'Answer', text: 'Acotan la búsqueda y reducen la ambigüedad. Usa el mismo significado para ambas fechas y nombra el lugar o programa incluido.' } },
+  { '@type': 'Question', name: '¿Puedo solicitar datos personales o sensibles?', acceptedAnswer: { '@type': 'Answer', text: 'Incluye solo los datos necesarios y adecuados. Las reglas de acceso y privacidad cambian según la jurisdicción, así que revisa las indicaciones del destinatario.' } },
+] };
+const howTo: HowTo = { '@type': 'HowTo', name: 'Redactar una solicitud de información precisa', step: [
+  { '@type': 'HowToStep', name: 'Nombra al destinatario', text: 'Introduce la autoridad, departamento, archivo u organización que probablemente conserva la información y verifica su canal vigente.' },
+  { '@type': 'HowToStep', name: 'Separa la información', text: 'Escribe un conjunto solicitables por línea. Nombra el tipo de registro, sus campos, el evento o el recuento.' },
+  { '@type': 'HowToStep', name: 'Acota la búsqueda', text: 'Añade fecha inicial, fecha final, ámbito geográfico e identificadores que faciliten localizar el material.' },
+  { '@type': 'HowToStep', name: 'Elige los datos de entrega', text: 'Indica un formato preferido y una vía fiable de respuesta, sin dar por hecho que podrán crear un formato nuevo.' },
+  { '@type': 'HowToStep', name: 'Revisa y guarda una copia', text: 'Lee el Markdown, resuelve los avisos, guarda el texto y los datos del envío y utiliza el canal verificado.' },
+] };
+
+export const content: AccessRequestLocaleContent = { slug: 'redactor-solicitud-acceso-informacion', title: 'Creador de solicitudes de acceso a la información', description: 'Redacta una solicitud precisa con destinatario, líneas concretas, fechas, ámbito geográfico, formato y lista de comprobación.', ui, seo: [
+  { type: 'title', text: 'Escribe una solicitud de información que se pueda localizar', level: 2 },
+  { type: 'paragraph', html: 'Una solicitud puede ser educada y aun así difícil de responder cuando el asunto es amplio, faltan fechas o mezcla preguntas independientes. Este creador convierte los datos que ya conoces en una trazabilidad revisable: quién recibe la solicitud, qué registros buscas, qué periodo y lugar importan y cómo podrían entregarte la respuesta.' },
+  { type: 'title', text: 'Pon un límite a la búsqueda', level: 2 },
+  { type: 'paragraph', html: 'Usa el mismo significado para las dos fechas: fecha de publicación, reunión, pago u otro criterio que puedas explicar. Añade lugar, programa, sede u organización. Si un límite es realmente desconocido, déjalo visible en la lista y resuélvelo antes de enviar en lugar de inventarlo.' },
+  { type: 'table', headers: ['Detalle', 'Redacción útil', 'Decisión que ayuda'], rows: [['Conjunto de información', 'Agendas finales y actas aprobadas', '¿Qué registros hay que buscar?'], ['Periodo', 'Del 01/01/2025 al 31/12/2025', '¿Qué registros entran?'], ['Ámbito geográfico', 'Zona de servicios del distrito norte', '¿Qué lugar o programa corresponde?'], ['Formato', 'Tabla legible por máquinas como CSV', '¿Cómo se puede reutilizar o comprobar?']] },
+  { type: 'title', text: 'Revisa el borrador antes de enviarlo', level: 2 },
+  { type: 'paragraph', html: 'El texto generado mantiene juntos tus datos y deja las orientaciones en una franja de revisión separada. Un elemento completo indica que existe el detalle mínimo; una advertencia te pide concretar un nombre, una fecha, un lugar o un conjunto medible.' },
+  { type: 'list', items: ['Confirma que el destinatario acepta actualmente este tipo de solicitud.', 'Comprueba que cada línea pide un conjunto identificable y no un tema entero.', 'Usa un periodo cerrado y un ámbito geográfico coherente.', 'Indica un formato preferido sin suponer que el organismo deba crear un archivo nuevo.', 'Guarda adjuntos, identificadores, texto final y canal de envío.'] },
+  { type: 'tip', title: 'Concreto no significa exhaustivo', html: 'Una solicitud corta con un tipo de registro, un periodo y buenos identificadores suele ser más fácil de buscar que una narración larga. Conserva el contexto útil y elimina lo que no cambie la petición.' },
+  { type: 'title', text: 'Conoce los límites del creador', level: 2 },
+  { type: 'paragraph', html: 'Es una ayuda de redacción independiente del país. No identifica la autoridad competente, calcula plazos, garantiza la divulgación, presenta la solicitud, decide excepciones ni ofrece asesoramiento jurídico. Para esas cuestiones manda la guía vigente del organismo receptor.' },
+  { type: 'tip', title: 'Conserva la trazabilidad', html: 'Guarda el texto exacto, la fecha, el destinatario, los adjuntos y cualquier acuse. Así podrás comparar la respuesta con la pregunta que realmente hiciste.' },
+  { type: 'title', text: 'Preparar una respuesta aprovechable', level: 2 },
+  { type: 'paragraph', html: 'Indica los campos o el tipo de registro que necesitas y conserva juntos la solicitud y cualquier respuesta recibida.' },
+], faq: [
+  { question: '¿Qué debería solicitar?', answer: 'Pide un conjunto de información, registro, campo o recuento identificable y separa los conjuntos independientes.' },
+  { question: '¿La herramienta sabe a qué autoridad escribir?', answer: 'No. Verifica destinatario, jurisdicción, plazo, excepciones y canal con información local vigente.' },
+  { question: '¿Por qué importan las fechas y el lugar?', answer: 'Acotan la búsqueda. Usa el mismo significado para las fechas y nombra el lugar o programa.' },
+  { question: '¿Puedo solicitar datos sensibles?', answer: 'Incluye solo los datos necesarios y revisa las indicaciones actuales de acceso y privacidad.' },
+], bibliography, howTo: [
+  { name: 'Nombra al destinatario', text: 'Introduce la autoridad probable y verifica su canal actual.' },
+  { name: 'Separa la información', text: 'Escribe un registro, campo o conjunto identificable por línea.' },
+  { name: 'Acota la búsqueda', text: 'Añade fechas coherentes, ámbito geográfico e identificadores.' },
+  { name: 'Elige los datos de entrega', text: 'Indica formato y vía de respuesta sin suponer un archivo nuevo.' },
+  { name: 'Revisa y guarda una copia', text: 'Resuelve los avisos y guarda el texto junto con los datos del envío.' },
+], schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[] };

package/src/tool/access-to-information-request-builder/i18n/fr.ts

@@ -0,0 +1,50 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { AccessRequestLocaleContent } from '../entry';
+import type { AccessRequestUI } from '../ui';
+
+const ui: AccessRequestUI = {
+  eyebrow: 'CIVIC PAPER TRAIL', introHeading: 'Cadrez la question avant de l envoyer.', introText: 'Commencez par le destinataire, indiquez un ensemble demandable par ligne, puis ajoutez les limites qui rendent le document repérable.', targetHeading: 'Définir le destinataire', targetPrompt: 'Qui peut répondre ?', questionPrompt: 'Un ensemble à la fois', boundaryHeading: 'Tracer les limites', boundaryPrompt: 'Qu est-ce qui le rend repérable ?', reviewWarningsHeading: 'Vérifier avant l envoi',
+  recipientLabel: 'Autorité ou destinataire', recipientPlaceholder: 'Service, organisme, archive ou organisation', subjectLabel: 'Objet', subjectPlaceholder: 'Les documents ou informations à retrouver', itemsLabel: 'Informations demandées', itemPlaceholder: 'Demandez un ensemble, document ou champ identifiable', addItem: 'Ajouter une ligne de demande', removeItem: 'Supprimer cette ligne', periodLabel: 'Période', periodFrom: 'Du', periodTo: 'Au', geographyLabel: 'Périmètre géographique', geographyPlaceholder: 'Ville, district, site, zone de programme ou national', formatLabel: 'Format souhaité', formatPlaceholder: 'Choisir un format de remise', formatEmail: 'Copie électronique par courriel', formatCsv: 'Tableau lisible par machine comme CSV', formatPdf: 'PDF ou document interrogeable', formatOriginal: 'Format original détenu par l autorité', deliveryLabel: 'Modalités de réponse', deliveryPlaceholder: 'Adresse électronique, postale ou moyen sûr de répondre', contactLabel: 'Coordonnées facultatives', contactPlaceholder: 'Téléphone, référence ou canal de réponse préféré', attachmentsLabel: 'Pièces jointes ou identifiants', attachmentsPlaceholder: 'Noms de fichiers, numéros, liens ou contexte utile', noAttachments: 'Aucune pièce jointe ou identifiant nécessaire', savedCopy: 'J ai enregistré une copie du texte final', presetLabel: 'Partir d un exemple ciblé', presetRecords: 'Documents de réunions', presetSpending: 'Documents de dépenses', presetMeetings: 'Réclamations sur les services', generateAction: 'Créer le brouillon', resetAction: 'Effacer le brouillon', resultHeading: 'Brouillon de demande', resultIntro: 'Vérifiez chaque fait et modifiez le texte final avant de le copier. Les conseils et avertissements restent hors du texte envoyé.', copyAction: 'Copier le Markdown', printAction: 'Imprimer ou enregistrer en PDF', copied: 'Copié dans le presse-papiers', noResult: 'Ajoutez un destinataire, un objet et au moins une ligne pour voir la trace.', checklistHeading: 'Traçabilité avant envoi', completeLabel: 'Prêt', reviewLabel: 'À vérifier', checklistRecipient: 'Destinataire nommé', checklistScope: 'Chaque ligne désigne un ensemble demandable', checklistPeriod: 'Période délimitée', checklistFormat: 'Format souhaité indiqué', checklistAttachments: 'Pièces et identifiants pris en compte', checklistCopy: 'Une copie est conservée', methodHeading: 'Méthode appliquée', methodText: 'Le générateur transforme un sujet large en demande traçable: un ensemble par ligne, un destinataire nommé, une période claire, une limite géographique, un format souhaité et un moyen de réponse utilisable. Il réorganise seulement vos indications et n ajoute jamais de base juridique, délai, autorité ou fait.', limitsHeading: 'Ce que l outil ne décide pas', limitsText: 'Il n identifie pas l autorité compétente, ne détermine pas de délai légal, ne garantit pas la communication, ne dépose pas la demande, ne classe pas un document selon le droit local et ne fournit pas de conseil juridique. Vérifiez les consignes actuelles du destinataire.', edgeCasesHeading: 'Cas particuliers et données', edgeCasesText: 'Des expressions larges comme "tous les documents" sont difficiles à rechercher. Évitez les termes indéfinis, les sens de date mélangés, les données personnelles inutiles et les demandes d analyse nouvelle quand vous cherchez un document existant. Certains formats peuvent être indisponibles.', statusReady: 'Le brouillon contient la trace minimale complète.', statusReview: 'Le brouillon est un bon point de départ mais doit être vérifié.', missingRecipient: 'Nommez l autorité ou le destinataire avant l envoi.', missingItems: 'Ajoutez au moins un ensemble d informations précis.', missingPeriod: 'Ajoutez un début et une fin ou expliquez la limite absente.', broadItem: 'Cette ligne semble peut-être trop large. Nommez un type, champ, événement ou ensemble mesurable.', missingFormat: 'Choisissez le mode de remise des informations.', missingGeography: 'Ajoutez un lieu ou expliquez pourquoi la demande est nationale.', missingDelivery: 'Ajoutez un moyen permettant au destinataire de répondre.', noCopyWarning: 'Enregistrez le texte final et les détails d envoi avant de transmettre.', itemNumber: 'Ligne de demande',
+};
+const softwareApplication: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Générateur de demande d accès à l information', applicationCategory: 'UtilitiesApplication', operatingSystem: 'Any', description: 'Rédigez une demande précise et traçable avec périmètre, dates, format et moyen de réponse.', url: 'https://gamebob.dev/fr/redacteur-demande-acces-information', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } };
+const faqPage: FAQPage = { '@type': 'FAQPage', mainEntity: [
+  { '@type': 'Question', name: 'Que dois-je demander ?', acceptedAnswer: { '@type': 'Answer', text: 'Demandez un ensemble, document, champ ou décompte mesurable identifiable. Séparez les ensembles indépendants en lignes différentes.' } },
+  { '@type': 'Question', name: 'L outil connaît-il l autorité à contacter ?', acceptedAnswer: { '@type': 'Answer', text: 'Non. Identifiez le destinataire probable et vérifiez ses consignes actuelles. L outil ne détermine ni compétence, ni délai, ni exception.' } },
+  { '@type': 'Question', name: 'Pourquoi les dates et le périmètre comptent-ils ?', acceptedAnswer: { '@type': 'Answer', text: 'Ils réduisent la recherche et l ambiguïté. Donnez le même sens aux deux dates et nommez le lieu ou le programme concerné.' } },
+  { '@type': 'Question', name: 'Puis-je demander des données personnelles ?', acceptedAnswer: { '@type': 'Answer', text: 'N incluez que les données nécessaires et appropriées. Les règles d accès et de confidentialité varient, vérifiez donc les consignes du destinataire.' } },
+] };
+const howTo: HowTo = { '@type': 'HowTo', name: 'Rédiger une demande d information précise', step: [
+  { '@type': 'HowToStep', name: 'Nommer le destinataire', text: 'Saisissez l autorité, le service, l archive ou l organisation qui détient probablement l information et vérifiez son canal actuel.' },
+  { '@type': 'HowToStep', name: 'Séparer l information', text: 'Écrivez un ensemble demandable par ligne et nommez le type de document, les champs, l événement ou le décompte.' },
+  { '@type': 'HowToStep', name: 'Délimiter la recherche', text: 'Ajoutez les dates, le périmètre géographique et les identifiants qui facilitent la localisation.' },
+  { '@type': 'HowToStep', name: 'Choisir la remise', text: 'Indiquez un format souhaité et un moyen fiable de réponse sans supposer qu un nouveau fichier sera créé.' },
+  { '@type': 'HowToStep', name: 'Vérifier et garder une copie', text: 'Lisez le Markdown, corrigez les points à revoir, conservez le texte et les détails d envoi puis utilisez le canal vérifié.' },
+] };
+export const content: AccessRequestLocaleContent = { slug: 'redacteur-demande-acces-information', title: 'Générateur de demande d accès à l information', description: 'Rédigez une demande précise avec destinataire, lignes ciblées, dates, périmètre, format et liste avant envoi.', ui, seo: [
+  { type: 'title', text: 'Écrire une demande d information repérable', level: 2 },
+  { type: 'paragraph', html: 'Une demande peut être polie et difficile à traiter si son sujet est vaste, ses dates absentes ou ses questions mélangées. Ce générateur transforme les détails connus en trace vérifiable: destinataire, documents recherchés, période, lieu et mode de réponse.' },
+  { type: 'title', text: 'Donner une limite à la recherche', level: 2 },
+  { type: 'paragraph', html: 'Utilisez le même sens pour les deux dates: publication, réunion, paiement ou autre sens explicable. Ajoutez un lieu, un programme, un site ou une organisation. Si une limite est inconnue, laissez-le visible et ne devinez pas.' },
+  { type: 'table', headers: ['Détail', 'Formulation utile', 'Décision soutenue'], rows: [['Ensemble', 'Ordres du jour finaux et procès-verbaux approuvés', 'Quels documents rechercher ?'], ['Période', 'Du 01/01/2025 au 31/12/2025', 'Quels documents inclure ?'], ['Périmètre', 'Zone de service du district nord', 'Quel lieu est concerné ?'], ['Format', 'Tableau lisible par machine comme CSV', 'Comment vérifier le résultat ?']] },
+  { type: 'title', text: 'Vérifier le brouillon avant envoi', level: 2 },
+  { type: 'paragraph', html: 'Le texte produit rassemble vos faits et place les conseils dans une zone séparée. Un élément complet signale la présence du minimum attendu ; un avertissement invite à préciser un document, un champ, une date, un lieu ou un ensemble mesurable.' },
+  { type: 'list', items: ['Confirmez que le destinataire accepte actuellement ce type de demande.', 'Vérifiez que chaque ligne vise un ensemble identifiable, non un sujet entier.', 'Utilisez une période fermée et un périmètre cohérent.', 'Indiquez un format préféré sans imposer la création d un fichier.', 'Conservez les pièces, identifiants, texte final et canal utilisé.'] },
+  { type: 'tip', title: 'Précis ne veut pas dire exhaustif', html: 'Une demande courte avec un type de document, une période et des identifiants utiles est souvent plus facile à rechercher qu un long récit. Gardez le contexte qui aide à localiser.' },
+  { type: 'title', text: 'Connaître les limites du générateur', level: 2 },
+  { type: 'paragraph', html: 'C est une aide de rédaction indépendante du pays. Elle n identifie pas l autorité, ne calcule pas de délai, ne garantit pas la communication, ne dépose pas la demande et ne donne pas de conseil juridique. Les règles actuelles du destinataire restent déterminantes.' },
+  { type: 'tip', title: 'Conserver la trace', html: 'Archivez le texte exact, la date, le destinataire, les pièces et tout accusé. Vous pourrez comparer la réponse avec la question réellement envoyée.' },
+  { type: 'title', text: 'Préparer une réponse exploitable', level: 2 },
+  { type: 'paragraph', html: 'Indiquez les champs ou le type de document utiles à votre objectif, puis gardez une copie de la demande et de toute réponse reçue.' },
+], faq: [
+  { question: 'Que dois-je demander ?', answer: 'Demandez un document, champ, ensemble ou décompte identifiable et séparez les ensembles indépendants.' },
+  { question: 'L outil connaît-il l autorité ?', answer: 'Non. Vérifiez destinataire, compétence, délai, exceptions et canal avec les consignes locales actuelles.' },
+  { question: 'Pourquoi les dates et le lieu comptent-ils ?', answer: 'Ils bornent la recherche. Utilisez le même sens pour les dates et nommez le lieu ou programme.' },
+  { question: 'Puis-je demander des données sensibles ?', answer: 'Incluez seulement les données nécessaires et vérifiez les règles actuelles d accès et de confidentialité.' },
+], bibliography, howTo: [
+  { name: 'Nommer le destinataire', text: 'Saisissez l autorité probable et vérifiez son canal actuel.' },
+  { name: 'Séparer l information', text: 'Écrivez un document, champ ou ensemble identifiable par ligne.' },
+  { name: 'Délimiter la recherche', text: 'Ajoutez dates cohérentes, périmètre et identifiants.' },
+  { name: 'Choisir la remise', text: 'Indiquez format et moyen de réponse sans supposer un nouveau fichier.' },
+  { name: 'Vérifier et garder une copie', text: 'Corrigez les avertissements et conservez texte et détails d envoi.' },
+], schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[] };