lynkow 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,1384 @@
+/**
+ * Configuration interne normalisee
+ */
+interface InternalConfig {
+    siteId: string;
+    baseUrl: string;
+    locale?: string;
+    fetchOptions: RequestInit;
+}
+/**
+ * Service de base dont heritent tous les services specifiques
+ */
+declare abstract class BaseService {
+    protected config: InternalConfig;
+    constructor(config: InternalConfig);
+    /**
+     * Construit l'URL complete pour un endpoint
+     */
+    protected buildEndpointUrl(path: string, query?: Record<string, unknown>): string;
+    /**
+     * Effectue une requete GET
+     */
+    protected get<T>(path: string, query?: Record<string, unknown>, options?: BaseRequestOptions): Promise<T>;
+    /**
+     * Effectue une requete POST
+     */
+    protected post<T>(path: string, body: Record<string, unknown>, options?: BaseRequestOptions): Promise<T>;
+    /**
+     * Effectue une requete GET qui retourne du texte brut (XML, txt)
+     */
+    protected getText(path: string, options?: BaseRequestOptions): Promise<string>;
+    /**
+     * Fusionne les options fetch locales avec celles globales
+     */
+    private mergeFetchOptions;
+}
+
+/**
+ * Service pour les contenus (articles de blog)
+ */
+declare class ContentsService extends BaseService {
+    /**
+     * Recupere une liste paginee de contenus publies
+     *
+     * @param filters - Filtres optionnels (pagination, categorie, tag, recherche)
+     * @param options - Options de requete
+     * @returns Liste paginee de contenus
+     *
+     * @example
+     * ```typescript
+     * const { data, meta } = await lynkow.contents.list({
+     *   page: 1,
+     *   perPage: 10,
+     *   category: 'tech'
+     * })
+     * ```
+     */
+    list(filters?: ContentsFilters, options?: BaseRequestOptions): Promise<ContentsListResponse>;
+    /**
+     * Recupere un contenu par son slug
+     *
+     * @param slug - Slug du contenu
+     * @param options - Options de requete (locale)
+     * @returns Contenu complet
+     *
+     * @example
+     * ```typescript
+     * const content = await lynkow.contents.getBySlug('my-article')
+     * ```
+     */
+    getBySlug(slug: string, options?: BaseRequestOptions): Promise<Content>;
+}
+
+/**
+ * Service pour les categories
+ */
+declare class CategoriesService extends BaseService {
+    /**
+     * Recupere la liste des categories
+     *
+     * @param options - Options de requete (locale)
+     * @returns Liste des categories avec compteurs
+     *
+     * @example
+     * ```typescript
+     * const { data, blogUrlMode } = await lynkow.categories.list()
+     * ```
+     */
+    list(options?: BaseRequestOptions): Promise<CategoriesListResponse>;
+    /**
+     * Recupere l'arborescence des categories
+     *
+     * @param options - Options de requete (locale)
+     * @returns Arborescence complete
+     *
+     * @example
+     * ```typescript
+     * const { data } = await lynkow.categories.tree()
+     * // data[0].children contient les sous-categories
+     * ```
+     */
+    tree(options?: BaseRequestOptions): Promise<CategoryTreeResponse>;
+    /**
+     * Recupere une categorie avec ses contenus pagines
+     *
+     * @param slug - Slug de la categorie
+     * @param options - Options (locale, pagination)
+     * @returns Categorie avec contenus
+     *
+     * @example
+     * ```typescript
+     * const { category, contents } = await lynkow.categories.getBySlug('tech', {
+     *   page: 1,
+     *   perPage: 10
+     * })
+     * ```
+     */
+    getBySlug(slug: string, options?: CategoryOptions & BaseRequestOptions): Promise<CategoryDetailResponse>;
+}
+
+/**
+ * Service pour les tags
+ */
+declare class TagsService extends BaseService {
+    /**
+     * Recupere la liste des tags
+     *
+     * @param options - Options de requete (locale)
+     * @returns Liste des tags
+     *
+     * @example
+     * ```typescript
+     * const { data } = await lynkow.tags.list()
+     * ```
+     */
+    list(options?: BaseRequestOptions): Promise<TagsListResponse>;
+}
+
+/**
+ * Service pour les pages (Site Blocks de type "page")
+ */
+declare class PagesService extends BaseService {
+    /**
+     * Recupere la liste des pages publiees
+     *
+     * @param options - Options de requete (locale)
+     * @returns Liste des pages
+     *
+     * @example
+     * ```typescript
+     * const { data } = await lynkow.pages.list()
+     * ```
+     */
+    list(options?: BaseRequestOptions): Promise<PagesListResponse>;
+    /**
+     * Recupere une page par son slug
+     *
+     * @param slug - Slug de la page
+     * @param options - Options de requete (locale)
+     * @returns Page complete avec donnees resolues
+     *
+     * @example
+     * ```typescript
+     * const page = await lynkow.pages.getBySlug('about')
+     * ```
+     */
+    getBySlug(slug: string, options?: BaseRequestOptions): Promise<Page>;
+    /**
+     * Recupere une page par son chemin
+     *
+     * @param path - Chemin de la page (ex: /services/consulting)
+     * @param options - Options de requete (locale)
+     * @returns Page complete avec donnees resolues
+     *
+     * @example
+     * ```typescript
+     * const page = await lynkow.pages.getByPath('/services/consulting')
+     * ```
+     */
+    getByPath(path: string, options?: BaseRequestOptions): Promise<Page>;
+    /**
+     * Recupere les donnees JSON-LD pour une page
+     *
+     * @param slug - Slug de la page
+     * @param options - Options de requete (locale)
+     * @returns Donnees JSON-LD (Schema.org)
+     *
+     * @example
+     * ```typescript
+     * const jsonLd = await lynkow.pages.getJsonLd('about')
+     * // Utiliser dans <script type="application/ld+json">
+     * ```
+     */
+    getJsonLd(slug: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
+}
+
+/**
+ * Service pour les blocs globaux (header, footer, etc.)
+ */
+declare class BlocksService extends BaseService {
+    /**
+     * Recupere la configuration du site avec tous les blocs globaux
+     *
+     * @param options - Options de requete (locale)
+     * @returns Configuration et blocs globaux
+     *
+     * @example
+     * ```typescript
+     * const { data } = await lynkow.blocks.siteConfig()
+     * const header = data.globals['header']
+     * const footer = data.globals['footer']
+     * ```
+     */
+    siteConfig(options?: BaseRequestOptions): Promise<SiteConfigResponse>;
+    /**
+     * Recupere un bloc global specifique par son slug
+     *
+     * @param slug - Slug du bloc (ex: 'header', 'footer')
+     * @param options - Options de requete (locale)
+     * @returns Bloc global avec donnees resolues
+     *
+     * @example
+     * ```typescript
+     * const { data } = await lynkow.blocks.global('header')
+     * // data.data contient les donnees du bloc
+     * ```
+     */
+    global(slug: string, options?: BaseRequestOptions): Promise<GlobalBlockResponse>;
+}
+
+/**
+ * Service pour les formulaires
+ */
+declare class FormsService extends BaseService {
+    /**
+     * Timestamp de creation du client (pour anti-spam)
+     */
+    private sessionStartTime;
+    constructor(config: InternalConfig);
+    /**
+     * Recupere un formulaire par son slug
+     *
+     * @param slug - Slug du formulaire
+     * @returns Schema du formulaire
+     *
+     * @example
+     * ```typescript
+     * const form = await lynkow.forms.getBySlug('contact')
+     * // Utiliser form.schema pour generer le formulaire
+     * ```
+     */
+    getBySlug(slug: string): Promise<Form>;
+    /**
+     * Soumet un formulaire
+     *
+     * Les champs anti-spam (_hp, _ts) sont ajoutes automatiquement.
+     *
+     * @param slug - Slug du formulaire
+     * @param data - Donnees du formulaire
+     * @param options - Options (token reCAPTCHA si active)
+     * @returns Reponse de soumission
+     *
+     * @example
+     * ```typescript
+     * const result = await lynkow.forms.submit('contact', {
+     *   name: 'John Doe',
+     *   email: 'john@example.com',
+     *   message: 'Hello!'
+     * })
+     * ```
+     */
+    submit(slug: string, data: FormSubmitData, options?: SubmitOptions & BaseRequestOptions): Promise<FormSubmitResponse>;
+}
+
+/**
+ * Service pour les avis clients
+ */
+declare class ReviewsService extends BaseService {
+    /**
+     * Timestamp de creation du client (pour anti-spam)
+     */
+    private sessionStartTime;
+    constructor(config: InternalConfig);
+    /**
+     * Recupere la liste des avis approuves
+     *
+     * @param filters - Filtres (pagination, note)
+     * @param options - Options de requete
+     * @returns Liste paginee des avis
+     *
+     * @example
+     * ```typescript
+     * const { data, meta } = await lynkow.reviews.list({
+     *   minRating: 4,
+     *   perPage: 10
+     * })
+     * ```
+     */
+    list(filters?: ReviewsFilters, options?: BaseRequestOptions): Promise<ReviewsListResponse>;
+    /**
+     * Recupere un avis par son slug ou ID
+     *
+     * @param slugOrId - Slug ou ID de l'avis
+     * @returns Avis complet
+     *
+     * @example
+     * ```typescript
+     * const review = await lynkow.reviews.getBySlug('excellent-service')
+     * ```
+     */
+    getBySlug(slugOrId: string): Promise<Review>;
+    /**
+     * Recupere les parametres publics des avis
+     *
+     * @returns Parametres (champs requis, echelle de notes, etc.)
+     *
+     * @example
+     * ```typescript
+     * const settings = await lynkow.reviews.settings()
+     * if (settings.fields.email.required) {
+     *   // Afficher le champ email comme requis
+     * }
+     * ```
+     */
+    settings(): Promise<ReviewSettings>;
+    /**
+     * Soumet un nouvel avis
+     *
+     * Les champs anti-spam (_hp, _ts) sont ajoutes automatiquement.
+     *
+     * @param data - Donnees de l'avis
+     * @param options - Options (token reCAPTCHA si active)
+     * @returns Reponse de soumission
+     *
+     * @example
+     * ```typescript
+     * const result = await lynkow.reviews.submit({
+     *   authorName: 'Alice',
+     *   rating: 5,
+     *   content: 'Excellent service !'
+     * })
+     * ```
+     */
+    submit(data: ReviewSubmitData, options?: SubmitOptions & BaseRequestOptions): Promise<ReviewSubmitResponse>;
+}
+
+/**
+ * Service pour la configuration du site
+ */
+declare class SiteService extends BaseService {
+    /**
+     * Recupere la configuration publique du site
+     *
+     * @returns Configuration du site
+     *
+     * @example
+     * ```typescript
+     * const config = await lynkow.site.getConfig()
+     * console.log(config.enabledLocales) // ['fr', 'en']
+     * ```
+     */
+    getConfig(): Promise<SiteConfig>;
+}
+
+/**
+ * Service pour les documents legaux
+ */
+declare class LegalService extends BaseService {
+    /**
+     * Recupere la liste des documents legaux
+     *
+     * @param options - Options de requete (locale)
+     * @returns Liste des documents disponibles
+     *
+     * @example
+     * ```typescript
+     * const { data } = await lynkow.legal.list()
+     * ```
+     */
+    list(options?: BaseRequestOptions): Promise<LegalListResponse>;
+    /**
+     * Recupere un document legal par son type
+     *
+     * @param type - Type de document ('terms', 'privacy', etc.)
+     * @param options - Options de requete (locale)
+     * @returns Document legal complet
+     *
+     * @example
+     * ```typescript
+     * const privacy = await lynkow.legal.getByType('privacy')
+     * // privacy.content contient le HTML
+     * ```
+     */
+    getByType(type: LegalDocumentType, options?: BaseRequestOptions): Promise<LegalDocument>;
+}
+
+/**
+ * Service pour le consentement cookies
+ */
+declare class CookiesService extends BaseService {
+    /**
+     * Recupere la configuration du bandeau de cookies
+     *
+     * @returns Configuration du bandeau
+     *
+     * @example
+     * ```typescript
+     * const config = await lynkow.cookies.getConfig()
+     * if (config.enabled) {
+     *   // Afficher le bandeau
+     * }
+     * ```
+     */
+    getConfig(): Promise<CookieConfig>;
+    /**
+     * Enregistre le consentement de l'utilisateur
+     *
+     * @param preferences - Preferences par categorie
+     * @returns Confirmation avec ID du consentement
+     *
+     * @example
+     * ```typescript
+     * await lynkow.cookies.logConsent({
+     *   necessary: true,
+     *   analytics: true,
+     *   marketing: false
+     * })
+     * ```
+     */
+    logConsent(preferences: CookiePreferences, options?: BaseRequestOptions): Promise<ConsentLogResponse>;
+}
+
+/**
+ * Service pour les fichiers SEO
+ */
+declare class SeoService extends BaseService {
+    /**
+     * Recupere le sitemap XML
+     *
+     * @returns Contenu XML du sitemap
+     *
+     * @example
+     * ```typescript
+     * // Dans une route API Next.js
+     * export async function GET() {
+     *   const xml = await lynkow.seo.sitemap()
+     *   return new Response(xml, {
+     *     headers: { 'Content-Type': 'application/xml' }
+     *   })
+     * }
+     * ```
+     */
+    sitemap(options?: BaseRequestOptions): Promise<string>;
+    /**
+     * Recupere le fichier robots.txt
+     *
+     * @returns Contenu du robots.txt
+     *
+     * @example
+     * ```typescript
+     * // Dans une route API Next.js
+     * export async function GET() {
+     *   const txt = await lynkow.seo.robots()
+     *   return new Response(txt, {
+     *     headers: { 'Content-Type': 'text/plain' }
+     *   })
+     * }
+     * ```
+     */
+    robots(options?: BaseRequestOptions): Promise<string>;
+}
+
+/**
+ * Service pour les chemins (SSG, resolution)
+ */
+declare class PathsService extends BaseService {
+    /**
+     * Recupere tous les chemins pour la generation statique
+     *
+     * @param options - Options de requete (locale)
+     * @returns Liste des chemins
+     *
+     * @example
+     * ```typescript
+     * // Dans generateStaticParams() de Next.js
+     * export async function generateStaticParams() {
+     *   const { paths } = await lynkow.paths.list()
+     *   return paths.map(p => ({
+     *     slug: p.segments
+     *   }))
+     * }
+     * ```
+     */
+    list(options?: BaseRequestOptions): Promise<PathsListResponse>;
+    /**
+     * Resout un chemin vers son contenu ou categorie
+     *
+     * @param path - Chemin a resoudre
+     * @param options - Options de requete
+     * @returns Contenu ou categorie correspondant
+     *
+     * @example
+     * ```typescript
+     * const result = await lynkow.paths.resolve('/blog/tech/my-article')
+     *
+     * if (result.type === 'content') {
+     *   // Afficher l'article
+     * } else {
+     *   // Afficher la categorie avec ses articles
+     * }
+     * ```
+     */
+    resolve(path: string, options?: BaseRequestOptions): Promise<ResolveResponse>;
+    /**
+     * Verifie si un chemin a une redirection configuree
+     *
+     * @param path - Chemin a verifier
+     * @returns Redirection ou null
+     *
+     * @example
+     * ```typescript
+     * // Dans un middleware Next.js
+     * const redirect = await lynkow.paths.matchRedirect(pathname)
+     * if (redirect) {
+     *   return NextResponse.redirect(redirect.target, redirect.statusCode)
+     * }
+     * ```
+     */
+    matchRedirect(path: string, options?: BaseRequestOptions): Promise<Redirect | null>;
+}
+
+/**
+ * Configuration pour creer une instance du client Lynkow
+ */
+interface LynkowConfig {
+    /**
+     * UUID du site Lynkow (requis)
+     * @example "550e8400-e29b-41d4-a716-446655440000"
+     */
+    siteId: string;
+    /**
+     * URL de base de l'API
+     * @default "https://api.lynkow.com"
+     */
+    baseUrl?: string;
+    /**
+     * Locale par defaut pour les requetes
+     * Sera utilisee si non specifiee dans les options de requete
+     * @example "fr"
+     */
+    locale?: string;
+    /**
+     * Options passees a toutes les requetes fetch()
+     * Permet d'integrer avec le cache Next.js, etc.
+     */
+    fetchOptions?: RequestInit;
+}
+/**
+ * Client Lynkow - Point d'entree principal du SDK
+ */
+interface LynkowClient {
+    /** Service pour les contenus (articles de blog) */
+    contents: ContentsService;
+    /** Service pour les categories */
+    categories: CategoriesService;
+    /** Service pour les tags */
+    tags: TagsService;
+    /** Service pour les pages (Site Blocks) */
+    pages: PagesService;
+    /** Service pour les blocs globaux (header, footer) */
+    blocks: BlocksService;
+    /** Service pour les formulaires */
+    forms: FormsService;
+    /** Service pour les avis clients */
+    reviews: ReviewsService;
+    /** Service pour la configuration du site */
+    site: SiteService;
+    /** Service pour les documents legaux */
+    legal: LegalService;
+    /** Service pour le consentement cookies */
+    cookies: CookiesService;
+    /** Service pour les fichiers SEO */
+    seo: SeoService;
+    /** Service pour les chemins (SSG) */
+    paths: PathsService;
+}
+
+/**
+ * Categorie de contenu
+ */
+interface Category {
+    /** ID unique */
+    id: number;
+    /** Nom de la categorie */
+    name: string;
+    /** Slug URL-friendly */
+    slug: string;
+    /** Locale */
+    locale: string;
+}
+/**
+ * Categorie avec chemin et compteur
+ */
+interface CategoryWithCount extends Category {
+    /** Chemin complet */
+    path: string;
+    /** Description */
+    description: string | null;
+    /** URL de l'image */
+    image: string | null;
+    /** Nombre de contenus dans cette categorie */
+    contentCount: number;
+}
+/**
+ * Categorie detaillee (avec toutes les infos)
+ */
+interface CategoryDetail extends CategoryWithCount {
+    /** ID de la categorie parente */
+    parentId: number | null;
+}
+/**
+ * Noeud de l'arborescence des categories
+ */
+interface CategoryTreeNode extends CategoryWithCount {
+    /** Sous-categories */
+    children: CategoryTreeNode[];
+}
+
+/**
+ * Tag de contenu
+ */
+interface Tag {
+    /** ID unique */
+    id: number;
+    /** Nom du tag */
+    name: string;
+    /** Slug URL-friendly */
+    slug: string;
+    /** Locale */
+    locale: string;
+}
+
+/**
+ * Auteur d'un contenu
+ */
+interface Author {
+    /** ID unique */
+    id: number;
+    /** Nom complet */
+    fullName: string;
+    /** URL de l'avatar */
+    avatarUrl: string | null;
+}
+/**
+ * Bloc de contenu individuel
+ */
+interface ContentBlock {
+    /** Type de bloc */
+    type: 'paragraph' | 'heading' | 'image' | 'list' | 'quote' | 'code' | 'embed' | 'table' | 'divider' | string;
+    /** Donnees specifiques au type */
+    data: Record<string, unknown>;
+    /** ID unique du bloc */
+    id?: string;
+}
+/**
+ * Corps du contenu (blocs editeur)
+ */
+type ContentBody = ContentBlock[];
+/**
+ * Resume d'un contenu (pour les listes)
+ */
+interface ContentSummary {
+    id: number;
+    title: string;
+    slug: string;
+    path: string;
+    excerpt: string | null;
+    featuredImage: string | null;
+    locale: string;
+    publishedAt: string;
+    createdAt: string;
+}
+/**
+ * Contenu complet (article de blog)
+ */
+interface Content extends ContentSummary {
+    /** Corps de l'article (blocs de contenu) */
+    body: ContentBody;
+    /** Statut (toujours 'published' via API publique) */
+    status: 'published';
+    /** Date de derniere modification */
+    updatedAt: string;
+    /** Meta title personnalise */
+    metaTitle: string | null;
+    /** Meta description */
+    metaDescription: string | null;
+    /** Mots-cles SEO */
+    keywords: string | null;
+    /** URL canonique */
+    canonicalUrl: string | null;
+    /** Image Open Graph */
+    ogImage: string | null;
+    /** Donnees structurees JSON-LD */
+    structuredData: Record<string, unknown> | null;
+    /** Auteur de l'article */
+    author: Author | null;
+    /** Categories associees */
+    categories: Category[];
+    /** Tags associes */
+    tags: Tag[];
+}
+
+/**
+ * Parametres SEO d'une page
+ */
+interface PageSeo {
+    /** Meta title */
+    title: string | null;
+    /** Meta description */
+    description: string | null;
+    /** Mots-cles */
+    keywords: string | null;
+    /** Image Open Graph */
+    ogImage: string | null;
+    /** URL canonique */
+    canonicalUrl: string | null;
+    /** Directive noindex */
+    noIndex: boolean;
+    /** Directive nofollow */
+    noFollow: boolean;
+}
+/**
+ * Version alternative (autre locale)
+ */
+interface Alternate {
+    /** Locale de cette version */
+    locale: string;
+    /** Chemin de cette version */
+    path: string;
+    /** Est-ce la version actuelle */
+    current: boolean;
+}
+/**
+ * Resume d'une page
+ */
+interface PageSummary {
+    /** ID unique */
+    id: number;
+    /** Slug URL-friendly */
+    slug: string;
+    /** Nom de la page */
+    name: string;
+    /** Chemin URL */
+    path: string | null;
+    /** Locale */
+    locale: string;
+    /** Date de derniere modification */
+    updatedAt: string | null;
+}
+/**
+ * Page complete avec donnees resolues
+ */
+interface Page extends PageSummary {
+    /** Donnees du bloc (resolues depuis les DataSources) */
+    data: Record<string, unknown>;
+    /** Parametres SEO */
+    seo: PageSeo | null;
+    /** Versions dans d'autres locales */
+    alternates: Alternate[];
+    /** Avertissements de resolution (si des DataSources ont echoue) */
+    _warnings?: string[];
+}
+
+/**
+ * Bloc global
+ */
+interface GlobalBlock {
+    /** Slug du bloc */
+    slug: string;
+    /** Nom du bloc */
+    name: string;
+    /** Donnees du bloc (resolues) */
+    data: Record<string, unknown>;
+    /** Avertissements de resolution */
+    _warnings?: string[];
+}
+
+/**
+ * Types de champs supportes
+ */
+type FormFieldType = 'text' | 'email' | 'tel' | 'url' | 'textarea' | 'number' | 'date' | 'datetime' | 'time' | 'select' | 'radio' | 'checkbox' | 'file' | 'hidden';
+/**
+ * Option pour les champs select/radio/checkbox
+ */
+interface FormFieldOption {
+    /** Valeur envoyee */
+    value: string;
+    /** Label affiche */
+    label: string;
+}
+/**
+ * Regles de validation
+ */
+interface FormFieldValidation {
+    /** Longueur minimum */
+    minLength?: number;
+    /** Longueur maximum */
+    maxLength?: number;
+    /** Valeur minimum (pour number) */
+    min?: number;
+    /** Valeur maximum (pour number) */
+    max?: number;
+    /** Pattern regex */
+    pattern?: string;
+    /** Message d'erreur personnalise */
+    message?: string;
+}
+/**
+ * Champ de formulaire
+ */
+interface FormField {
+    /** Nom du champ (cle dans les donnees) */
+    name: string;
+    /** Type de champ */
+    type: FormFieldType;
+    /** Label affiche */
+    label: string;
+    /** Placeholder */
+    placeholder?: string;
+    /** Champ requis */
+    required: boolean;
+    /** Options (pour select, radio, checkbox) */
+    options?: FormFieldOption[];
+    /** Regles de validation */
+    validation?: FormFieldValidation;
+    /** Valeur par defaut */
+    defaultValue?: string | number | boolean;
+    /** Texte d'aide */
+    helpText?: string;
+    /** Largeur (pour le layout) */
+    width?: 'full' | 'half' | 'third';
+}
+/**
+ * Parametres du formulaire
+ */
+interface FormSettings {
+    /** Texte du bouton de soumission */
+    submitLabel: string;
+    /** Message de succes */
+    successMessage: string;
+    /** URL de redirection apres soumission */
+    redirectUrl?: string;
+    /** Activer la double confirmation email */
+    doubleOptIn?: boolean;
+}
+/**
+ * Formulaire
+ */
+interface Form {
+    /** ID unique */
+    id: number;
+    /** Nom du formulaire */
+    name: string;
+    /** Slug URL-friendly */
+    slug: string;
+    /** Description */
+    description: string | null;
+    /** Schema des champs */
+    schema: FormField[];
+    /** Parametres du formulaire */
+    settings: FormSettings;
+    /** Statut */
+    status: 'active';
+}
+/**
+ * Donnees de soumission de formulaire
+ */
+type FormSubmitData = Record<string, string | number | boolean | File>;
+
+/**
+ * Reponse a un avis
+ */
+interface ReviewResponse {
+    /** Contenu de la reponse */
+    content: string;
+    /** Date de la reponse */
+    respondedAt: string;
+}
+/**
+ * Avis client
+ */
+interface Review {
+    /** ID unique */
+    id: number;
+    /** Slug URL-friendly */
+    slug: string | null;
+    /** Nom de l'auteur */
+    authorName: string;
+    /** Email de l'auteur (peut etre masque) */
+    authorEmail?: string;
+    /** Note (1-5) */
+    rating: number;
+    /** Titre de l'avis */
+    title: string | null;
+    /** Contenu de l'avis */
+    content: string;
+    /** Locale */
+    locale: string;
+    /** Statut (toujours 'approved' via API publique) */
+    status: 'approved';
+    /** Date de creation */
+    createdAt: string;
+    /** Reponse du site (si presente) */
+    response?: ReviewResponse;
+}
+/**
+ * Parametres publics des avis
+ */
+interface ReviewSettings {
+    /** Avis actives pour ce site */
+    enabled: boolean;
+    /** Moderation requise avant publication */
+    requireApproval: boolean;
+    /** Autoriser les avis anonymes */
+    allowAnonymous: boolean;
+    /** Note minimum */
+    minRating: number;
+    /** Note maximum */
+    maxRating: number;
+    /** Configuration des champs */
+    fields: {
+        title: {
+            enabled: boolean;
+            required: boolean;
+        };
+        email: {
+            enabled: boolean;
+            required: boolean;
+        };
+    };
+}
+/**
+ * Donnees pour soumettre un avis
+ */
+interface ReviewSubmitData {
+    /** Nom de l'auteur */
+    authorName: string;
+    /** Email de l'auteur */
+    authorEmail?: string;
+    /** Note (1-5) */
+    rating: number;
+    /** Titre (optionnel selon settings) */
+    title?: string;
+    /** Contenu de l'avis */
+    content: string;
+}
+
+/**
+ * Configuration publique du site
+ */
+interface SiteConfig {
+    /** UUID du site */
+    id: string;
+    /** Nom du site */
+    name: string;
+    /** Domaine principal */
+    domain: string;
+    /** Description du site */
+    description: string | null;
+    /** URL du logo */
+    logoUrl: string | null;
+    /** URL du favicon */
+    faviconUrl: string | null;
+    /** Fuseau horaire */
+    timezone: string;
+    /** Locale par defaut */
+    defaultLocale: string;
+    /** Multi-langue active */
+    multiLanguageEnabled: boolean;
+    /** Locales disponibles */
+    enabledLocales: string[];
+    /** Parametres additionnels */
+    settings: Record<string, unknown>;
+}
+
+/**
+ * Types de documents legaux
+ */
+type LegalDocumentType = 'terms' | 'privacy' | 'cookies' | 'legal-notice' | 'refund' | 'shipping';
+/**
+ * Resume d'un document legal
+ */
+interface LegalDocumentSummary {
+    /** Type de document */
+    type: LegalDocumentType;
+    /** Titre */
+    title: string;
+    /** Date de mise a jour */
+    updatedAt: string;
+}
+/**
+ * Document legal complet
+ */
+interface LegalDocument extends LegalDocumentSummary {
+    /** Contenu HTML */
+    content: string;
+    /** Locale */
+    locale: string;
+    /** Version du document */
+    version: string;
+    /** Date d'effet */
+    effectiveDate: string;
+}
+
+/**
+ * Categorie de cookies
+ */
+interface CookieCategory {
+    /** ID de la categorie */
+    id: string;
+    /** Nom affiche */
+    name: string;
+    /** Description */
+    description: string;
+    /** Categorie obligatoire (ne peut pas etre desactivee) */
+    required: boolean;
+}
+/**
+ * Textes du bandeau de cookies
+ */
+interface CookieTexts {
+    /** Titre */
+    title: string;
+    /** Description/message */
+    description: string;
+    /** Bouton "Tout accepter" */
+    acceptAll: string;
+    /** Bouton "Tout refuser" */
+    rejectAll: string;
+    /** Bouton "Personnaliser" */
+    customize: string;
+    /** Bouton "Enregistrer" */
+    save: string;
+}
+/**
+ * Configuration du bandeau de cookies
+ */
+interface CookieConfig {
+    /** Bandeau active */
+    enabled: boolean;
+    /** Position du bandeau */
+    position: 'bottom' | 'top' | 'bottom-left' | 'bottom-right';
+    /** Style du bandeau */
+    layout: 'bar' | 'box' | 'popup';
+    /** Theme */
+    theme: 'light' | 'dark' | 'auto';
+    /** Categories de cookies */
+    categories: CookieCategory[];
+    /** Textes du bandeau */
+    texts: CookieTexts;
+}
+/**
+ * Preferences de consentement
+ */
+type CookiePreferences = Record<string, boolean>;
+
+/**
+ * Chemin pour generation statique
+ */
+interface Path {
+    /** Chemin complet (ex: /blog/tech/my-article) */
+    path: string;
+    /** Segments du chemin */
+    segments: string[];
+    /** Type de ressource */
+    type: 'content' | 'category';
+    /** Locale */
+    locale: string;
+    /** Date de derniere modification */
+    lastModified: string;
+}
+/**
+ * Redirection
+ */
+interface Redirect {
+    /** Chemin source */
+    source: string;
+    /** Chemin cible */
+    target: string;
+    /** Code HTTP */
+    statusCode: 301 | 302 | 307 | 308;
+    /** Preserver la query string */
+    preserveQueryString: boolean;
+}
+
+/**
+ * Metadonnees de pagination
+ */
+interface PaginationMeta {
+    /** Nombre total d'elements */
+    total: number;
+    /** Elements par page */
+    perPage: number;
+    /** Page actuelle */
+    currentPage: number;
+    /** Derniere page */
+    lastPage: number;
+    /** Premiere page */
+    firstPage: number;
+    /** Y a-t-il plus de pages */
+    hasMorePages: boolean;
+    /** Y a-t-il des pages precedentes */
+    hasPreviousPages: boolean;
+}
+/**
+ * Reponse paginee generique
+ */
+interface PaginatedResponse<T> {
+    data: T[];
+    meta: PaginationMeta;
+}
+/**
+ * Reponse de liste des contenus
+ */
+interface ContentsListResponse {
+    data: ContentSummary[];
+    meta: PaginationMeta;
+}
+/**
+ * Reponse de liste des categories
+ */
+interface CategoriesListResponse {
+    data: CategoryWithCount[];
+    blogUrlMode: string;
+    locale: string | null;
+}
+/**
+ * Reponse de l'arborescence des categories
+ */
+interface CategoryTreeResponse {
+    data: CategoryTreeNode[];
+    blogUrlMode: string;
+    locale: string | null;
+}
+/**
+ * Reponse de detail d'une categorie
+ */
+interface CategoryDetailResponse {
+    category: CategoryDetail;
+    contents: {
+        data: ContentSummary[];
+        meta: PaginationMeta;
+    };
+    locale: string | null;
+}
+/**
+ * Reponse de liste des tags
+ */
+interface TagsListResponse {
+    data: Tag[];
+}
+/**
+ * Reponse de liste des pages
+ */
+interface PagesListResponse {
+    data: PageSummary[];
+}
+/**
+ * Reponse de configuration du site avec blocs globaux
+ */
+interface SiteConfigResponse {
+    data: {
+        site: {
+            name: string;
+            domain: string;
+            logo: string | null;
+            favicon: string | null;
+        };
+        locale: string;
+        globals: Record<string, GlobalBlock>;
+    };
+}
+/**
+ * Reponse d'un bloc global
+ */
+interface GlobalBlockResponse {
+    data: GlobalBlock;
+}
+/**
+ * Reponse de liste des avis
+ */
+interface ReviewsListResponse {
+    data: Review[];
+    meta: PaginationMeta;
+}
+/**
+ * Reponse de soumission de formulaire
+ */
+interface FormSubmitResponse {
+    message: string;
+    status: 'success' | 'pending';
+    submissionId?: number;
+}
+/**
+ * Reponse de soumission d'avis
+ */
+interface ReviewSubmitResponse {
+    message: string;
+    status: 'success' | 'pending';
+    reviewId?: number;
+}
+/**
+ * Reponse de liste des documents legaux
+ */
+interface LegalListResponse {
+    data: LegalDocumentSummary[];
+}
+/**
+ * Reponse d'enregistrement de consentement
+ */
+interface ConsentLogResponse {
+    message: string;
+    consentId: string;
+}
+/**
+ * Reponse de liste des chemins
+ */
+interface PathsListResponse {
+    paths: Path[];
+    blogUrlMode: string;
+    locale: string | null;
+}
+/**
+ * Reponse de resolution d'un chemin vers un contenu
+ */
+interface ContentResolveResponse {
+    type: 'content';
+    locale: string;
+    blogUrlMode: string;
+    content: Content;
+}
+/**
+ * Reponse de resolution d'un chemin vers une categorie
+ */
+interface CategoryResolveResponse {
+    type: 'category';
+    locale: string;
+    blogUrlMode: string;
+    category: CategoryDetail;
+    contents: {
+        data: ContentSummary[];
+        meta: PaginationMeta;
+    };
+}
+/**
+ * Reponse de resolution de chemin (union)
+ */
+type ResolveResponse = ContentResolveResponse | CategoryResolveResponse;
+
+/**
+ * Options de base pour les requetes
+ */
+interface BaseRequestOptions {
+    /** Override de la locale */
+    locale?: string;
+    /** Override des options fetch */
+    fetchOptions?: RequestInit;
+}
+/**
+ * Options de pagination
+ */
+interface PaginationOptions {
+    /** Numero de page */
+    page?: number;
+    /** Elements par page */
+    perPage?: number;
+}
+/**
+ * Options de tri
+ */
+interface SortOptions {
+    /** Champ de tri */
+    sort?: string;
+    /** Ordre de tri */
+    order?: 'asc' | 'desc';
+}
+/**
+ * Filtres pour les contenus
+ */
+interface ContentsFilters extends PaginationOptions, SortOptions {
+    /** Filtrer par categorie (slug) */
+    category?: string;
+    /** Filtrer par tag (slug) */
+    tag?: string;
+    /** Recherche textuelle */
+    search?: string;
+    /** Locale */
+    locale?: string;
+}
+/**
+ * Options pour recuperer une categorie
+ */
+interface CategoryOptions extends PaginationOptions {
+    /** Locale */
+    locale?: string;
+}
+/**
+ * Filtres pour les avis
+ */
+interface ReviewsFilters extends PaginationOptions, SortOptions {
+    /** Note minimum */
+    minRating?: number;
+    /** Note maximum */
+    maxRating?: number;
+}
+/**
+ * Options de soumission avec reCAPTCHA
+ */
+interface SubmitOptions {
+    /** Token reCAPTCHA (si active sur le site) */
+    recaptchaToken?: string;
+}
+
+/**
+ * Codes d'erreur
+ */
+type ErrorCode = 'BAD_REQUEST' | 'UNAUTHORIZED' | 'FORBIDDEN' | 'NOT_FOUND' | 'VALIDATION_ERROR' | 'TOO_MANY_REQUESTS' | 'INTERNAL_ERROR' | 'SERVICE_UNAVAILABLE' | 'NETWORK_ERROR';
+/**
+ * Detail d'une erreur
+ */
+interface ApiErrorDetail {
+    /** Message d'erreur */
+    message: string;
+    /** Champ concerne (pour les erreurs de validation) */
+    field?: string;
+    /** Code d'erreur specifique */
+    code?: string;
+}
+
+/**
+ * Erreur specifique au SDK Lynkow
+ */
+declare class LynkowError extends Error {
+    /** Code HTTP */
+    status: number;
+    /** Code d'erreur */
+    code: ErrorCode;
+    /** Liste des erreurs detaillees */
+    errors: ApiErrorDetail[];
+    constructor(status: number, code: ErrorCode, message: string, errors?: ApiErrorDetail[]);
+}
+
+/**
+ * Verifie si une reponse de resolution est un contenu
+ */
+declare function isContentResolve(response: ResolveResponse): response is ContentResolveResponse;
+/**
+ * Verifie si une reponse de resolution est une categorie
+ */
+declare function isCategoryResolve(response: ResolveResponse): response is CategoryResolveResponse;
+/**
+ * Verifie si une erreur est une erreur Lynkow
+ */
+declare function isLynkowError(error: unknown): error is LynkowError;
+
+/**
+ * Cree une instance du client Lynkow
+ *
+ * @param config - Configuration du client
+ * @returns Instance du client avec tous les services
+ *
+ * @example
+ * ```typescript
+ * const lynkow = createLynkowClient({
+ *   siteId: 'your-site-uuid',
+ *   locale: 'fr'
+ * })
+ *
+ * const posts = await lynkow.contents.list()
+ * ```
+ */
+declare function createLynkowClient(config: LynkowConfig): LynkowClient;
+
+export { type Alternate, type ApiErrorDetail, type Author, type BaseRequestOptions, type CategoriesListResponse, type Category, type CategoryDetail, type CategoryDetailResponse, type CategoryOptions, type CategoryResolveResponse, type CategoryTreeNode, type CategoryTreeResponse, type CategoryWithCount, type ConsentLogResponse, type Content, type ContentBlock, type ContentBody, type ContentResolveResponse, type ContentSummary, type ContentsFilters, type ContentsListResponse, type CookieCategory, type CookieConfig, type CookiePreferences, type CookieTexts, type ErrorCode, type Form, type FormField, type FormFieldOption, type FormFieldType, type FormFieldValidation, type FormSettings, type FormSubmitData, type FormSubmitResponse, type GlobalBlock, type GlobalBlockResponse, type LegalDocument, type LegalDocumentSummary, type LegalDocumentType, type LegalListResponse, type LynkowClient, type LynkowConfig, LynkowError, type Page, type PageSeo, type PageSummary, type PagesListResponse, type PaginatedResponse, type PaginationMeta, type PaginationOptions, type Path, type PathsListResponse, type Redirect, type ResolveResponse, type Review, type ReviewResponse, type ReviewSettings, type ReviewSubmitData, type ReviewSubmitResponse, type ReviewsFilters, type ReviewsListResponse, type SiteConfig, type SiteConfigResponse, type SortOptions, type SubmitOptions, type Tag, type TagsListResponse, createLynkowClient, isCategoryResolve, isContentResolve, isLynkowError };