export interface TOPDeskDocsTranslation {
    metadata: {
      title: string;
      description: string;
    };
    hero: {
      title: string;
      subtitle: string;
      cta: {
        primary: string;
      };
    };
    sections: {
      overview: {
        title: string;
        whatIs: {
          title: string;
          content: string;
        };
        apiOverview: {
          title: string;
          host: string;
          basePath: string;
          protocol: string;
          protocolValue: string;
          authentication: string;
          authValue: string;
        };
        capabilities: {
          title: string;
          items: {
            title: string;
            description: string;
          }[];
        };
      };
      concepts: {
        title: string;
        entities: {
          title: string;
        };
        terminology: {
          title: string;
          headers: {
            term: string;
            description: string;
            example: string;
          };
          items: {
            term: string;
            description: string;
            example: string;
          }[];
        };
        lifecycle: {
          title: string;
        };
      };
      gettingStarted: {
        title: string;
        authentication: {
          title: string;
          description: string;
          headers: string;
        };
        firstCall: {
          title: string;
          description: string;
          code: string;
        };
        dynamicDropdowns: {
          title: string;
          warning: string;
          explanation: string;
          integration: {
            title: string;
            wrongCode: string;
            correctCode: string;
          };
          whyEssential: {
            title: string;
            reasons: {
              title: string;
              description: string;
            }[];
          };
        };
      };
      apiReference: {
        title: string;
        essentialEndpoints: {
          title: string;
          findUsers: {
            title: string;
            purpose: string;
            purposeText: string;
            returns: string;
            returnsText: string;
          };
          dropdownOptions: {
            title: string;
            endpoints: {
              path: string;
              description: string;
            }[];
          };
          createTicket: {
            title: string;
            purpose: string;
            purposeText: string;
            requires: string;
            requiresText: string;
          };
          searchKnowledgeBase: {
            title: string;
            purpose: string;
            purposeText: string;
          };
        };
      };
      contact: {
        title: string;
        team: string;
        teamName: string;
        email: string;
        website: string;
        supportText: string;
      };
    };
  }
  
  export const supportedLanguages = ['en', 'nl', 'de', 'fr'] as const;
  
  export function getTOPDeskDocsTranslation(lang: string): TOPDeskDocsTranslation {
    return translations[lang] || translations['en'];
  }
  
  export const translations: Record<string, TOPDeskDocsTranslation> = {
    en: {
      metadata: {
        title: 'API Documentation | Technical Integration Guide',
        description: 'Comprehensive technical documentation for API integration. Learn concepts, endpoints, and best practices for developers.'
      },
      hero: {
        title: 'API Documentation',
        subtitle: 'Comprehensive technical documentation for developers and system integrators. Learn concepts, explore endpoints, and master integration best practices.',
        cta: {
          primary: 'Start Learning'
        }
      },
      sections: {
        overview: {
          title: 'Introduction and Overview',
          whatIs: {
            title: 'What is this API?',
            content: 'This API is a comprehensive platform that manages IT services, incidents, changes, and assets within an organization. It provides programmatic access to core functionality, enabling integration with chatbots, automated workflows, and custom applications.'
          },
          apiOverview: {
            title: 'API Overview',
            host: 'Host',
            basePath: 'Base Path',
            protocol: 'Protocol',
            protocolValue: 'HTTPS only',
            authentication: 'Authentication',
            authValue: 'API Key Management (subscription keys required)'
          },
          capabilities: {
            title: 'What You Can Do With This API',
            items: [
              {
                title: 'Create and manage incidents',
                description: '(IT support tickets)'
              },
              {
                title: 'Search and retrieve knowledge base articles',
                description: ''
              },
              {
                title: 'Access asset information',
                description: 'from the Configuration Management Database (CMDB)'
              },
              {
                title: 'Manage change requests',
                description: 'and their lifecycle'
              },
              {
                title: 'Retrieve supporting data',
                description: '(users, categories, operators, etc.)'
              }
            ]
          }
        },
        concepts: {
          title: 'Understanding Core Concepts',
          entities: {
            title: 'Core Entities and Their Relationships'
          },
          terminology: {
            title: 'Key Terminology',
            headers: {
              term: 'Term',
              description: 'Description',
              example: 'Example'
            },
            items: [
              {
                term: 'Caller',
                description: 'The person who reports an issue',
                example: 'John Doe reporting a broken laptop'
              },
              {
                term: 'Incident',
                description: 'A support ticket for an IT problem',
                example: '"Email not working" ticket'
              },
              {
                term: 'Operator',
                description: 'IT support staff member',
                example: 'Sarah from the Help Desk team'
              },
              {
                term: 'Operator Group',
                description: 'IT support team',
                example: '"1st Line Support", "Network Team"'
              },
              {
                term: 'Category/Subcategory',
                description: 'Classification system for tickets',
                example: 'Hardware > Laptop, Software > Email'
              },
              {
                term: 'Priority/Urgency/Impact',
                description: 'Ticket severity indicators',
                example: 'P1 (Critical), P5 (Low priority)'
              },
              {
                term: 'Processing Status',
                description: 'Where the ticket is in its lifecycle',
                example: 'New, In Progress, Resolved, Closed'
              },
              {
                term: 'Change',
                description: 'Planned modification to IT systems',
                example: '"Upgrade email server on Sunday"'
              },
              {
                term: 'Asset',
                description: 'IT equipment or software in CMDB',
                example: 'Laptop ABC123, Windows Server XYZ'
              }
            ]
          },
          lifecycle: {
            title: 'Typical Incident Lifecycle'
          }
        },
        gettingStarted: {
          title: 'Getting Started',
          authentication: {
            title: 'Authentication Setup',
            description: 'You\'ll need API Management credentials. All requests require these headers:',
            headers: `Content-Type: application/json
  Access-Control-Allow-Origin: *
  Accept-Encoding: gzip, deflate, br`
          },
          firstCall: {
            title: 'Your First API Call - Find a Person',
            description: 'Before creating tickets, you need to find user IDs:',
            code: `// Find a user by name
  const response = await fetch('/api/persons?query=dynamicName=="John Doe"', {
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*',
      'Accept-Encoding': 'gzip, deflate, br'
    }
  });
  
  const persons = await response.json();
  console.log(persons[0].id); // Use this ID when creating tickets`
          },
          dynamicDropdowns: {
            title: 'Understanding Dynamic Dropdowns',
            warning: '⚠️ Critical Concept: Why You Can\'t Hardcode Values',
            explanation: 'This platform is highly configurable. Each organization customizes their instance with their own categories, operator groups, priorities, and call types.',
            integration: {
              title: 'What This Means for Integration:',
              wrongCode: `// ❌ WRONG - These IDs won't work in your environment
  const ticketData = {
    category: { id: "12345-hardware" },      // Your org might not have this
    operatorGroup: { id: "67890-helpdesk" } // Different ID in your instance
  };`,
              correctCode: `// ✅ CORRECT - Always fetch current options first
  const categories = await getDropdownOptions('/api/categories/parent');
  const operatorGroups = await getDropdownOptions('/api/operatorgroups');
  
  const ticketData = {
    category: { id: categories.find(c => c.name === "Hardware").id },
    operatorGroup: { id: operatorGroups.find(g => g.groupName === "IT Support").id }
  };`
            },
            whyEssential: {
              title: 'Why This Approach is Essential:',
              reasons: [
                {
                  title: 'Configuration Changes',
                  description: 'Admins add/remove/rename categories regularly'
                },
                {
                  title: 'Environment Differences',
                  description: 'Dev, test, and prod environments have different IDs'
                },
                {
                  title: 'Organization Differences',
                  description: 'Every company\'s setup is configured differently'
                },
                {
                  title: 'API Failures',
                  description: 'Using invalid IDs results in 400 Bad Request errors'
                }
              ]
            }
          }
        },
        apiReference: {
          title: 'API Reference',
          essentialEndpoints: {
            title: 'Essential Endpoints for Getting Started',
            findUsers: {
              title: '1. Find Users (Required for ticket creation)',
              purpose: 'Purpose',
              purposeText: 'Get user ID needed for creating tickets',
              returns: 'Returns',
              returnsText: 'User object with id, dynamicName, email'
            },
            dropdownOptions: {
              title: '2. Get Dropdown Options (Required for ticket creation)',
              endpoints: [
                {
                  path: '/api/categories/parent',
                  description: 'Get categories for ticket classification'
                },
                {
                  path: '/api/categories/sub',
                  description: 'Get subcategories'
                },
                {
                  path: '/api/incidents/call_types',
                  description: 'Get call types (incident, service request, etc.)'
                },
                {
                  path: '/api/operatorgroups?fields=id,groupName&page_size=100',
                  description: 'Get operator groups (which team should handle this?)'
                }
              ]
            },
            createTicket: {
              title: '3. Create Incident Ticket',
              purpose: 'Purpose',
              purposeText: 'Create a new support ticket',
              requires: 'Requires',
              requiresText: 'Caller ID + all the dropdown IDs from step 2'
            },
            searchKnowledgeBase: {
              title: '4. Search Knowledge Base',
              purpose: 'Purpose',
              purposeText: 'Find help articles and solutions'
            }
          }
        },
        contact: {
          title: 'Contact Information',
          team: 'Support Team',
          teamName: 'Technical Support Team',
          email: 'Email',
          website: 'Website',
          supportText: 'For technical support and integration assistance, please contact our support team with specific endpoint details and error information.'
        }
      }
    },
    nl: {
      metadata: {
        title: 'API Documentatie | Technische Integratiegids',
        description: 'Uitgebreide technische documentatie voor API-integratie. Leer concepten, endpoints en best practices voor ontwikkelaars.'
      },
      hero: {
        title: 'API Documentatie',
        subtitle: 'Uitgebreide technische documentatie voor ontwikkelaars en systeemintegrators. Leer concepten, verken endpoints en beheers integratieprincipes.',
        cta: {
          primary: 'Begin met Leren'
        }
      },
      sections: {
        overview: {
          title: 'Inleiding en Overzicht',
          whatIs: {
            title: 'Wat is deze API?',
            content: 'Deze API is een uitgebreid platform dat IT-services, incidenten, wijzigingen en assets binnen een organisatie beheert. Het biedt programmatische toegang tot kernfunctionaliteit, waardoor integratie met chatbots, geautomatiseerde workflows en aangepaste applicaties mogelijk wordt.'
          },
          apiOverview: {
            title: 'API Overzicht',
            host: 'Host',
            basePath: 'Basis Pad',
            protocol: 'Protocol',
            protocolValue: 'Alleen HTTPS',
            authentication: 'Authenticatie',
            authValue: 'API Key Management (abonnementssleutels vereist)'
          },
          capabilities: {
            title: 'Wat Je Kunt Doen Met Deze API',
            items: [
              {
                title: 'Incidenten creëren en beheren',
                description: '(IT-ondersteuningstickets)'
              },
              {
                title: 'Kennisbank artikelen zoeken en ophalen',
                description: ''
              },
              {
                title: 'Asset informatie toegang',
                description: 'vanuit de Configuration Management Database (CMDB)'
              },
              {
                title: 'Wijzigingsverzoeken beheren',
                description: 'en hun levenscyclus'
              },
              {
                title: 'Ondersteunende data ophalen',
                description: '(gebruikers, categorieën, operators, etc.)'
              }
            ]
          }
        },
        concepts: {
          title: 'Kernconcepten Begrijpen',
          entities: {
            title: 'Kernentiteiten en Hun Relaties'
          },
          terminology: {
            title: 'Belangrijke Terminologie',
            headers: {
              term: 'Term',
              description: 'Beschrijving',
              example: 'Voorbeeld'
            },
            items: [
              {
                term: 'Melder',
                description: 'De persoon die een probleem meldt',
                example: 'John Doe meldt een kapotte laptop'
              },
              {
                term: 'Incident',
                description: 'Een ondersteuningsticket voor een IT-probleem',
                example: '"E-mail werkt niet" ticket'
              },
              {
                term: 'Operator',
                description: 'IT-ondersteuningsmedewerker',
                example: 'Sarah van de Helpdesk team'
              },
              {
                term: 'Operator Groep',
                description: 'IT-ondersteuningsteam',
                example: '"1e Lijn Ondersteuning", "Netwerkteam"'
              },
              {
                term: 'Categorie/Subcategorie',
                description: 'Classificatiesysteem voor tickets',
                example: 'Hardware > Laptop, Software > E-mail'
              },
              {
                term: 'Prioriteit/Urgentie/Impact',
                description: 'Ticket ernst indicatoren',
                example: 'P1 (Kritiek), P5 (Lage prioriteit)'
              },
              {
                term: 'Verwerkingsstatus',
                description: 'Waar het ticket zich bevindt in zijn levenscyclus',
                example: 'Nieuw, In Behandeling, Opgelost, Gesloten'
              },
              {
                term: 'Wijziging',
                description: 'Geplande modificatie aan IT-systemen',
                example: '"E-mailserver upgraden op zondag"'
              },
              {
                term: 'Asset',
                description: 'IT-apparatuur of software in CMDB',
                example: 'Laptop ABC123, Windows Server XYZ'
              }
            ]
          },
          lifecycle: {
            title: 'Typische Incident Levenscyclus'
          }
        },
        gettingStarted: {
          title: 'Aan de Slag',
          authentication: {
            title: 'Authenticatie Instelling',
            description: 'Je hebt API Management inloggegevens nodig. Alle verzoeken vereisen deze headers:',
            headers: `Content-Type: application/json
  Access-Control-Allow-Origin: *
  Accept-Encoding: gzip, deflate, br`
          },
          firstCall: {
            title: 'Je Eerste API Aanroep - Een Persoon Vinden',
            description: 'Voordat je tickets aanmaakt, moet je gebruikers-IDs vinden:',
            code: `// Zoek een gebruiker op naam
  const response = await fetch('/api/persons?query=dynamicName=="John Doe"', {
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*',
      'Accept-Encoding': 'gzip, deflate, br'
    }
  });
  
  const persons = await response.json();
  console.log(persons[0].id); // Gebruik deze ID bij het maken van tickets`
          },
          dynamicDropdowns: {
            title: 'Dynamische Dropdowns Begrijpen',
            warning: '⚠️ Kritiek Concept: Waarom Je Geen Waarden Kunt Hardcoderen',
            explanation: 'Dit platform is zeer configureerbaar. Elke organisatie past hun instantie aan met hun eigen categorieën, operator groepen, prioriteiten en oproeptypes.',
            integration: {
              title: 'Wat Dit Betekent Voor Integratie:',
              wrongCode: `// ❌ FOUT - Deze IDs werken niet in jouw omgeving
  const ticketData = {
    category: { id: "12345-hardware" },      // Jouw org heeft dit misschien niet
    operatorGroup: { id: "67890-helpdesk" } // Ander ID in jouw instantie
  };`,
              correctCode: `// ✅ CORRECT - Haal altijd huidige opties op eerst
  const categories = await getDropdownOptions('/api/categories/parent');
  const operatorGroups = await getDropdownOptions('/api/operatorgroups');
  
  const ticketData = {
    category: { id: categories.find(c => c.name === "Hardware").id },
    operatorGroup: { id: operatorGroups.find(g => g.groupName === "IT Support").id }
  };`
            },
            whyEssential: {
              title: 'Waarom Deze Aanpak Essentieel Is:',
              reasons: [
                {
                  title: 'Configuratie Wijzigingen',
                  description: 'Beheerders voegen regelmatig categorieën toe/verwijderen/hernoemen'
                },
                {
                  title: 'Omgeving Verschillen',
                  description: 'Dev, test en prod omgevingen hebben verschillende IDs'
                },
                {
                  title: 'Organisatie Verschillen',
                  description: 'Elke bedrijfsinstelling is anders geconfigureerd'
                },
                {
                  title: 'API Fouten',
                  description: 'Het gebruik van ongeldige IDs resulteert in 400 Bad Request fouten'
                }
              ]
            }
          }
        },
        apiReference: {
          title: 'API Referentie',
          essentialEndpoints: {
            title: 'Essentiële Endpoints om Mee te Beginnen',
            findUsers: {
              title: '1. Gebruikers Vinden (Vereist voor ticket creatie)',
              purpose: 'Doel',
              purposeText: 'Gebruikers-ID ophalen die nodig is voor het maken van tickets',
              returns: 'Retourneert',
              returnsText: 'Gebruikersobject met id, dynamicName, email'
            },
            dropdownOptions: {
              title: '2. Dropdown Opties Ophalen (Vereist voor ticket creatie)',
              endpoints: [
                {
                  path: '/api/categories/parent',
                  description: 'Categorieën ophalen voor ticket classificatie'
                },
                {
                  path: '/api/categories/sub',
                  description: 'Subcategorieën ophalen'
                },
                {
                  path: '/api/incidents/call_types',
                  description: 'Oproeptypes ophalen (incident, serviceverzoek, etc.)'
                },
                {
                  path: '/api/operatorgroups?fields=id,groupName&page_size=100',
                  description: 'Operator groepen ophalen (welk team moet dit afhandelen?)'
                }
              ]
            },
            createTicket: {
              title: '3. Incident Ticket Aanmaken',
              purpose: 'Doel',
              purposeText: 'Een nieuw ondersteuningsticket aanmaken',
              requires: 'Vereist',
              requiresText: 'Melder ID + alle dropdown IDs van stap 2'
            },
            searchKnowledgeBase: {
              title: '4. Kennisbank Doorzoeken',
              purpose: 'Doel',
              purposeText: 'Hulpartikelen en oplossingen vinden'
            }
          }
        },
        contact: {
          title: 'Contactinformatie',
          team: 'Ondersteuningsteam',
          teamName: 'Technisch Ondersteuningsteam',
          email: 'E-mail',
          website: 'Website',
          supportText: 'Voor technische ondersteuning en integratiehulp, neem contact op met ons ondersteuningsteam met specifieke endpoint details en foutinformatie.'
        }
      }
    },
    de: {
      metadata: {
        title: 'API Dokumentation | Technischer Integrationsleitfaden',
        description: 'Umfassende technische Dokumentation für API-Integration. Lernen Sie Konzepte, Endpoints und Best Practices für Entwickler.'
      },
      hero: {
        title: 'API Dokumentation',
        subtitle: 'Umfassende technische Dokumentation für Entwickler und Systemintegratoren. Lernen Sie Konzepte, erkunden Sie Endpoints und meistern Sie Integrationspraktiken.',
        cta: {
          primary: 'Loslegen'
        }
      },
      sections: {
        overview: {
          title: 'Einführung und Überblick',
          whatIs: {
            title: 'Was ist diese API?',
            content: 'Diese API ist eine umfassende Plattform, die IT-Services, Vorfälle, Änderungen und Assets innerhalb einer Organisation verwaltet. Sie bietet programmatischen Zugang zu Kernfunktionalitäten und ermöglicht die Integration mit Chatbots, automatisierten Workflows und benutzerdefinierten Anwendungen.'
          },
          apiOverview: {
            title: 'API Überblick',
            host: 'Host',
            basePath: 'Basis Pfad',
            protocol: 'Protokoll',
            protocolValue: 'Nur HTTPS',
            authentication: 'Authentifizierung',
            authValue: 'API Key Management (Abonnementschlüssel erforderlich)'
          },
          capabilities: {
            title: 'Was Sie mit dieser API tun können',
            items: [
              {
                title: 'Vorfälle erstellen und verwalten',
                description: '(IT-Support-Tickets)'
              },
              {
                title: 'Wissensdatenbank-Artikel suchen und abrufen',
                description: ''
              },
              {
                title: 'Asset-Informationen zugreifen',
                description: 'aus der Configuration Management Database (CMDB)'
              },
              {
                title: 'Änderungsanfragen verwalten',
                description: 'und deren Lebenszyklus'
              },
              {
                title: 'Unterstützende Daten abrufen',
                description: '(Benutzer, Kategorien, Operatoren, etc.)'
              }
            ]
          }
        },
        concepts: {
          title: 'Kernkonzepte Verstehen',
          entities: {
            title: 'Kernentitäten und ihre Beziehungen'
          },
          terminology: {
            title: 'Wichtige Terminologie',
            headers: {
              term: 'Begriff',
              description: 'Beschreibung',
              example: 'Beispiel'
            },
            items: [
              {
                term: 'Anrufer',
                description: 'Die Person, die ein Problem meldet',
                example: 'John Doe meldet einen defekten Laptop'
              },
              {
                term: 'Vorfall',
                description: 'Ein Support-Ticket für ein IT-Problem',
                example: '"E-Mail funktioniert nicht" Ticket'
              },
              {
                term: 'Operator',
                description: 'IT-Support-Mitarbeiter',
                example: 'Sarah vom Helpdesk-Team'
              },
              {
                term: 'Operator Gruppe',
                description: 'IT-Support-Team',
                example: '"1st Line Support", "Netzwerk-Team"'
              },
              {
                term: 'Kategorie/Unterkategorie',
                description: 'Klassifizierungssystem für Tickets',
                example: 'Hardware > Laptop, Software > E-Mail'
              },
              {
                term: 'Priorität/Dringlichkeit/Auswirkung',
                description: 'Ticket-Schweregrad-Indikatoren',
                example: 'P1 (Kritisch), P5 (Niedrige Priorität)'
              },
              {
                term: 'Bearbeitungsstatus',
                description: 'Wo sich das Ticket in seinem Lebenszyklus befindet',
                example: 'Neu, In Bearbeitung, Gelöst, Geschlossen'
              },
              {
                term: 'Änderung',
                description: 'Geplante Modifikation an IT-Systemen',
                example: '"E-Mail-Server am Sonntag upgraden"'
              },
              {
                term: 'Asset',
                description: 'IT-Ausrüstung oder Software in CMDB',
                example: 'Laptop ABC123, Windows Server XYZ'
              }
            ]
          },
          lifecycle: {
            title: 'Typischer Vorfall-Lebenszyklus'
          }
        },
        gettingStarted: {
          title: 'Erste Schritte',
          authentication: {
            title: 'Authentifizierung Einrichten',
            description: 'Sie benötigen API Management Anmeldedaten. Alle Anfragen erfordern diese Header:',
            headers: `Content-Type: application/json
  Access-Control-Allow-Origin: *
  Accept-Encoding: gzip, deflate, br`
          },
          firstCall: {
            title: 'Ihr erster API-Aufruf - Eine Person finden',
            description: 'Vor dem Erstellen von Tickets müssen Sie Benutzer-IDs finden:',
            code: `// Einen Benutzer nach Namen suchen
  const response = await fetch('/api/persons?query=dynamicName=="John Doe"', {
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*',
      'Accept-Encoding': 'gzip, deflate, br'
    }
  });
  
  const persons = await response.json();
  console.log(persons[0].id); // Diese ID beim Erstellen von Tickets verwenden`
          },
          dynamicDropdowns: {
            title: 'Dynamische Dropdowns Verstehen',
            warning: '⚠️ Kritisches Konzept: Warum Sie keine Werte fest codieren können',
            explanation: 'Diese Plattform ist hochgradig konfigurierbar. Jede Organisation passt ihre Instanz mit eigenen Kategorien, Operator-Gruppen, Prioritäten und Anruftypen an.',
            integration: {
              title: 'Was das für die Integration bedeutet:',
              wrongCode: `// ❌ FALSCH - Diese IDs funktionieren nicht in Ihrer Umgebung
  const ticketData = {
    category: { id: "12345-hardware" },      // Ihre Org hat das vielleicht nicht
    operatorGroup: { id: "67890-helpdesk" } // Andere ID in Ihrer Instanz
  };`,
              correctCode: `// ✅ RICHTIG - Aktuelle Optionen immer zuerst abrufen
  const categories = await getDropdownOptions('/api/categories/parent');
  const operatorGroups = await getDropdownOptions('/api/operatorgroups');
  
  const ticketData = {
    category: { id: categories.find(c => c.name === "Hardware").id },
    operatorGroup: { id: operatorGroups.find(g => g.groupName === "IT Support").id }
  };`
            },
            whyEssential: {
              title: 'Warum dieser Ansatz wesentlich ist:',
              reasons: [
                {
                  title: 'Konfigurationsänderungen',
                  description: 'Administratoren fügen regelmäßig Kategorien hinzu/entfernen/umbenennen'
                },
                {
                  title: 'Umgebungsunterschiede',
                  description: 'Dev-, Test- und Prod-Umgebungen haben unterschiedliche IDs'
                },
                {
                  title: 'Organisationsunterschiede',
                  description: 'Jede Unternehmensinstanz ist anders konfiguriert'
                },
                {
                  title: 'API-Fehler',
                  description: 'Die Verwendung ungültiger IDs führt zu 400 Bad Request Fehlern'
                }
              ]
            }
          }
        },
        apiReference: {
          title: 'API Referenz',
          essentialEndpoints: {
            title: 'Wesentliche Endpoints für den Einstieg',
            findUsers: {
              title: '1. Benutzer finden (Erforderlich für Ticket-Erstellung)',
              purpose: 'Zweck',
              purposeText: 'Benutzer-ID abrufen, die für die Erstellung von Tickets benötigt wird',
              returns: 'Gibt zurück',
              returnsText: 'Benutzerobjekt mit id, dynamicName, email'
            },
            dropdownOptions: {
              title: '2. Dropdown-Optionen abrufen (Erforderlich für Ticket-Erstellung)',
              endpoints: [
                {
                  path: '/api/categories/parent',
                  description: 'Kategorien für Ticket-Klassifizierung abrufen'
                },
                {
                  path: '/api/categories/sub',
                  description: 'Unterkategorien abrufen'
                },
                {
                  path: '/api/incidents/call_types',
                  description: 'Anruftypen abrufen (Vorfall, Serviceanfrage, etc.)'
                },
                {
                  path: '/api/operatorgroups?fields=id,groupName&page_size=100',
                  description: 'Operator-Gruppen abrufen (welches Team soll das behandeln?)'
                }
              ]
            },
            createTicket: {
              title: '3. Vorfall-Ticket erstellen',
              purpose: 'Zweck',
              purposeText: 'Ein neues Support-Ticket erstellen',
              requires: 'Erfordert',
              requiresText: 'Anrufer-ID + alle Dropdown-IDs aus Schritt 2'
            },
            searchKnowledgeBase: {
              title: '4. Wissensdatenbank durchsuchen',
              purpose: 'Zweck',
              purposeText: 'Hilfeartikel und Lösungen finden'
            }
          }
        },
        contact: {
          title: 'Kontaktinformationen',
          team: 'Support-Team',
          teamName: 'Technisches Support-Team',
          email: 'E-Mail',
          website: 'Website',
          supportText: 'Für technischen Support und Integrationshilfe wenden Sie sich bitte an unser Support-Team mit spezifischen Endpoint-Details und Fehlerinformationen.'
        }
      }
    },
    fr: {
      metadata: {
        title: 'Documentation API | Guide d\'Intégration Technique',
        description: 'Documentation technique complète pour l\'intégration API. Apprenez les concepts, points de terminaison et meilleures pratiques pour les développeurs.'
      },
      hero: {
        title: 'Documentation API',
        subtitle: 'Documentation technique complète pour les développeurs et intégrateurs système. Apprenez les concepts, explorez les points de terminaison et maîtrisez les pratiques d\'intégration.',
        cta: {
          primary: 'Commencer l\'Apprentissage'
        }
      },
      sections: {
        overview: {
          title: 'Introduction et Aperçu',
          whatIs: {
            title: 'Qu\'est-ce que cette API ?',
            content: 'Cette API est une plateforme complète qui gère les services IT, incidents, changements et actifs au sein d\'une organisation. Elle fournit un accès programmatique aux fonctionnalités principales, permettant l\'intégration avec des chatbots, workflows automatisés et applications personnalisées.'
          },
          apiOverview: {
            title: 'Aperçu de l\'API',
            host: 'Hôte',
            basePath: 'Chemin de Base',
            protocol: 'Protocole',
            protocolValue: 'HTTPS uniquement',
            authentication: 'Authentification',
            authValue: 'Gestion des clés API (clés d\'abonnement requises)'
          },
          capabilities: {
            title: 'Ce que Vous Pouvez Faire Avec Cette API',
            items: [
              {
                title: 'Créer et gérer les incidents',
                description: '(tickets de support IT)'
              },
              {
                title: 'Rechercher et récupérer les articles de base de connaissances',
                description: ''
              },
              {
                title: 'Accéder aux informations d\'actifs',
                description: 'depuis la Base de Données de Gestion de Configuration (CMDB)'
              },
              {
                title: 'Gérer les demandes de changement',
                description: 'et leur cycle de vie'
              },
              {
                title: 'Récupérer les données de support',
                description: '(utilisateurs, catégories, opérateurs, etc.)'
              }
            ]
          }
        },
        concepts: {
          title: 'Comprendre les Concepts Fondamentaux',
          entities: {
            title: 'Entités Principales et Leurs Relations'
          },
          terminology: {
            title: 'Terminologie Clé',
            headers: {
              term: 'Terme',
              description: 'Description',
              example: 'Exemple'
            },
            items: [
              {
                term: 'Appelant',
                description: 'La personne qui signale un problème',
                example: 'John Doe signalant un ordinateur portable cassé'
              },
              {
                term: 'Incident',
                description: 'Un ticket de support pour un problème IT',
                example: 'Ticket "L\'email ne fonctionne pas"'
              },
              {
                term: 'Opérateur',
                description: 'Membre du personnel de support IT',
                example: 'Sarah de l\'équipe Help Desk'
              },
              {
                term: 'Groupe d\'Opérateurs',
                description: 'Équipe de support IT',
                example: '"Support 1ère Ligne", "Équipe Réseau"'
              },
              {
                term: 'Catégorie/Sous-catégorie',
                description: 'Système de classification pour les tickets',
                example: 'Matériel > Ordinateur portable, Logiciel > Email'
              },
              {
                term: 'Priorité/Urgence/Impact',
                description: 'Indicateurs de gravité des tickets',
                example: 'P1 (Critique), P5 (Priorité faible)'
              },
              {
                term: 'Statut de Traitement',
                description: 'Où le ticket se trouve dans son cycle de vie',
                example: 'Nouveau, En Cours, Résolu, Fermé'
              },
              {
                term: 'Changement',
                description: 'Modification planifiée des systèmes IT',
                example: '"Mise à niveau du serveur email dimanche"'
              },
              {
                term: 'Actif',
                description: 'Équipement IT ou logiciel dans CMDB',
                example: 'Ordinateur portable ABC123, Serveur Windows XYZ'
              }
            ]
          },
          lifecycle: {
            title: 'Cycle de Vie Typique d\'un Incident'
          }
        },
        gettingStarted: {
          title: 'Premiers Pas',
          authentication: {
            title: 'Configuration de l\'Authentification',
            description: 'Vous aurez besoin des identifiants de gestion API. Toutes les requêtes nécessitent ces en-têtes :',
            headers: `Content-Type: application/json
  Access-Control-Allow-Origin: *
  Accept-Encoding: gzip, deflate, br`
          },
          firstCall: {
            title: 'Votre Premier Appel API - Trouver une Personne',
            description: 'Avant de créer des tickets, vous devez trouver les IDs utilisateur :',
            code: `// Trouver un utilisateur par nom
  const response = await fetch('/api/persons?query=dynamicName=="John Doe"', {
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*',
      'Accept-Encoding': 'gzip, deflate, br'
    }
  });
  
  const persons = await response.json();
  console.log(persons[0].id); // Utiliser cet ID lors de la création de tickets`
          },
          dynamicDropdowns: {
            title: 'Comprendre les Menus Déroulants Dynamiques',
            warning: '⚠️ Concept Critique : Pourquoi Vous Ne Pouvez Pas Coder en Dur les Valeurs',
            explanation: 'Cette plateforme est hautement configurable. Chaque organisation personnalise son instance avec ses propres catégories, groupes d\'opérateurs, priorités et types d\'appel.',
            integration: {
              title: 'Ce que Cela Signifie pour l\'Intégration :',
              wrongCode: `// ❌ INCORRECT - Ces IDs ne fonctionneront pas dans votre environnement
  const ticketData = {
    category: { id: "12345-hardware" },      // Votre org n'a peut-être pas ceci
    operatorGroup: { id: "67890-helpdesk" } // ID différent dans votre instance
  };`,
              correctCode: `// ✅ CORRECT - Toujours récupérer les options actuelles d'abord
  const categories = await getDropdownOptions('/api/categories/parent');
  const operatorGroups = await getDropdownOptions('/api/operatorgroups');
  
  const ticketData = {
    category: { id: categories.find(c => c.name === "Hardware").id },
    operatorGroup: { id: operatorGroups.find(g => g.groupName === "IT Support").id }
  };`
            },
            whyEssential: {
              title: 'Pourquoi Cette Approche est Essentielle :',
              reasons: [
                {
                  title: 'Changements de Configuration',
                  description: 'Les administrateurs ajoutent/suppriment/renomment régulièrement les catégories'
                },
                {
                  title: 'Différences d\'Environnement',
                  description: 'Les environnements dev, test et prod ont des IDs différents'
                },
                {
                  title: 'Différences d\'Organisation',
                  description: 'Chaque instance d\'entreprise est configurée différemment'
                },
                {
                  title: 'Échecs d\'API',
                  description: 'L\'utilisation d\'IDs invalides entraîne des erreurs 400 Bad Request'
                }
              ]
            }
          }
        },
        apiReference: {
          title: 'Référence API',
          essentialEndpoints: {
            title: 'Points de Terminaison Essentiels pour Commencer',
            findUsers: {
              title: '1. Trouver les Utilisateurs (Requis pour la création de tickets)',
              purpose: 'Objectif',
              purposeText: 'Obtenir l\'ID utilisateur nécessaire pour créer des tickets',
              returns: 'Retourne',
              returnsText: 'Objet utilisateur avec id, dynamicName, email'
            },
            dropdownOptions: {
              title: '2. Obtenir les Options de Menu Déroulant (Requis pour la création de tickets)',
              endpoints: [
                {
                  path: '/api/categories/parent',
                  description: 'Obtenir les catégories pour la classification des tickets'
                },
                {
                  path: '/api/categories/sub',
                  description: 'Obtenir les sous-catégories'
                },
                {
                  path: '/api/incidents/call_types',
                  description: 'Obtenir les types d\'appel (incident, demande de service, etc.)'
                },
                {
                  path: '/api/operatorgroups?fields=id,groupName&page_size=100',
                  description: 'Obtenir les groupes d\'opérateurs (quelle équipe devrait gérer ceci ?)'
                }
              ]
            },
            createTicket: {
              title: '3. Créer un Ticket d\'Incident',
              purpose: 'Objectif',
              purposeText: 'Créer un nouveau ticket de support',
              requires: 'Nécessite',
              requiresText: 'ID de l\'appelant + tous les IDs de menu déroulant de l\'étape 2'
            },
            searchKnowledgeBase: {
              title: '4. Rechercher dans la Base de Connaissances',
              purpose: 'Objectif',
              purposeText: 'Trouver des articles d\'aide et des solutions'
            }
          }
        },
        contact: {
          title: 'Informations de Contact',
          team: 'Équipe de Support',
          teamName: 'Équipe de Support Technique',
          email: 'Email',
          website: 'Site Web',
          supportText: 'Pour le support technique et l\'aide à l\'intégration, veuillez contacter notre équipe de support avec des détails spécifiques sur les points de terminaison et les informations d\'erreur.'
        }
      }
    }
  };