import { AxiosInstance } from 'axios';
import { AxiosResponse } from 'axios';
import { ComponentType } from 'react';
import { CSSProperties } from 'react';
import { default as default_2 } from 'react';
import { DetailedHTMLProps } from 'react';
import { FC } from 'react';
import { ForwardRefExoticComponent } from 'react';
import { InputHTMLAttributes } from 'react';
import { JSX } from 'react/jsx-runtime';
import { JSX as JSX_2 } from 'react';
import { ReactNode } from 'react';
import { RefAttributes } from 'react';
import { SVGProps } from 'react';
import { TextareaHTMLAttributes } from 'react';

export declare function addComment({ publication, path, username, comment, id, recaptchaResponse, baseUrl, apiToken, securityToken, COMMENTS_VARS, }: {
    publication: string;
    path: string;
    username: string;
    comment: string;
    id?: string;
    recaptchaResponse: string;
    baseUrl: string;
    apiToken: string;
    securityToken: string;
    COMMENTS_VARS: any;
}): Promise<AddCommentResponse>;

declare type AddCommentResponse = {
    type: 'success' | 'error';
    message: string;
    status: number;
};

export declare interface Advanced {
    tagarticle: string;
    cintillo: boolean;
    color: string;
    imagearticle: string;
    imagehomeorientation: string;
    imagesectionorientation: string;
    elementhome: string;
    elementarticle: string;
}

export declare type Analytics = {
    ga4: string | undefined;
    marfeel: string | undefined;
    gtm: string | undefined;
    comscore: string | undefined;
};

/**
 * Una pasada sobre el DOM. Exportada aparte de `initRelativeTime` para poder
 * re-correrla a mano después de inyectar HTML (paginados, "más noticias") —
 * pasándole las MISMAS `opts` que se le pasaron a `initRelativeTime`.
 *
 * Tambien gateada por el flag: sin `enabled` no escribe nada. Es la condición
 * de que el HTML de un sitio que no opto in sea el de siempre.
 */
export declare const applyRelativeTime: (opts?: RelativeTimeOptions) => void;

/**
 * Red de seguridad runtime para consumidores JS (sin type-check). El tipo
 * marca la forma en build; esto valida presencia de cada slot y que matchee
 * el formato exacto en runtime — enforcement doble, decisión del owner (§3).
 */
export declare function assertImageSizesContract(x: unknown): asserts x is ImageSizesContract;

export declare const assetsImagesPrefixer: (imagePath: string, assetsClient?: string) => string;

export declare const AssetsPreconnect: () => false | "" | JSX.Element | undefined;

export declare function auditConfigOrigin(entry: ConfigOriginAuditEntry): void;

export declare interface Author {
    firstname: string;
    lastname: string;
    fullname: string;
    image: Preview;
    name: string;
    internaluser: boolean;
}

/**
 * Normalizacion de las redes del autor que llegan en `addtional.USER_PAGE_*`.
 *
 * El CMS deja esos campos como texto libre: el mismo campo puede traer una URL
 * completa (`https://www.tiktok.com/@debate_mx`), un handle con `@`
 * (`@debatenoticias`), un handle pelado (`debate_mx`) o venir vacio. Prefijar
 * `https://` a ciegas produce links rotos (`https://@debatenoticias`), asi que
 * se arma la URL por red y se descarta lo que no resuelve: el componente no
 * renderiza el icono en vez de renderizarlo roto.
 *
 * Alcance: solo las redes que hasta ahora no tenian render en `AutorHeader1/2`
 * ni en `JournalistArticule2`. Facebook / Instagram / X / LinkedIn siguen
 * resolviendose como siempre (`ensureHttpsProtocol`) y no se tocan aca.
 */
export declare type AuthorSocialNetwork = 'tiktok' | 'youtube' | 'pinterest';

export declare const AutorHeader1: FC<Props_45>;

export declare const AutorHeader2: FC<Props_46>;

export declare interface AutorInfo {
    info: {
        id: string;
        name: string;
        nickname: string;
        firstname: string;
        lastname: string;
        fullname: string;
        email: string;
        image: ImageProps;
        country: string;
        birthdate: string;
        gender: string;
        address: string;
        telephone: string;
        cellphone: string;
    };
    addtional: {
        USER_JOBSTART: string;
        USER_JOBTITLE: string;
        USER_VIEW_NEWS: string;
        USER_USERIG: string;
        USER_USERFB: string;
        USER_MIBIO: string;
        USER_MIBIO_EN: string;
        USER_COUNTRY: string;
        USER_PICTURE: string;
        APODO: string;
        USER_SHOWEMAIL: boolean;
        USER_TWOFACTOR_DEADLINE: string;
        USER_MISITIO: string;
        USER_SHOWBIO: boolean;
        USER_MODULEALERTS_20220120: string;
        USER_USERLIN: string;
        USER_USERTWT: string;
        USER_VIEW_PINS: string;
        USER_PAGE_FACEBOOK: string;
        USER_PAGE_TWITTER: string;
        USER_PAGE_INSTAGRAM: string;
        USER_PAGE_LINKEDIN: string;
        USER_PAGE_TIKTOK: string;
        USER_PAGE_YOUTUBE: string;
        USER_PAGE_PINTEREST: string;
        USER_FACEBOOK_FAN_PAGE: string;
        USER_POSITION: string;
        USER_POSITION_EN: string;
        USER_DESCRIPCION: string;
        USER_DESCRIPCION_EN: string;
        USER_MOSTRAR_MAIL: string;
    };
}

export declare const BannerAdvertising: ({ banners, name, legacy, scope }: Props_28) => JSX.Element | null;

export declare const BannerAdvertisingMiddle: ({ banners, index, name, legacy, scope, }: Props_27) => JSX.Element | null;

/**
 * Arma la cadena de candidatos de una posición: primero la key canónica
 * (nomenclatura nueva), después los alias legacy en orden.
 *
 * No deduplica por accidente: si un sitio pasa `legacy` igual al canónico el
 * resultado es el mismo lookup una sola vez.
 */
export declare const bannerKeyCandidates: (canonical: string, legacy?: BannerLegacyKey) => string[];

/**
 * Nombres legacy de una posición de banner. Acepta un string o una lista
 * ordenada (de más a menos prioritario).
 */
export declare type BannerLegacyKey = string | string[] | undefined;

export declare interface BannerResponse {
    key: string;
    value: string;
    show: boolean;
}

export declare interface BannerResponse {
    key: string;
    value: string;
    show: boolean;
}

export declare type BannerScope = {
    type: 'general';
} | {
    type: 'seccion';
    value: string;
} | {
    type: 'tema';
    value: number;
};

/**
 * ¿La ruta actual debe emitir banners para este request? Fuente ÚNICA de la
 * política "banners condicionados a query". Para las rutas listadas en
 * `CONFIG_bannersRequireQuery` (default `['buscar']`) devuelve `true` solo si hay
 * query no vacío; para el resto de rutas devuelve siempre `true`.
 *
 * Consumida por `GenerateHead` (gatea `<BannersPreconnect>` + `headscripts`) y
 * por el `LayoutCore` de cada sitio (para saltar el self-fetch de `getBanners`
 * cuando no corresponde). Al vivir acá, agregar/quitar rutas gateadas o el
 * default es un cambio de un solo lugar que se propaga a todos los repos.
 *
 * `cfg` default = `getConfig()` (singleton de `initLibrary`, ya poblado cuando
 * corre el render de Head/LayoutCore). Se puede pasar explícito para tests.
 */
export declare function bannersEnabledForRequest(route: string, query: string | undefined, cfg?: Pick<LibraryConfig, 'CONFIG_bannersRequireQuery'>): boolean;

export declare const BannersPreconnect: ({ gpt, googleAds, syndication, adsense, }: BannersPreconnectProps) => JSX.Element;

/**
 * BannersPreconnect — resource hints (preconnect / dns-prefetch) para el stack
 * de publicidad de Google Ad Manager (GPT). Migrado desde el preconnect
 * hardcodeado que vivía en los sitios (ej. saas-redmas-astro
 * `components/temporal/BannersPreconnect.astro`).
 *
 * NO incluye el preconnect a `PUBLIC_ASSETS_URL`: eso ya lo emite
 * `AssetsPreconnect` dentro de `GenerateHead`. Este componente es SOLO de
 * banners/ads.
 *
 * Cada dominio se controla con su propio flag de `headConfig`. Base = todo en
 * `false`; cada sitio prende los que usa (un sitio con GAM completo los prende
 * todos). Sin gate de entorno: al igual que el resto de flags de `headConfig`
 * (schemas, preloadImages, amp), lo que se configura es lo que se emite.
 */
declare type BannersPreconnectProps = {
    /** securepubads.g.doubleclick.net — requests de GPT (googletag). */
    gpt?: boolean;
    /** googleads.g.doubleclick.net — serving / clicks de Google Ads. */
    googleAds?: boolean;
    /** tpc.googlesyndication.com — render de creatividades (SafeFrame). */
    syndication?: boolean;
    /** pagead2.googlesyndication.com — AdSense/GPT (hint liviano: dns-prefetch). */
    adsense?: boolean;
};

export declare const bannersReplace: (bannerLineAd: string, replaces?: {
    [key: string]: string;
}) => string;

export declare const becomeVideoObject: (video: VideoResponseData, showtime?: boolean, showsubtitle?: boolean, showauthor?: boolean) => NewListResponseData;

export declare interface BlockSaasResponse {
    key: string;
    block: string;
    size: string;
    value: string;
    title: string;
    link: string;
}

export declare interface BlockSaasResponseData {
    blockSass: Array<BlockSaasResponse>;
    news?: NewListResponse | undefined;
}

/**
 * Ruta del recurso en el bucket: `${clientName}/${site}/${type}/${subtype}/${subtype}.json`,
 * donde `site` = `forceSite` ?? `servicePrefix` ?? `clientName` (ver `forceSite`).
 * `subtype` se deriva en runtime (nombre del archivo de menú sin `.html`, o el
 * `template` de banners en minúscula) — no forma parte de esta config.
 */
export declare type BucketOriginConfig = {
    /** Base URL pública del bucket (sin slash final). Ej: `https://debate-site-configs.s3.us-west-2.amazonaws.com` */
    url: string;
    /**
     * Base URL alternativa (CloudFront u otro proxy cacheado). Si está definida,
     * reemplaza `url` al armar las rutas de menú/banners en bucket.
     */
    proxyUrl?: string;
    /** Prefijo raíz del cliente dentro del bucket (ej. `'debate'`). */
    clientName: string;
    /**
     * Sirve el menú (sidebar/menu/footer/freeZone/cintillo + equipos/sites) desde
     * el bucket. Con el toggle ON, SIN fallback a CMS: si el bucket agota los 4
     * intentos, se sirve vacío + registro en el debugPanel (`reportBucketOriginExhausted`).
     */
    menu?: boolean;
    /**
     * Sirve los banners (home/seccion/nota) desde el bucket. Con el toggle ON, SIN
     * fallback a CMS: si el bucket agota los 4 intentos, se sirve vacío + registro
     * en el debugPanel.
     */
    banners?: boolean;
    /**
     * [transicional] Sirve la config de los slots dinámicos de home
     * (`bloques/modulos-dinamicos/modulos-dinamicos.json`) desde el bucket en
     * lugar del fan-out N contra `/config/blocks-saas`. Toggle de migración: al
     * pasar todos los sitios a `true`, la rama legacy CMS se elimina y el toggle
     * queda no-op (luego se remueve). El JSON keyea plano `Home_N` (sin subíndices);
     * cada entry se resuelve con `resolveSlotContent` (content-fetch al CMS igual
     * que legacy). SIN fallback de CONFIG a CMS: con el toggle ON el bucket es el
     * método único; si agota los 4 intentos, los slots se sirven vacíos y se
     * registra en el debugPanel (`reportBucketOriginExhausted`) para notar la falla.
     * El fan-out CMS solo corre con el toggle OFF (sitios sin migrar).
     * Ver `PLAN_DYNAMIC_SLOTS_BUCKET_ORIGIN.md` §4.3/§7.
     */
    slots?: boolean;
    /**
     * [transicional] Sirve la config del destacado dinámico
     * (`bloques/destacado/destacado.json`) desde el bucket en lugar de
     * `/config/blocks`. Es drop-in de TRANSPORTE (mismo `.data.data` que el CMS).
     * ⚠ CONTRATO (verificado contra un sitio CMS funcional, golfo): el LAYOUT del
     * destacado va en `data[0].block`, que debe ser uno de los 5 nombres de layout
     * (`Diario` | `Diario con imagen` | `Super` | `3 notas verticales` |
     * `3 notas horizontales`) — es la key que consume `DynamicMainSlot` vía el prop
     * `component`. Los campos `value`/`size`/`title`/`link` NO los usa el destacado
     * (en el CMS vuelven como tokens sin rellenar) → se ignoran. (Nota: existe
     * `getMainBlockData`, que lee `value` contra `GetByOptions`, pero es otra ruta
     * que el render vivo de golfo no usa.)
     * El CONTENIDO (las notas) SIEMPRE sale del CMS (zona `destacadas`, sección
     * provista por la app) — permanente, no transicional: este toggle solo mueve el
     * ORIGEN DE LA CONFIG (bucket vs CMS), nunca el contenido. SIN fallback de CONFIG
     * a CMS: con el toggle ON el bucket es el método único; si agota los 4 intentos,
     * el destacado se sirve vacío y se registra en el debugPanel (`reportBucketOriginExhausted`).
     * El CMS solo sirve la config con el toggle OFF (sitios sin migrar).
     * Ver `PLAN_DYNAMIC_SLOTS_BUCKET_ORIGIN.md` §4.4/§7.
     */
    destacado?: boolean;
    /**
     * Referer exigido por la bucket policy (`aws:Referer`). Sin este header el
     * bucket devuelve 403 aunque la ruta/archivo exista. Default: el mismo
     * valor que usa `getRankingS3` (bucket propio de Debate).
     */
    referer?: string;
    /**
     * Segmento de sitio a usar en la ruta del bucket. Es un OVERRIDE explícito:
     * si está definido GANA sobre `PUBLIC_SERVICE_PREFIX`. Orden de resolución:
     * `forceSite` > `servicePrefix` > `clientName`.
     *
     * Sirve para dos casos:
     * 1. Sitios sin `servicePrefix` (ej. soyfutbol): evita que la ruta quede mal
     *    formada (`debate//menu/...`) cayendo a `clientName`.
     * 2. Sitios cuyo `servicePrefix` NO coincide con el segmento del bucket
     *    (ej. vader-en: `PUBLIC_SERVICE_PREFIX=en` porque así lo pide el CMS, pero
     *    en el bucket el sitio es `vaderen`). El prefix no se puede tocar porque lo
     *    consume `getServicePrefix` para armar las URLs del CMS, así que `forceSite`
     *    es la única salida.
     *
     * Ver `resolveBucketOriginUrl`.
     */
    forceSite?: string;
    /**
     * TTL (ms) del cache in-memory SSR para menú/banners (bucket o API). Default 45000.
     * `0` desactiva. Prioridad sobre `CONFIG_configCacheTtlMs`.
     */
    cacheTtlMs?: number;
};

declare type BuildArgs = {
    route: string;
    slug: string;
    page: number;
    /** Tamano del lote. Es el `NEWS_PER_SECTION` con el que se pinto la pagina 1. */
    size: number;
    cfg?: LibraryConfig;
};

export declare function buildConfigMenuApiPath(servicePrefix: string, configVersion: string, fileName: string): string;

/**
 * Arma `{ path, params }` para la pagina `page` de `route`.
 *
 * `publication` es OBLIGATORIO: sin el, el CMS responde 500 (verificado contra
 * `news-list-section`). En el resto de la app viaja gratis porque `createAxiosApi`
 * lo pone como param por default del instance; aca el request se arma a mano.
 *
 * Los listados transversales (tema / autor / ultimas-noticias) lo pisan con la
 * lista de ids de multipublicacion; `seccion` NO, porque sus slugs son propios
 * de cada publicacion.
 *
 * Devuelve `null` si la ruta no es una ruta de listado conocida.
 */
export declare function buildLoadMoreRequest({ route, slug, page, size, cfg, }: BuildArgs): LoadMoreCmsRequest | null;

export declare const buildTagUrl: (tag: Tag, paths: RoutePathConfig) => string;

/**
 * Reconstruye la URL pública desde `info.link.internal`. Es el inverso exacto
 * de `getVideoRealPath`, que es quien la vuelve a resolver en `/video/[…slug]`.
 */
export declare const buildVideoUrlFromInternal: (internal: string, options?: {
    videoPath?: string;
    title?: string;
}) => string;

declare interface ButtonCSS {
    '--button-background-color'?: string;
    '--button-color'?: string;
    '--button-background-color-hover'?: string;
    '--button-border-image-source'?: string;
    '--button-border'?: string;
    '--button-font-size'?: string;
    '--button-letter-spacing'?: string;
    '--button-text-transform'?: string;
    '--button-border-radius'?: string;
}

export declare type captchaActionType = 'comment_login' | 'comment_register' | 'login' | 'register';

export declare function CarrouselCSR(props: CarrouselProps): JSX.Element | undefined;

export declare function CarrouselIRS(props: CarrouselProps): JSX.Element;

declare type CarrouselProps = {
    children: ReactNode[];
    slot_id: string;
    visibleItems?: number;
    cardWidth?: number;
    cardGap?: number;
    fullPageWidth?: boolean;
    pagination?: boolean;
    /** Dots circulares (opt-in). No altera el estilo de barra de `pagination`. */
    paginationCircle?: boolean;
    enableDrag?: boolean;
};

export declare const CarruselCard: FC<CarruselCardProps>;

declare interface CarruselCardProps extends Omit<CarrouselProps, 'slot_id'> {
    title: string;
    titleUrl: string;
    content: Array<NewListResponseData>;
    heightImageOverwrite?: string;
    heightImageOverwriteMobile?: string;
    slot_id: string;
    isHome?: boolean;
    paths: RoutePathConfig;
    speculationPrerenderClass?: string;
}

export declare const CarruselOpinion: FC<SectionCardCarouselProps>;

/** Corre `resolveImageSizes` y reduce el resultado a pass/fail para CI. */
export declare function checkImageSizes(input: ImageSizesContractInput | undefined): ImageSizesCheckReport;

/**
 * Recorre recursivamente un schema (objeto o array) y elimina toda entry
 * que quede sin valor. Si una propiedad de un objeto queda sin valor, la
 * propiedad se elimina del objeto; si un item de un array queda sin valor,
 * se quita del array.
 */
export declare const cleanSchema: <T>(value: T) => T;

export declare function clearConfigOriginAudit(): void;

/** Limpia el cache (útil en tests o tras invalidación manual). */
export declare function clearConfigOriginCache(cacheKey?: string): void;

export declare function clearConfigOriginComparisonCache(): void;

export declare const coloringByStrokeSVGs: string[];

/** Textos del popup anónimo (AnonimusPopUp.tsx) */
export declare type ComentariosAnonimusPopUpTexts = {
    /** Botón para continuar de forma anónima */
    anonimusContinueButton?: string;
    /** Texto del divisor entre opciones (ej. "o") */
    anonimusDividerOr?: string;
    /** alt de la imagen de usuario anónimo */
    anonimusImageAlt?: string;
    /** aria-label del botón de cerrar popup */
    popupCloseAriaLabel?: string;
};

/** Solo fase ChangePassword (código + nueva contraseña). changePasswordMessage puede usar {{email}} */
export declare type ComentariosChangePasswordPhaseTexts = {
    changePasswordMessage?: string;
    verificationCodeLabel?: string;
    newPasswordLabel?: string;
    confirmPasswordLabel?: string;
    showPasswordsLabel?: string;
    changePasswordButton?: string;
};

/** Textos del formulario de comentario/respuesta (CommentInput, CommentUsername, CommentButton) */
export declare type ComentariosCommentFormTexts = {
    /** Label del textarea de comentario */
    commentInputLabel?: string;
    /** Placeholder del textarea de comentario */
    commentInputPlaceholder?: string;
    /** Label del input de nombre anónimo */
    usernameInputLabel?: string;
    /** Placeholder del input de nombre anónimo */
    usernameInputPlaceholder?: string;
    /** Texto del botón de envío del comentario */
    submitCommentButton?: string;
};

/** Textos de la lista/cabecera de comentarios (Comments.tsx) */
export declare type ComentariosCommentsSectionTexts = {
    commentsSectionTitle?: string;
    commentHeaderMessageEmpty?: string;
    commentHeaderMessageWithComments?: string;
    loadMoreButton?: string;
    /** Botón para cargar más respuestas en un hilo (Comment.tsx) */
    moreRepliesButton?: string;
    /** Saludo al usuario autenticado en UserHeader (usa {{name}} como placeholder del nombre) */
    userGreeting?: string;
    /** Botón de cerrar sesión en UserHeader */
    logoutButton?: string;
    /** Prefijo del mensaje anónimo antes del botón de login (Comments.tsx) */
    anonimusPromptPrefix?: string;
    /** Texto del botón para iniciar sesión dentro del mensaje anónimo */
    anonimusPromptLinkText?: string;
    /** Sufijo del mensaje anónimo después del botón de login */
    anonimusPromptSuffix?: string;
    /** Etiqueta "Respondiendo a" en Reply.tsx */
    replyingToLabel?: string;
};

/** Solo fase Feedback (éxito al cambiar contraseña) */
export declare type ComentariosFeedbackPhaseTexts = {
    feedbackSuccessMessage?: string;
};

/** Solo fase Forgot (olvidé contraseña) */
export declare type ComentariosForgotPhaseTexts = {
    forgotMessage?: string;
    sendCodeButton?: string;
};

/** Tipo resuelto con todos los textos con valor por defecto (para el objeto `t` en LoginForm) */
export declare type ComentariosLoginFormResolved = Required<ComentariosTextsCommon> & Required<ComentariosLoginPhaseTexts> & Required<ComentariosForgotPhaseTexts> & Required<ComentariosChangePasswordPhaseTexts> & Required<ComentariosFeedbackPhaseTexts>;

/** Solo fase Login (iniciar sesión) */
export declare type ComentariosLoginPhaseTexts = {
    GoogleButtonText?: string;
    noAccountText?: string;
    alreadyHasAccountText?: string;
    registerButtonText?: string;
    forgotPasswordText?: string;
};

/** Labels para los campos del formulario de registro (comentarios) */
export declare type ComentariosRegisterFormLabels = {
    email?: string;
    given_name?: string;
    family_name?: string;
    password?: string;
    confirmPassword?: string;
};

/** Textos del formulario de registro (crear cuenta, confirmar código, éxito) */
export declare type ComentariosRegisterFormPhaseTexts = {
    showPasswordsLabel?: string;
    termsPrefix?: string;
    termsLinkText?: string;
    termsSuffix?: string;
    createAccountButton?: string;
    confirmAccountButton?: string;
    alreadyConfirmedText?: string;
    successTitle?: string;
    successMessage?: string;
    /** Labels de las reglas de contraseña (orden: minLength, number, lowercase, uppercase, symbol) */
    passwordRuleMinLength?: string;
    passwordRuleNumber?: string;
    passwordRuleLowercase?: string;
    passwordRuleUppercase?: string;
    passwordRuleSymbol?: string;
    /** Mensajes de error del formulario */
    errorCompleteFields?: string;
    errorPasswordMismatch?: string;
    errorPasswordInvalid?: string;
    errorVerificationCodeRequired?: string;
    errorUnexpected?: string;
};

/** Textos del popup Reportar abuso (ReportPop.tsx) */
export declare type ComentariosReportPopTexts = {
    reportAbuseTitle?: string;
    errorAlreadyReported?: string;
    errorReportComment?: string;
    cancelButton?: string;
    reportButton?: string;
    reportSuccessMessage?: string;
    reportCloseButton?: string;
    /** Override de labels por motivo de reporte */
    reportReasons?: Partial<Record<ComentariosReportReasonKey, string>>;
};

/** Claves de motivos de reporte (debe coincidir con reportComment.ReportReasonKey) */
export declare type ComentariosReportReasonKey = 'spam' | 'inappropriate' | 'hate' | 'misinformation' | 'terrorism' | 'intellectual' | 'bullying';

/** Textos de la sección comentarios: común + por fase + register (usado en LoginForm y RegisterForm) */
export declare type ComentariosTexts = ComentariosTextsCommon & ComentariosLoginPhaseTexts & ComentariosForgotPhaseTexts & ComentariosChangePasswordPhaseTexts & ComentariosFeedbackPhaseTexts & ComentariosRegisterFormPhaseTexts & ComentariosCommentsSectionTexts & ComentariosCommentFormTexts & ComentariosAnonimusPopUpTexts & ComentariosReportPopTexts & {
    /** Labels para campos del formulario de registro; usados en FIELDS_CONFIG */
    registerForm?: ComentariosRegisterFormLabels;
};

/** Textos compartidos entre fases del login/recuperar contraseña */
export declare type ComentariosTextsCommon = {
    title?: string;
    button?: string;
    /** Mensaje cuando el usuario no está autenticado (ej. "Súmate a la comunidad para dejar tu comentario") */
    commentPromptMessage?: string;
    email?: string;
    password?: string;
    showPassword?: string;
    loginButtonText?: string;
    backButton?: string;
};

export declare interface CommentDate {
    date?: number;
    day?: number;
    hours?: number;
    minutes?: number;
    month?: number;
    seconds?: number;
    time: number;
    timezoneOffset?: number;
    year?: number;
}

export declare const CommentLazyLoader: ({ internalPath, icon, API_ENV, texts, }: CommentLazyLoaderProps) => JSX.Element;

declare type CommentLazyLoaderProps = {
    internalPath: string;
    icon?: string;
    isVisibleDefault?: boolean;
    API_ENV: LibraryConfig;
    texts?: textsType;
};

export declare interface CommentsResponse {
    comments: CommentType[];
    morecomment?: boolean;
}

export declare interface CommentType extends ReplyType {
    morereply?: boolean;
    reply?: ReplyType[] | false;
}

export declare class CommonServices {
    protected props?: ICommonServices | undefined;
    configVersion: string;
    exclude: string;
    /**
     * Contrato de tamaños resuelto UNA vez en el punto de entrada (§3). El resto
     * de los métodos consume `this.contract.<slot>` — cero literales sueltos.
     */
    readonly contract: ImageSizesContract;
    constructor(props?: ICommonServices | undefined);
    generateTokenOffline: (browserId: string) => Promise<any>;
    getEntitySection: (params: Params) => Promise<AxiosResponse<{
        data: Array<NewListResponse>;
    }, any, {}>> | undefined;
    getMainMenu: (params: Params) => Promise<{
        data: {
            data: Array<MenuResponse>;
        };
    }>;
    getNewsListZone: (params: Params) => Promise<AxiosResponse<NewListResponse, any, {}>>;
    getNewsListZoneSection: (params: Params) => Promise<AxiosResponse<NewListResponse, any, {}>>;
    getNewsList: (params: Params) => Promise<AxiosResponse<NewListResponse, any, {}>>;
    getNewsListTag: (params: Params) => Promise<AxiosResponse<NewListResponse, any, {}>>;
    getNewsListSection: (params: Params) => Promise<AxiosResponse<NewListResponse, any, {}>>;
    getNewsListAvanced: (params: Params) => Promise<AxiosResponse<NewListResponse, any, {}>>;
    getNewsListTags: (params: Params) => Promise<AxiosResponse<NewListResponse, any, {}>>;
    getNewsListTagEntity: (params: Params) => Promise<AxiosResponse<NewListResponse, any, {}>>;
    getNewsListTagLite: (params: Params) => Promise<AxiosResponse<NewListResponse, any, {}>>;
    getNewsListAutor: (params: Params) => Promise<AxiosResponse<NewListResponse, any, {}>>;
    getNewsSearch: (params: Params) => Promise<AxiosResponse<NewListResponse, any, {}>> | undefined;
    getAutorInfo: (params: Params) => Promise<AxiosResponse<{
        data: Array<AutorInfo>;
    }, any, {}>> | undefined;
    getvideoListAdvanced: (params: Params) => Promise<AxiosResponse<{
        data: Array<VideoResponseData>;
    }, any, {}>> | undefined;
    getVideos: (params: Params) => Promise<AxiosResponse<{
        data: Array<VideoResponseData>;
    }, any, {}>> | undefined;
    getVideosList: (params: Params) => Promise<AxiosResponse<{
        data: Array<VideoResponseData>;
    }, any, {}>> | undefined;
    getBanners: (params: Params) => Promise<{
        data: {
            data: Array<BannerResponse>;
        };
    }>;
    getPages: (params: Params) => Promise<AxiosResponse<{
        data: Array<FreeZoneResponse>;
    }, any, {}>> | undefined;
    getRankingS3: (url: string, headers?: {
        Referer: string;
    }) => Promise<AxiosResponse<{
        data: Array<NewListResponseData>;
    }, any, {}> | {
        data: Array<NewListResponseData>;
    }>;
    getNews: (params: Params) => Promise<AxiosResponse<{
        data: Array<NewListResponseData>;
    }, any, {}>> | undefined;
    getNewsMultimedia: (params: Params) => Promise<AxiosResponse<{
        data: {
            gallery: Array<Preview>;
            videos: Array<VideoItem>;
        }[];
    }, any, {}>> | undefined;
    getNewsItemsList: (params: Params) => Promise<AxiosResponse<{
        data: Array<ItemList>;
    }, any, {}>> | undefined;
    getNewsListPath: (params?: Params) => Promise<AxiosResponse<{
        data: Array<NewListResponseData>;
    }, any, {}>> | undefined;
    getNewsSchemasImages: (params?: Params) => Promise<AxiosResponse<{
        data: Array<NewListResponseData>;
    }, any, {}>> | undefined;
    getNewsItemsRelated: (path: string, params?: Params) => Promise<AxiosResponse<NewListResponse, any, {}> | {
        data: NewListResponse;
    }> | undefined;
    sendEmail: (data: EmailParams) => Promise<AxiosResponse<{
        data: Array<ItemList>;
    }, any, {}>> | undefined;
    searchData: (params: Params) => Promise<{
        search: AxiosResponse<NewListResponse, any, {}>;
        lastNews?: undefined;
    } | {
        lastNews: AxiosResponse<NewListResponse, any, {}>;
        search?: undefined;
    }>;
    commonNewsServices: (path: string, imgSizes?: {
        getNews?: string;
        getNewsItemsList?: string;
        getAutorInfo?: string;
        getNewsItemsRelated?: string;
    }, exclude?: {
        getNewsItemsRelated?: string;
        getAutorInfo?: string;
    }) => Promise<{
        news: any[];
        autor: any[];
        newsRelatedResponses: any[];
        itemList: any;
        newsRelatedListResponses: (NewListResponseData[] | undefined)[];
        schemasImages: any[];
    }>;
}

export declare const compileStyleProps: (data: {
    [key: string]: any;
}) => {
    [key: string]: any;
};

export declare const Comscore: () => "" | JSX.Element | undefined;

export declare type Config = {
    paginationLimit: number;
    newsListLimit: number;
    description: string;
    email: string;
    ampOption: boolean;
    useS3Font: boolean;
    fontName: string;
    fontWeight: string;
    fontDisplay: 'swap' | 'block' | 'fallback' | 'optional';
    fontFormat?: 'woff2' | 'woff' | 'ttf' | 'eot' | 'otf';
    useSpeculationRules: boolean;
    googleFontFamily: string;
    sideCopyright: string;
    footerCopyright: string;
    tapeTitle: string;
    fontS3Url: string;
    /**
     * Opt-in: URL de un .css inmutable que contiene SOLO el @font-face con el woff2
     * embebido en base64. Si esta seteado, Font.tsx lo carga con un <link rel=stylesheet>
     * render-blocking y NO emite ni el preload de font ni el @font-face inline.
     * Ausente = comportamiento historico. Ver PLAN_blocking-font-css.md en saas-soyfutbol-astro.
     */
    fontCssUrl?: string;
    /**
     * Opt-in, requiere fontCssUrl. Techo en ms del GATE DE PAINT: Font.tsx emite un
     * <style> que oculta el documento y un script que lo saca cuando document.fonts
     * resuelve la cara (o cuando vence este techo, lo que pase primero).
     *
     * Es lo UNICO que garantiza que el primer frame con contenido ya tenga la cara de
     * marca: cargar un @font-face es lazy y asincrono, asi que sin gate el paint se
     * libera antes y se ve un frame con el fallback o, con font-display: block, con
     * texto invisible. No hay equivalente declarativo:  se quito de
     * la spec para <link rel=preload>.
     *
     * Se paga con FCP: el contenido no pinta hasta que la cara esta lista. Con el woff2
     * embebido en el CSS bloqueante ese tiempo es la instanciacion de la cara, no una
     * descarga. Ausente = sin gate.
     */
    fontGatePaintMs?: number;
    siteUrl: string;
    newsType: string;
    servicePrefix: string;
    name: string;
    headerLogo: Logo;
    squareLogo: Logo;
    socialBlockLogo: Logo;
    lang: string;
    landscapeLogo: Logo;
    twitterSummaryCard: Logo;
    language?: string;
    icons?: any;
    manifest?: string;
    msapplicationTileImage?: string;
    paths: RoutePathConfig;
    zonehome?: any;
    showauthor?: boolean;
    showtime?: boolean;
    showsubtitle?: boolean;
    priorityhome?: string;
    zonesection?: string;
    prioritysection?: string;
    homepreview?: string;
    showcomments?: boolean;
    showuppertitle?: boolean;
    showads?: boolean;
    articlepreview?: string;
    configVersion?: string;
    cookieName?: string;
    clipUrl?: string;
    schemasNewsParams?: {
        includebody?: boolean;
        includedatecreated?: boolean;
    };
    address?: {
        streetAddress: string;
        addressLocality: string;
        addressRegion: string;
        postalCode: string;
        addressCountry: string;
    };
    orgSoftware?: Array<SoftwareApplicationData>;
};

declare type Config_2 = {
    issuuApi?: string;
    state?: string;
    size?: number;
    q: string;
    token: string;
};

export declare type ConfigDynamic = {
    'Modulo 1x3': Modulo1XN;
    'Modulo 1x3 Client'?: Modulo1XN;
    'Modulo 1x3 card': any;
    'Modulo 1x4': Modulo1XN;
    'Modulo 1x5': Modulo1XN;
    'Destacado noticias': IDestacadoNoticias;
    'Destacado videos': DestacadoVideos_2;
    'Carrusel opinion': any;
    'Carrusel card': any;
    'Carrusel story': any;
    'Carrusel owl': any;
    'Carrusel Videos'?: any;
    'Carrusel video'?: any;
    'Carusel videos'?: any;
    'Modulo fotogaleria': any;
    'Destacado full width'?: any;
};

export declare type ConfigMain = {
    Diario: DestacadoDiario;
    'Diario con imagen': DestacadoDiario;
    'En vivo': DestacadoDiarioLive;
    Super: SectionCardCSS & Super;
    '3 notas verticales': {
        customLargeSection?: SectionCardCSS & Super;
        customSlimSection?: SectionCardCSS & Super;
    };
    '3 notas horizontales': {
        customLargeSection?: SectionCardCSS & Super;
        customSmallSection?: SectionCardCSS & Super;
    };
};

export declare type ConfigOriginAuditEntry = {
    kind: 'menu' | 'banners';
    origin: 'api' | 'bucket';
    outcome: ConfigOriginOutcome;
    target: string;
    durationMs: number;
    ok?: boolean;
};

export declare type ConfigOriginAuditReport = {
    entries: ConfigOriginAuditEntry[];
    totals: {
        network: number;
        cacheHit: number;
        dedup: number;
        stale: number;
        api: number;
        bucket: number;
        networkMs: number;
    };
    comparison?: ConfigOriginComparisonReport | null;
};

export declare type ConfigOriginComparisonReport = {
    runs: number;
    rows: ConfigOriginComparisonRow[];
    homeParallel: {
        api: number;
        bucket: number;
    };
    generatedAt: string;
    cached: boolean;
};

export declare type ConfigOriginComparisonRow = {
    name: string;
    api: ConfigOriginTimingStats;
    bucket: ConfigOriginTimingStats;
    winner: 'api' | 'bucket';
    advantagePct: number;
    deltaMs: number;
};

export declare type ConfigOriginOutcome = 'network' | 'cache-hit' | 'dedup' | 'stale';

export declare type ConfigOriginTimingStats = {
    ok: boolean;
    status: number;
    size: number;
    avg: number;
    p50: number;
    min: number;
    max: number;
};

export declare const ContactInfoServer: FC<Props_9>;

export declare const ContactInput: FC<Props_40>;

export declare const ContactSelect: FC<Props_41>;

export declare const ContactTextarea: FC<Props_42>;

export declare const ContentLayout1: FC<Props_24>;

export declare const ContentLayoutTema: FC<Props_38>;

/**
 * Aviso RUIDOSO de violación de contrato: un campo REQUERIDO por el render llegó
 * ausente. El componente degrada para no romper el stream SSR (evita el "200 OK +
 * HTML de Internal Server Error"), pero deja rastro para detectar el agujero.
 *
 * NO debería dispararse nunca si el consumidor valida el contrato en su frontmatter
 * (ver ENTREGABLE-1). Si aparece en los logs, el contrato tiene un hueco.
 */
export declare const contractWarn: (component: string, field: string, extra?: unknown) => void;

export declare const createAssessment: ({ projectID, recaptchaKey, token, recaptchaAction, apiKey, userAgent, userIpAddress, config, }: CreateAssessmentParams) => Promise<number | null>;

declare interface CreateAssessmentParams {
    projectID: string;
    recaptchaKey: string;
    token: string;
    recaptchaAction: string;
    apiKey: string;
    userAgent?: string;
    userIpAddress?: string;
    config?: Pick<LibraryConfig, 'CONFIG_blockRecaptcha'>;
}

export declare const cutString: (text: string, length?: number) => string;

export declare interface DataNews {
    info: Info;
    config: Config;
    main: Main;
    body: Subtitle;
    preview: Preview;
    gallery: boolean;
    related: Related;
    relatedexternal: Relatedexternal;
    list: boolean;
    videos: boolean;
    audios: boolean;
    social: Social;
    external: External_2;
    hascontent: Hascontent;
    customfields: boolean;
    pixel: string;
    authors: Author[];
}

declare interface Date_2 {
    date: string;
    created: number;
    modified: number;
    firstpublish: number;
    lastpublish: number;
}
export { Date_2 as Date }

export declare const DEBUG_MainSlots: ({ StylesConfigMain, config, banners, axiosApi, commonServices, textPosition, imageSizes, section, zone, exclude, customMainImagesSize, live, texts, }: Props_22) => Promise<JSX.Element | null>;

declare type DebugCfg = {
    buttonPosition?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
    initialErrors?: DebugFetchError[];
    initialSuccesses?: DebugFetchSuccess[];
};

export declare interface DebugFetchError {
    id: string;
    timestamp: string;
    service?: string;
    endpoint: string;
    method: string;
    params?: Record<string, any>;
    message: string;
    status?: number;
    layer: 'axios-service' | 'fetch-api' | 'captcha' | 'auth';
}

export declare interface DebugFetchSuccess {
    id: string;
    timestamp: string;
    service?: string;
    endpoint: string;
    method: string;
    params?: Record<string, any>;
    status: number;
    responsePreview?: string;
    layer: 'axios-service' | 'fetch-api' | 'captcha' | 'auth';
    durationMs?: number;
}

export declare function DebugPanel({ debugCfg }: {
    debugCfg?: DebugCfg;
}): JSX.Element | null;

export declare const DebugStore: {
    add(err: Omit<DebugFetchError, "id" | "timestamp">): void;
    getAll(): DebugFetchError[];
    getCount(): number;
    clear(): void;
    addSuccess(entry: Omit<DebugFetchSuccess, "id" | "timestamp">): void;
    getAllSuccesses(): DebugFetchSuccess[];
    getSuccessCount(): number;
    clearSuccesses(): void;
    clearAll(): void;
};

export declare function decodeApiEnv<T = any>(encoded: Record<string, any>): T;

/**
 * Defaults del `headConfig`. `GenerateHead` mergea el `headConfig` recibido
 * sobre estos (`{ ...DEFAULT_HEAD_CONFIG, ...headConfig }`), así el consumidor
 * puede pasar solo los campos que quiere overridear (partial) y la librería
 * rellena el resto. Base: schemas Autor + WebsiteList on, resto off, banner
 * preconnects off.
 */
export declare const DEFAULT_HEAD_CONFIG: headConfig;

/**
 * Ventana por defecto del relativo, en horas. **48 h**: hasta ahí el texto es
 * "hace N horas"; pasada la ventana, fecha absoluta.
 *
 * Es el default de `isWithinRelativeWindow`, de `formatRelativeDate` y del
 * hidratador, para que los tres no puedan discrepar. Se sobreescribe por sitio
 * con `CONFIG_relativeTime.maxAgeHours`.
 */
export declare const DEFAULT_RELATIVE_MAX_AGE_HOURS = 48;

/**
 * Separador entre el absoluto y el relativo para los absolutos que NO traen
 * hora: `' · '`, U+00B7 con espacios a los lados. Es el caso de las tarjetas y
 * de los comentarios, que emiten solo fecha (`formatDate`) — el resultado es
 * `26 agosto 2026 · hace 2 horas`.
 *
 * Cuando el absoluto SÍ trae hora (el encabezado de la nota:
 * `26 de agosto 2026 • 09:23 hs`) este separador no se usa: el relativo ocupa
 * el lugar de la hora y se conserva el `'•'` que ya emitió el SSR. Ver
 * {@link absolutePrefixWithoutTime}. Se sobreescribe con
 * `CONFIG_relativeTime.separator`.
 */
export declare const DEFAULT_RELATIVE_SEPARATOR = " \u00B7 ";

export declare const DEFAULT_S3_REFERER = "https://goamg.amplifyapp.com/vndomv";

declare type DestacadoDiario = {
    customSectionCardStyles: SectionCardCSS;
    customNewsDescriptionStyles: NewsDescriptionBlockCSS;
};

declare type DestacadoDiarioLive = {
    customSectionCardStyles: SectionCardCSS;
    customNewsDescriptionStyles: NewsDescriptionBlockCSS;
    customLiveStyles?: SectionCardCSS & {
        borderBottom?: string;
        padding?: string;
        '--image-play-margin'?: string;
        '--news-description-padding'?: string;
        '--news-description-border-bottom'?: string;
    };
    customLiveBadgeStyles?: {
        '--ddl-live-badge-box-align-items'?: string;
        '--ddl-live-badge-box-gap'?: string;
        '--ddl-live-badge-box-padding'?: string;
        '--ddl-live-badge-gap'?: string;
        '--ddl-live-badge-background'?: string;
        '--ddl-live-badge-border'?: string;
        '--ddl-live-badge-border-radius'?: string;
        '--ddl-live-badge-padding'?: string;
        '--ddl-live-badge-font-family'?: string;
        '--ddl-live-badge-font-weight'?: string;
        '--ddl-live-badge-font-size'?: string;
        '--ddl-live-badge-color'?: string;
        '--ddl-live-badge-dot-size'?: string;
        '--ddl-live-badge-dot-color'?: string;
        '--ddl-live-badge-pulse-color'?: string;
        '--ddl-live-badge-title-font-family'?: string;
        '--ddl-live-badge-title-font-weight'?: string;
        '--ddl-live-badge-title-font-size-mobile'?: string;
        '--ddl-live-badge-title-line-height-mobile'?: string;
        '--ddl-live-badge-title-font-size-desk'?: string;
        '--ddl-live-badge-title-line-height-desk'?: string;
        '--ddl-live-badge-title-color'?: string;
    };
};

export declare interface DestacadoDiarioLiveProps extends SectionCardProps, NewDescriptionBlockProps {
    banner?: ReactNode;
    banners?: BannerResponse[];
    rightOnlyBanner?: boolean;
    rightHasBanner?: boolean;
    customSectionCardStyles?: CSSProperties;
    customNewsDescriptionStyles?: CSSProperties;
    customLiveStyles?: CSSProperties;
    customLiveBadgeStyles?: CSSProperties;
    paths: RoutePathConfig;
    block: NewListResponseData[];
    commonServices?: CommonServices;
    speculationPrerenderClass?: string;
    /** HTML del iframe del bloque destacado ("En vivo"). */
    live?: {
        iframe?: string;
        title?: string;
    };
    showSuper?: boolean;
    textPosition?: 'center' | 'start';
    heightImageOverwrite?: string;
    heightImageOverwriteMobile?: string;
    texts?: textsType;
}

export declare const DestacadoNoticias: FC<DestacadoNoticiasProps>;

declare interface DestacadoNoticiasProps extends Omit<ImageProps_2, 'preview'>, SectionProps {
    titleUrl?: string;
    content: Array<NewListResponseData>;
    goTo?: {
        url: string;
        description: string;
    };
    slot_id?: string;
    isHome?: boolean;
    banner?: ReactNode;
    customVariables?: CSSProperties;
    paths: RoutePathConfig;
    speculationPrerenderClass?: string;
}

export declare const DestacadoVideos: FC<DestacadoVideosProps>;

declare type DestacadoVideos_2 = {
    title: string;
    isVideo: boolean;
    goTo: {
        description: string;
        url: string;
    };
    titleUrl: string;
    '--video-section-news-content-gap-mobile'?: string;
    '--block-head-title-font-size'?: string;
    '--block-head-title-line-height'?: string;
    '--block-head-title-font-size-mobile'?: string;
    '--block-head-title-line-height-mobile'?: string;
    '--image-is-large-play-margin'?: string;
    '--block-head-subtitle-line-clamp'?: string;
    '--block-head-title-line-clamp'?: string;
    '--block-head-subtitle-display'?: string;
    '--block-head-title-hover-color'?: string;
} & SectionCardCSS & SectionCSS & OutstandingNewsCSS & ButtonCSS & ImageCSS;

declare interface DestacadoVideosProps extends Omit<ImageProps_2, 'preview'>, Omit<SectionProps, 'children'> {
    titleUrl?: string;
    content: Array<VideoResponseData>;
    goTo?: {
        url: string;
        description: string;
    };
    slot_id?: string;
    isHome?: boolean;
    banner?: ReactNode;
    paths: RoutePathConfig;
    speculationPrerenderClass?: string;
}

export declare class DynamicBlockServices extends CommonServices {
    MULTIPUBLICATION_FETCHES: any | undefined;
    PUBLIC_PUBLICATION_ID: string | undefined;
    IS_MULTIPUBLICATION: boolean;
    constructor(props?: ConstructorParameters<typeof CommonServices>[0]);
    getBlockSass: (params: Params) => Promise<{
        blockSass: BlockSaasResponse[];
        content: {
            data: Array<VideoResponseData>;
        } | undefined;
    } | {
        blockSass: BlockSaasResponse[];
        content: NewListResponse | undefined;
    } | {
        blockSass: BlockSaasResponse[] | undefined;
    }>;
    /**
     * Dada la config de UN slot (`BlockSaasResponse[]`, se usa `[0]`), dispara el
     * content-fetch que corresponda (`videos`/`tag`/`seccion`) y devuelve
     * `{ blockSass, content? }`. Extraído de `getBlockSass` para reusarse tanto
     * desde la rama legacy (CMS `/config/blocks-saas`) como desde la rama de
     * bucket (`modulos-dinamicos.json`, ver `getDynamicSlotsFromBucket`): el
     * origen del array cambia, el resto de la resolución de contenido no.
     */
    resolveSlotContent: (blockSassData: Array<BlockSaasResponse> | undefined) => Promise<{
        blockSass: BlockSaasResponse[];
        content: {
            data: Array<VideoResponseData>;
        } | undefined;
    } | {
        blockSass: BlockSaasResponse[];
        content: NewListResponse | undefined;
    } | {
        blockSass: BlockSaasResponse[] | undefined;
    }>;
}

export declare const DynamicComponents: ({ slots, DYNAMIC_SLOT_SUBINDEXES, stylesConfig, AutorIcon, config, banners, showTagBySection, pathname, }: Props_21) => ReactNode[];

export declare const DynamicMainSlot: ({ component, data, banners, rightOnlyBanner, isHome, commonServices, texts, }: Props_20) => JSX.Element;

export declare function DynamicSlot({ component, slot_id, data, banners, isHome, }: Props_18): JSX.Element | undefined;

export declare const EditorialBlock: FC<Props_7>;

export declare type EmailParams = {
    sendto: string;
    from: string;
    host: string;
    subject: string;
    body: string;
};

export declare const EMPTY_PREVIEW: Preview;

/**
 * Fallback completo (no solo `{data: []}`) para endpoints tipados `NewListResponse`:
 * algunos consumidores leen `response.data.entity`/`site`/`publication`, no solo `.data.data`.
 */
export declare function emptyNewListResponse(): NewListResponse;

export declare function encodeApiEnv<T extends Record<string, any>>(env: T): Record<string, any>;

/** El CMS manda `preview: false` cuando la nota no tiene imagen. `??` no lo cubre. */
export declare function ensurePreview(value: unknown): Preview;

export declare interface Entity {
    color: string;
    description: string;
    idPage: number;
    idTipoEdicion: number;
    idZone: number;
    name: string;
    new: boolean;
    order: number;
    orderDefault: string;
    sizeDefault: number;
    visibility: boolean;
    url?: string;
    image: {
        url: string;
        width: number;
        height: number;
    };
    social?: {
        facebook: string;
        twitter: string;
        linkedin: string;
        google: boolean;
        instagram: string;
    };
}

export declare const ErrorComponent: FC<Props_39>;

declare type EventReplaces = {
    '[author_replace]': string;
    '[section_replace]': string;
    '[tag_replace]': string;
    '[url_replace]': string;
};

declare interface External_2 {
    httpstream: boolean;
    iframe: boolean;
}

export declare const extractMainSlug: (pathname: string) => string;

/** @deprecated Nombre con typo; usar `extractRelatedNews`. */
export declare const extractRealtedNews: typeof extractRelatedNews;

/**
 * Devuelve, por cada bloque `.ck-related-news`, todos los `data-src` de los `<span>` internos
 * (un bloque puede tener varios spans).
 */
export declare function extractRelatedNews(article: NewListResponseData): Array<Array<string>>;

/** ID de tag en slugs como `lionel-messi-t640863` o `t640863`. */
export declare const extractTagIdFromSlug: (slug: string) => string;

export declare type FetchConfig = {
    imgSizes: string;
    newsType: string;
};

declare type FetchMoreArgs = {
    endpoint: string;
    route: string;
    slug: string;
    page: number;
    size: number;
    /** Rama CDN: URL ya armada (con params) + headers. Ausente = endpoint propio. */
    direct?: {
        url: string;
        headers: Record<string, string>;
    };
};

export declare function fetchMoreNews({ endpoint, route, slug, page, size, direct, }: FetchMoreArgs): Promise<MoreNewsPage>;

/**
 * Cache in-memory + deduplicación de requests en vuelo (misma clave → misma promesa).
 * TTL corto pensado para SSR: evita 4–5 GETs repetidos de menú/banners por instancia.
 *
 * Con `staleOnError: true`, un fallo de red/timeout no cachea vacío: sirve el último
 * valor OK de esa clave (si existe) y deja que el caller decida el fallback final.
 */
export declare function fetchWithConfigCache<T>(cacheKey: string, fetchFn: () => Promise<T>, options?: number | {
    ttlMs?: number;
    shouldCache?: (value: T) => boolean;
    staleOnError?: boolean;
}): Promise<T>;

/**
 * Resuelve una posición de banner contra la respuesta del CMS con fallback a
 * nomenclatura vieja.
 *
 * REGLA DE CAÍDA — **solo por ausencia**. Se devuelve la primera key que
 * EXISTE en el array, sin mirar `show` ni `value`. Si la key canónica está
 * presente pero apagada (`show: false`) NO se cae al legacy: apagar un banner
 * es una decisión deliberada de tráfico y el fallback no debe revivirlo.
 *
 * Los guards de `show`/`value` los sigue aplicando cada componente sobre el
 * `BannerResponse` devuelto, exactamente como antes de este helper. Por eso,
 * sin `legacy`, el comportamiento es byte-idéntico al `banners.find(...)`
 * original: misma búsqueda, mismo resultado.
 */
export declare const findBanner: (banners: Array<BannerResponse> | undefined, canonical: string, legacy?: BannerLegacyKey) => BannerResponse | undefined;

export declare const Font: ({ config }: {
    config: Config;
}) => JSX.Element | null;

export declare const Footer: FC<Props_33>;

export declare const FormatAfterScripts: (props: ScriptProps) => JSX.Element | null;

export declare function formatConfigOriginComparisonTable(report: ConfigOriginComparisonReport): string;

export declare const formatDate: (date: number, DATE_CONFIG?: {
    PUBLIC_LNG: string;
    DATE_TIMEZONE: string;
}) => string;

export declare const formatDateEdiciones: (date: string) => string;

export declare const formatDateJournalistArticule: (date: number) => string;

export declare const formatDateTimeline: (date: number) => string;

export declare const formatNewsMeta: (meta: any, news: NewListResponseData | undefined, config: Config, schemasImages?: {
    preview: {
        format: string;
        width: string;
        height: string;
        url: string;
    }[];
    description: string;
}) => {
    title?: undefined;
    robots?: undefined;
    alternates?: undefined;
    description?: undefined;
    news_keywords?: undefined;
    keywords?: undefined;
    openGraph?: undefined;
    twitter?: undefined;
    article?: undefined;
} | {
    title: string;
    robots: string;
    alternates: {
        types: {
            'application/rss+xml': string;
        };
        canonical: string | undefined;
    };
    description: string;
    news_keywords: string;
    keywords: string;
    openGraph: {
        title: string;
        url: string | undefined;
        type: string;
        description: string;
        images: {
            url: string;
            width: string | number;
            height: string | number;
            alt: string;
        }[];
        siteName: string;
        locale: string;
    };
    twitter: {
        title: string;
        card: string;
        site: any;
        description: string;
        images: {
            url: string;
            width: string | number;
            height: string | number;
            alt: string;
        }[];
    };
    article: {
        published_time: string;
        modified_time: string;
        section: string | undefined;
        author: string;
        tag: Tag[];
    };
};

/**
 * Relativo ("hace 3 horas") si la nota es más nueva que `maxAgeHours`;
 * si no, cae a `formatDate` (absoluto).
 *
 * Escala: `hace instantes` (< 1 min) · `hace N minutos` · `hace N horas` ·
 * `hace N días`. Pasada la ventana (`maxAgeHours`, default 48) vuelve al
 * absoluto — el hidratador restaura el texto que emitió el SSR, que puede no
 * ser el de `formatDate` (la nota usa `formatDateJournalistArticule`).
 *
 * `now` entra POR PARÁMETRO, no se lee adentro: así la función es determinista
 * dado `(date, now)` y el SSR nunca la llama con `Date.now()` por accidente
 * (un relativo renderizado en servidor queda congelado en el cache del CDN y
 * a los 40 minutos sigue diciendo "hace 5 minutos" — información incorrecta,
 * no desactualizada).
 */
export declare const formatRelativeDate: (date: number, now: number, maxAgeHours?: number, DATE_CONFIG?: {
    PUBLIC_LNG: string;
    DATE_TIMEZONE: string;
}) => string;

export declare const FormatScripts: (props: ScriptProps) => JSX.Element | null;

export declare const formatVideoData: (meta: any, news: VideoResponseData, config: Config) => {
    title?: undefined;
    robots?: undefined;
    alternates?: undefined;
    description?: undefined;
    news_keywords?: undefined;
    keywords?: undefined;
    openGraph?: undefined;
    twitter?: undefined;
} | {
    title: string;
    robots: string;
    alternates: {
        canonical: string;
    };
    description: string;
    news_keywords: string;
    keywords: string;
    openGraph: {
        title: string;
        url: string;
        type: string;
        description: string;
        images: {
            url: string;
            width: number;
            height: number;
        }[];
        siteName: string;
        locale: string;
    };
    twitter: {
        title: string;
        card: string;
        site: any;
        description: string;
        images: {
            url: string;
            width: number;
            height: number;
        }[];
    };
};

export declare interface FreeZoneResponse {
    info: {
        title: string;
        description: string;
        keywords: string;
    };
    body: {
        rendered: string;
        striped: string;
    };
}

export declare const GA4: ({ id, dimensionValues, event_analytics, eventReplaces }: Props_2) => "" | JSX.Element | undefined;

export declare const GalleryHeader: ({ newsformated, internal, commonServices, }: {
    newsformated: NewListResponseData;
    internal?: string;
    commonServices: CommonServices;
}) => Promise<JSX.Element | undefined>;

export declare const generalGetData: (promiseArray: PromiseArray) => Promise<{
    [key: string]: any;
}>;

export declare const GenerateBody: ({ children, defaultRouteName, banners, pathname, slug, config, internalPath, currentNew, tagsParsed, scriptReplaces, body_custom_elements, }: Props_5) => JSX.Element;

export declare function GenerateHead({ axiosApi, headConfig: headConfigInput, meta, imgSizes, defaultMetadataName, pathname, slug, texts, query, autor, listAutor, currentNew, banners, schemasImages, internalPath, metaSource, config, socials, speculationType, preloadImageUrl, custom_Speculation, custom_metadata, custom_scriptReplaces, head_custom_elements, schemasCustomEndpoints, configOriginAuditReport, }: Props_4): Promise<ReactNode>;

/** Cliente axios compartido por origen de bucket (keep-alive en Node SSR). */
export declare function getBucketHttpClient(baseUrl: string, referer: string): AxiosInstance;

/**
 * Busca en un dict keyed por nombre de bloque (SlotComponents, stylesConfig,
 * imgSizes). Match exacto primero; si no, compara nombres normalizados para que
 * 'Carrusel Videos', 'Carrusel video' y 'Carusel videos' resuelvan igual.
 */
export declare const getByBlockName: <T>(dict: {
    [key: string]: T;
} | undefined | null, name: string | undefined | null) => T | undefined;

/**
 * Helper para conseguir el recaptcha token usando grecaptcha.enterprise
 * Make sure to load the grecaptcha script in your HTML:
 * <script src="https://www.google.com/recaptcha/enterprise.js?render=your_site_key"></script>
 * @param captchaAction Nombre de la acción para el captcha
 * @param siteKey La clave del sitio para el captcha
 * @param config Config del sitio (prop `API_ENV`) para leer el kill switch
 *   `CONFIG_blockRecaptcha`. Si se omite se cae al singleton de `initLibrary`.
 * @returns Una promesa que se resuelve con el token del captcha
 */
export declare const getCaptchaToken: (captchaAction: captchaActionType, siteKey: string, config?: Pick<LibraryConfig, "CONFIG_blockRecaptcha">) => Promise<string>;

export declare function getComments({ publication, path, size, sizereply, id, lastid, state, apiToken, API_ENV, }: GetCommentsParams): Promise<any>;

export declare interface GetCommentsParams {
    publication: string;
    path: string;
    size?: number;
    sizereply?: number;
    id?: string;
    lastid?: string;
    state?: string;
    apiToken: string;
    API_ENV: LibraryConfig;
}

export declare function getConfig(): LibraryConfig;

export declare function getConfigCacheTtlMs(): number;

export declare function getConfigOriginAuditReport(comparison?: ConfigOriginComparisonReport | null): ConfigOriginAuditReport;

export declare const getDynamicSlots: (axiosApi: AxiosInstance, config: Config, imgSizes: {
    [key: string]: any;
}, imageSizes: ImageSizesContractInput | undefined, DYNAMIC_SLOT_TOTAL: number, DYNAMIC_SLOT_SUBINDEXES: number, exclude?: string) => Promise<{
    [key: string]: any;
}>;

export declare const getEnvironmentUrl: () => string | undefined;

export declare const getEnvironmentUrlFront: () => string | undefined;

export declare function getFrontPrefix(cfg?: PrefixConfig): string;

export declare const getHydratorPath: (props: Props_3) => string;

export declare const getImageUrl: (imageUrl: string) => Promise<string>;

export declare const getItemFormated: (item: NewListResponseData, commonServices: CommonServices, imgSize: string) => Promise<ItemFormatedType>;

export declare const getNextMeta: (config: Config, paths: Array<string>, page: number) => string;

export declare const getPage: (pathname: string) => number;

/**
 * Get the custom Play icon component if configured, otherwise return the default Play component
 *
 * @example
 * // Server components
 * const PlayIcon = getPlayIcon();
 * return <PlayIcon className="my-class" />
 *
 * @returns ComponentType<SVGProps<SVGSVGElement>>
 */
export declare function getPlayIcon(): ComponentType<SVGProps<SVGSVGElement>>;

export declare const getPreloadImages: (list: NewListResponseData[], PRELOADED_IMAGES_AMOUNT?: number) => PreloadImage[];

export declare const getPrevMeta: (config: Config, paths: Array<string>, page: number) => string;

export declare const getRelatedNewsCarrousel: (currentNew: NewListResponseData, internalPath: string, commonServices: CommonServices) => Promise<NewListResponseData[] | undefined>;

export declare function getReportReasonLabel(reasonKey: ReportReasonKey): string;

export declare function getResponse<T>(response: PromiseSettledResult<AxiosResponse<T>> | undefined): T | null;

export declare function getResponsePromise<T>(response: PromiseSettledResult<T> | undefined): T | null;

export declare const getSchemas: (params: Params, path: string, axiosApi: AxiosInstance) => Promise<void | AxiosResponse<    {
data: Array<ItemList>;
}, any, {}>>;

export declare const getScriptReplaces: {
    [key in MetadataDefaultsKeys]: (props: Props_6) => replaces | undefined;
};

export declare function getServicePrefix(cfg?: PrefixConfig): string;

export declare const getSlugs: {
    [key in MetadataDefaultsKeys]: any;
};

/** String (o undefined) para una clave dinámica; nunca devuelve el objeto `comentarios`. */
export declare function getTextsStringValue(texts: textsType, key: string): string | undefined;

export declare function getTitleString(title: string | {
    article?: string;
    home?: string;
    section?: string;
    seo?: string;
} | undefined): string;

export declare const getTypeOfNews: (props: Props) => string;

/** `vf` | `vy` | `ve` si la entrada es un video; `undefined` si es nota. */
export declare const getVideoOp: (item: any) => VideoOp | undefined;

export declare function getVideoRealPath(pathname: string): {
    path: string;
    op: string;
};

export declare const GTM: () => "" | JSX.Element | undefined;

export declare function handleGetComments({ publication, path, size, sizereply, id, lastid, state, apiToken, API_ENV, }: GetCommentsParams): Promise<any>;

export declare function handleListLoadMoreRequest(url: URL, { size, cfg, timeoutMs }: ListLoadMoreHandlerOptions): Promise<Response>;

export declare interface Hascontent {
    hasgalleryvideosflash: boolean;
    hasgalleryvideosyoutube: boolean;
    hasgalleryvideosembedded: boolean;
    hasgalleryimages: boolean;
    hasaudios: boolean;
    hasfiles: boolean;
    hasembeddedimage: boolean;
    hasembeddedvideoyoutube: boolean;
    hasembeddedvideolink: boolean;
    hasembeddedvideoembedded: boolean;
    hasembeddedvideogallery: boolean;
    hasembeddedvideolist: boolean;
    hasembeddedimagegallery: boolean;
    hasembeddedaudio: boolean;
    hasembeddedaudiogallery: boolean;
    hasembeddedaudiolist: boolean;
    hasembeddedpinterest: boolean;
    hasembeddedvine: boolean;
    hasembeddedinstagram: boolean;
    hasembeddedtwitter: boolean;
    hasembeddedfacebook: boolean;
    hasembeddedembedded: boolean;
    hasembeddedpoll: boolean;
    hasembeddedstorify: boolean;
    hasembeddedflickr: boolean;
    hasembeddedimagecomparator: boolean;
    hasembeddedyoutube: boolean;
    hasembeddediframe: boolean;
    hasembeddedevent: boolean;
    hasembeddedrelatednews: boolean;
    hasembeddedjwplayer: boolean;
    hasembeddedbrid: boolean;
}

export declare type headConfig = {
    ampConfig: boolean;
    ampConfig_slugIsValid: boolean;
    preloadImages: boolean;
    schemas_Autor: boolean;
    schemas_ItemList: boolean;
    schemas_NewsArticle: boolean;
    schemas_Videos: boolean;
    schemas_WebsiteList: boolean;
    schemas_SoftwareApplication: boolean;
    /**
     * Banner/ads preconnect (stack GPT/GAM). Opcionales: `GenerateHead` mergea el
     * `headConfig` recibido sobre `DEFAULT_HEAD_CONFIG`, así el que no los define
     * hereda `false` y NO emite nada (retrocompatible). Cada sitio opta por los
     * que usa.
     */
    /** preconnect a securepubads.g.doubleclick.net (GPT). */
    bannersPreconnect_gpt?: boolean;
    /** preconnect a googleads.g.doubleclick.net (Google Ads). */
    bannersPreconnect_googleAds?: boolean;
    /** preconnect a tpc.googlesyndication.com (SafeFrame). */
    bannersPreconnect_syndication?: boolean;
    /** dns-prefetch a pagead2.googlesyndication.com (AdSense/GPT). */
    bannersPreconnect_adsense?: boolean;
};

export declare const Header: default_2.FC<HeaderProps>;

declare type HeaderProps = {
    menuText: string;
    editionText: string;
    menu: Array<MenuResponse>;
    alertZone?: NewListResponse;
    children: default_2.ReactNode;
    sidebar: Array<MenuResponse>;
    cintillo?: Array<MenuResponse>;
    socialIcons: boolean;
    tapeTitle?: string;
    icon: ReactNode;
    socials: Socials;
    rightZone?: ReactNode;
    sidebarExtra?: ReactNode;
    copyrigth?: string;
    searchKeyWord: string;
    showAlertPop?: boolean;
    showOnlyStickyHeader?: boolean;
    searchLink?: string;
    headerTape?: {
        static: boolean;
        sticky: boolean;
    };
    childrenContentPosition?: 'before-headers' | 'after-headers';
    childrenContentTag?: 'div' | 'article';
    custom_styles?: CSSProperties;
    mobileIcon?: any;
    customComponent?: ReactNode;
    /**
     * [banners] Slot `pre_header`. Pensado para el banner `pre_header` (posicion
     * no estandar: la mayoria de los sitios no la usa).
     *
     * Se renderiza UNA sola vez, como primer hijo de `#content-layout`
     * (`.sass-com-h1-preHeader`). No va dentro de ningun `<header>`: bajo 900px
     * el estatico es `display: none` y solo se ve el sticky, asi que un slot
     * dentro del estatico nunca se veia en mobile. Tampoco se duplica en el
     * sticky: con `CONFIG_deferBanners.middle: false` los `<script>` del creativo
     * corren igual aunque el nodo este oculto => doble impresion / ids repetidos.
     *
     * - Mobile (<900px): pegado ARRIBA del sticky. El nodo es el mismo, pero se
     *   fija al viewport (`position: fixed; top: 0`) y el sticky baja lo que mide
     *   el banner; los dos quedan pineados juntos. CONTRATO DE ALTURA: el sitio
     *   DEBE declarar la altura del creativo mobile:
     *
     *     :root { --pre-header-height-mobile: 100px; }
     *
     *   El recuadro mide exactamente eso (lo que sobra se recorta, no tapa el
     *   sticky). El offset del sticky y del contenido solo se aplica con el slot
     *   lleno (`body:has(.sass-com-h1-preHeader:not(:empty))`).
     * - Desktop (>=900px): se sube a `top: 0` de la pagina y el header estatico
     *   le deja el hueco con un `::before`. CONTRATO DE ALTURA: el estatico es
     *   `position: absolute` y el contenido lo despeja con un `margin-top` fijo,
     *   asi que un sitio que active `pre_header` DEBE declarar la altura:
     *
     *     :root { --pre-header-height: 90px; }
     *
     * Default `0px` y el wrapper se oculta con `:empty` (el banner devuelve
     * `null` sin la key en el CMS), asi que sin el slot el layout no cambia.
     */
    preHeader?: ReactNode;
    prerender_classes?: {
        alert?: string;
    };
};

export declare const HeaderSectionComponent: FC<Props_12>;

export declare function HomeCard(props: SectionCardProps_3): JSX.Element;

/**
 * Genera el string HTML de una HomeCard de tipo "imagen" sin pasar por React.
 * Reemplaza a <HomeCard> para el tipo imagen en LandingTemplate.
 *
 * - `priorityHigh` (lo decide el caller) → fetchpriority="high" / loading="eager".
 *   Por default false → low/lazy.
 * - Sin espacio extra en la clase homeCardImage cuando no hay preRenderClass.
 */
export declare function homeCardImagenToHTMLString(item: NewListResponseData, index: number, paths: RoutePathConfig, share?: Omit<NoteShare, 'googleProfile'>, priorityHigh?: boolean): string;

declare interface ICommonServices {
    config?: Config;
    /** @deprecated Ya no se lee acá; los tamaños salen de `contract` (§3). Se acepta por retrocompat hasta Fase 3. */
    imgSizes?: any;
    /** @deprecated No se lee en CommonServices; se acepta por retrocompat hasta Fase 3. */
    imgSizesVideo?: any;
    /** Nuevo contrato de tamaños (REFACTOR_IMGSIZES_PLAN.md §3). Ausente → `resolveImageSizes` cae a los defaults congelados (§4) → output idéntico. */
    imageSizes?: ImageSizesContractInput;
    axiosApi: AxiosInstance;
    exclude?: string;
}

export declare type IDestacadoNoticias = {
    title: string;
    '--block-head-title-font-size'?: string;
    '--block-head-title-line-height'?: string;
    '--block-head-title-font-size-mobile'?: string;
    '--block-head-title-line-height-mobile'?: string;
    '--news-section-news-content-gap-mobile'?: string;
    '--block-head-subtitle-line-clamp'?: string;
    '--block-head-title-line-clamp'?: string;
    '--block-head-subtitle-display'?: string;
    '--block-head-title-hover-color'?: string;
} & OutstandingNewsCSS & SectionCardCSS & SectionCSS & ButtonCSS & ImageCSS;

export declare const IframeHeader: ({ newsformated, internal, commonServices, }: {
    newsformated: NewListResponseData;
    internal?: string;
    commonServices: CommonServices;
}) => Promise<JSX.Element | null>;

declare interface Image_2 {
    sizes: Size[];
}
export { Image_2 as Image }

declare interface ImageCSS {
    '--image-play-width'?: string;
    '--image-play-height'?: string;
}

export declare const ImageOffline: FC<ImageProps_3>;

export declare const ImageOnline: FC<ImageProps_2>;

export declare const ImageOnlineClient: FC<ImageProps_4>;

declare interface ImageProps {
    copyright: boolean;
    description: string | false;
    photographer: boolean;
    sizes: Array<{
        scale: string;
        url: string;
        width: number;
        height: number;
    }>;
    original: {
        height: number;
        width: number;
        url: string;
    };
}

declare interface ImageProps_2 {
    preview: Preview;
    isVideo?: boolean;
    isLarge?: boolean;
    priorityHigh?: boolean;
    BackDropAuxHeigthMobile?: string;
    figCaption?: string;
}

declare interface ImageProps_3 {
    preview: Preview;
    isVideo?: boolean;
    isLarge?: boolean;
    hasShadow?: boolean;
    priorityHigh?: boolean;
    cookies?: any;
    PUBLIC_API_HOST: string;
    PUBLIC_OFFLINE_SITE: string;
}

declare interface ImageProps_4 {
    preview: Preview;
    isVideo?: boolean;
    isLarge?: boolean;
    priorityHigh?: boolean;
    figCaption?: string;
}

export declare interface ImageSizesCheckReport {
    /** `true` si el contrato no necesitó ningún default congelado. */
    ok: boolean;
    legacyFieldsUsed: string[];
}

export declare interface ImageSizesContract {
    note: {
        detailMain: SizeString;
        detailSecondary: SizeString;
        itemsListPrimary: SizeString;
        relatedPrimary: SizeString;
        relatedThumb: SizeString;
        listStandard: SizeString;
        cardTall: SizeString;
        square: SizeString;
        gallery: SizeString;
        featuredSuperSecondary?: SizeString;
        featuredVerticalPrimary?: SizeString;
        featuredVerticalSecondary?: SizeString;
        featuredHorizontalPrimary?: SizeString;
        featuredHorizontalSecondary?: SizeString;
        featuredDiarioImageThumb?: SizeString;
    };
    author: {
        avatar: SizeString;
        multiCrop: SizeString;
    };
    video: {
        xl: SizeString;
        lg: SizeString;
        md: SizeString;
    };
    og: {
        social: SizeString;
    };
    /**
     * Corte opcional propio de un repo (NO resuelto por `resolveImageSizes`, sin
     * default congelado). El repo que lo usa lo declara; si un consumidor lo usa
     * sin declararlo es `undefined` → falla (obliga a configurar, decisión del
     * owner). Hoy: preview cuadrado-grande de video/clip (`squareLg`) en
     * radioformula/template/crack-family. Repos que no lo usan lo omiten.
     */
    squareLg?: SizeString;
}

/**
 * Partial real (por slot, no solo por grupo): `Partial<ImageSizesContract>` es
 * shallow y obligaría a mandar cada grupo completo o nada. Un app puede mandar
 * solo algunos slots de `note` y dejar el resto en manos del default congelado.
 *
 * `squareLg` (opcional, sin default) va aparte del mapeo de grupos: es un
 * escalar, no un grupo — pasa tal cual si se provee, se omite si no.
 */
export declare type ImageSizesContractInput = {
    [G in RequiredGroup]?: Partial<ImageSizesContract[G]>;
} & {
    squareLg?: SizeString;
};

export declare interface ImageSizesResolution {
    /** Siempre completo — nunca undefined para el resto del paquete. */
    contract: ImageSizesContract;
    /** Slots resueltos por el default congelado, no provistos por el app. */
    legacyFieldsUsed: string[];
}

export declare interface Info {
    type?: string;
    /** Tipo de video cuando `type === 'video'`: flash, youtube o embedded. */
    videoOp?: 'vf' | 'vy' | 've';
    section?: {
        name: string;
        slug: string;
        url: string;
    };
    link: {
        url?: string;
        target?: string;
        canonical?: string;
        internal?: string;
    };
    date: {
        date: string;
        created: number;
        modified: number;
        firstpublish: number;
        lastpublish: number;
    };
}

export declare function initLibrary(userConfig?: LibraryConfig): void;

/** Engancha todos los botones "Ver mas" presentes en `scope` (default: el documento). */
export declare function initListLoadMore(scope?: ParentNode | null): void;

/**
 * Reescribe a "hace 3 horas" el texto de todo `[data-rel-ts]` cuya fecha caiga
 * dentro de `maxAgeHours`, y lo refresca mientras la pestaña esté visible.
 *
 * Sin React a propósito: hidratar un nodo de texto con React cuesta más que el
 * dato. Sin JS —o sin llamar a esta función— queda el absoluto que emitió el
 * SSR, que es correcto, cacheable y el que lee el crawler.
 *
 * Idempotente: una segunda llamada reemplaza los listeners de la anterior.
 * Devuelve el disposer.
 */
export declare const initRelativeTime: (opts?: RelativeTimeOptions) => () => void;

/**
 * CKEditor deja `.ck-audio-player` con spans vacíos. El mp3 público está en
 * `.ck-editor-audios span[data-source]` — no se usa `data-src` ni ningún servicio.
 *
 * <div class="ck-audio-player">
 *   <span data-type="audio" data-src="/audios/…" data-title="…">
 *   <span data-type="img">
 *   <div class="ck-editor-audios">
 *     <span data-source="https://hls.debate.com.mx/audios/….mp3">
 *   </div>
 * </div>
 */
export declare function insertCkAudioPlayers(html: string): string;

export declare function isConfigOriginAuditEnabled(): boolean;

export declare interface ISection {
    name: string;
    slug: string;
    url: string;
}

/**
 * Única fuente de verdad para saber si un pathname corresponde al home.
 * Misma regla que usa el schema ItemList (ver schemas/item.list.server.tsx).
 */
export declare const isHomePath: (pathname?: string) => boolean;

/** `true` si esta ruta muestra el boton "Ver mas" en lugar del paginador. */
export declare function isLoadMoreRoute(route: string, cfg?: Pick<LibraryConfig, 'CONFIG_listLoadMore'>): boolean;

export declare const isPhotoGallery: (news: NewListResponseData) => boolean | undefined;

/**
 * ¿reCAPTCHA está desactivado? Fuente ÚNICA del kill switch
 * `CONFIG_blockRecaptcha`; la consumen todos los puntos de uso de reCAPTCHA de
 * la librería (script enterprise, widget v2, generación de token y las tres
 * verificaciones server-side).
 *
 * `cfg` explícito (típicamente el prop `API_ENV` de un componente cliente, o
 * las `COMMENTS_VARS` de un endpoint) GANA sobre el singleton de `initLibrary`,
 * que se usa como fallback: en el cliente el singleton puede no estar poblado
 * porque cada isla hidrata su propio grafo de módulos.
 *
 * Default `false` cuando nadie define el flag → comportamiento actual.
 */
export declare function isRecaptchaBlocked(cfg?: Pick<LibraryConfig, 'CONFIG_blockRecaptcha'>): boolean;

/**
 * ¿El molde es una tarjeta que este renderer sabe completar? Cubre
 * `section-card-1` y `SectionCard6`, que son las dos que emiten el bloque de
 * `NewsDescription` (`.sass-com-nd-*`). Una `OpinionCard2` (`.sass-com-oc2-*`)
 * NO lo emite: ahi el clon saldria con los datos de la primera nota repetidos,
 * asi que el runtime corta antes de pintar nada.
 */
export declare const isSupportedCardTemplate: (template: Element) => boolean;

export declare class IssuuServices {
    private issuuApi;
    private api;
    private q;
    constructor(config: Config_2);
    getListIssuuPublications({ page }: {
        page: number;
    }): Promise<AxiosResponse<any, any, {}> | undefined>;
    getListIssuuPublicationBySlug(slug: string): Promise<AxiosResponse<any, any, {}> | undefined>;
}

/** True para videos (flash, youtube y embedded) en cualquiera de sus formas. */
export declare const isVideoContentItem: (item: any) => boolean;

/**
 * ¿La fecha cae dentro de la ventana en la que corresponde texto relativo?
 *
 * Fuente ÚNICA de la decisión relativo-vs-absoluto: la consumen
 * `formatRelativeDate` (SSR/render) y el hidratador `initRelativeTime`
 * (cliente), para que nunca puedan discrepar.
 *
 * Las fechas futuras (`date > now`) quedan FUERA de la ventana a propósito:
 * un reloj de cliente atrasado no debe producir "en 3 horas".
 */
export declare const isWithinRelativeWindow: (date: number, now: number, maxAgeHours?: number) => boolean;

export declare interface ItemFormatedType extends NewListResponseData {
    gallery?: Array<Preview>;
    videos?: Array<VideoItem>;
}

export declare type ItemList = {
    list: {
        integrated: boolean;
        items: Array<{
            index: number;
            title: string;
            body: {
                rendered: string;
                striped: string;
            };
            categories: boolean;
            image: Preview;
            videos: boolean;
            related: string;
            date: number;
        }>;
    };
};

export declare const ItemListSchema: ({ config, axiosApi, pathname, ROUTE }: ItemListSchemaProps) => Promise<false | JSX.Element>;

declare interface ItemListSchemaProps {
    config: Config;
    pathname: string;
    axiosApi: AxiosInstance;
    ROUTE: MetadataDefaultsKeys;
}

export declare const JournalistArticule2: FC<Props_49>;

export declare const JournalistArticule5: FC<Props_53>;

export declare const JournalistGroup: FC<Props_50>;

/**
 * Techo de la ventana para las familias que PRESERVAN el absoluto
 * (`keepAbsolute`): **24 h**. Con la fecha absoluta a la vista, un relativo en
 * días no agrega información — `26 de agosto 2026 • hace 3 días` es la misma
 * fecha dicha dos veces, y peor: la segunda, aproximada.
 *
 * Es un TECHO, no un default: se aplica como `min(maxAgeHours, 24)`, así un
 * sitio que configure una ventana más corta la conserva. Las familias que
 * REEMPLAZAN el absoluto no lo usan: ahí el relativo es el único dato que hay y
 * `maxAgeHours` manda entero.
 *
 * El borde es EXCLUSIVO (`< 24 h`), a diferencia de `isWithinRelativeWindow`,
 * que es inclusiva: a las 24 h exactas la escala ya dice "hace 1 día", que es
 * justo lo que este techo existe para evitar.
 */
export declare const KEEP_ABSOLUTE_MAX_AGE_HOURS = 24;

export declare const LayoutNewsComponent: FC<Props_47>;

export declare type LibraryConfig = {
    PUBLIC_API_HOST?: string;
    PUBLIC_API_FRONT?: string;
    PUBLIC_API_PATH?: string;
    PUBLIC_API_PATH_VERSION?: string;
    PUBLIC_X_SECURITY_TOKEN?: string;
    PUBLIC_PUBLICATION_ID?: string;
    PUBLIC_TAG_TYPE?: string;
    PUBLIC_ENV?: string;
    PUBLIC_LNG?: string;
    PUBLIC_SERVICE_PREFIX?: string;
    PUBLIC_IS_SUB_PUBLICATION?: string;
    FORCE_SUB_PUBLICATION_PREFIX?: string;
    PUBLIC_USERNAME_OFFLINE?: string;
    PUBLIC_PASSWORD_OFFLINE?: string;
    PUBLIC_IS_OFFLINE?: string;
    PUBLIC_OFFLINE_SITE?: string;
    PUBLIC_WP_API_HOST?: string;
    PUBLIC_X_SECURITY_WAF_TOKEN?: string;
    DEPLOY_BUCKET?: string;
    PUBLIC_ASSETS_URL?: string;
    PUBLIC_BUILD_ID?: string;
    DATE_TIMEZONE?: string;
    VARIANT_header?: 'op2' | 'op1';
    VARIANT_footer?: 'op2' | 'op1';
    VARIANT_section?: 'op1' | 'op2';
    VARIANT_videos?: 'op2' | 'op1';
    VARIANT_autor?: 'op1' | 'op2';
    VARIANT_tag?: 'op1' | 'op2';
    S3_ID_DIR?: string;
    CONFIG_commentsV2?: boolean;
    /**
     * [EXPERIMENTAL] Lista de `internalPath` donde forzar `commentsV2` en el
     * render SSR aunque el flag global `CONFIG_commentsV2` esté en `false`.
     * Scaffold de testing per-nota (el flag global se lee de un singleton y no
     * puede variar por nota). Aditivo: sin la lista el comportamiento no cambia.
     * Remover al promover v2 a global.
     */
    EXPERIMENTAL_commentsV2Paths?: string[];
    CONFIG_comments?: boolean;
    CONFIG_blockDefaultTwitterHydrator?: boolean;
    CONFIG_hasSlugRoute?: boolean;
    CONFIG_slugAsSection?: boolean;
    CONFIG_shareOnlyWhatsApp?: boolean;
    CONFIG_blockDefaultSectionRoute?: boolean;
    CONFIG_videoClipUrl?: string;
    CONFIG_newNoteBannersIndexing?: boolean;
    CONFIG_buscar_html?: boolean;
    /**
     * [render] Cuando es `true`, `LandingTemplate` renderiza las cards de tipo
     * `imagen` con el fast-render HTML-string (`homeCardImagenToHTMLString`) en
     * lugar del componente React `<HomeCard>`, ahorrando reconciliación/hidratación.
     * El fast-render se saltea online cuando la URL de preview no es absoluta y
     * SIEMPRE cae a `<HomeCard>` en offline (el path HTML-string no pasa por el
     * hidratador de imágenes offline). Default `false` → usa `<HomeCard>` React.
     */
    CONFIG_landingFastRender?: boolean;
    /**
     * [listados] Boton "Ver mas" en lugar de ANTERIOR/SIGUIENTE.
     *
     * `true` lo prende en todas las rutas de {@link LISTING_ROUTES} con los
     * defaults; la forma larga ({@link ListLoadMoreConfig}) permite elegir rutas,
     * tope de paginas y los params del pedido al CMS.
     *
     * Prenderlo arrastra, sin tocar codigo de la ruta:
     *  - `SectionServerComponent` pinta `<ListLoadMore>` en el lugar exacto donde
     *    pintaba `<NextPrev>`, o sea que hereda su caja y su CSS.
     *  - `shouldDisablePagination(route)` pasa a `true`, para que el sitio recorte
     *    la metadata de paginado (`rel=prev` / `rel=next`).
     *
     * Lo unico que cada repo monta a mano es el runtime de cliente
     * (`initListLoadMore()`, un `<script>` en el layout) y el endpoint
     * (`handleListLoadMoreRequest`, un archivo de ~6 lineas en `src/pages/api/`),
     * porque ni los `<script>` ni las rutas de Astro se pueden declarar desde un
     * paquete.
     *
     * Default `undefined` -> paginacion clasica, comportamiento actual.
     */
    CONFIG_listLoadMore?: boolean | ListLoadMoreConfig;
    /**
     * [render] Fecha relativa ("hace 3 horas") en las superficies que emiten
     * `data-rel-ts`. Solo lo lee el hidratador `initRelativeTime` en el cliente:
     * el SSR SIEMPRE emite la fecha absoluta, porque el HTML se sirve cacheado y
     * un relativo renderizado en servidor queda congelado en el CDN.
     *
     * Default `undefined` -> comportamiento actual (absoluto, sin hidratador).
     *
     * - `enabled`     — kill switch. Sin `true` el hidratador no toca el DOM.
     * - `scope`       — qué familias de superficie hidrata. Default `'all'`.
     *                   Ver {@link RelativeTimeScope}.
     * - `maxAgeHours` — cuánto tiempo se mantiene el relativo. Default **48**;
     *                   pasada esa antigüedad se muestra el absoluto que emitió
     *                   el SSR (cada superficie conserva su propio formato).
     *                   En las familias de `keepAbsolute` la ventana se topea en
     *                   **24 h** (`min(maxAgeHours, 24)`): con la fecha a la
     *                   vista, un relativo en días es la misma fecha repetida.
     * - `keepAbsolute` — dónde el relativo convive con el absoluto en vez de
     *                    reemplazarlo. Default `'notes'`. En esas familias la
     *                    ventana se topea en 24 h y el relativo ocupa el lugar de
     *                    la hora (`26 de agosto 2026 • hace 2 horas`).
     *                    Ver {@link RelativeTimeKeepAbsolute}.
     * - `separator`   — qué va entre el absoluto y el relativo cuando el
     *                   absoluto NO trae hora (tarjetas, comentarios). Default
     *                   `' · '` (U+00B7). En el encabezado de la nota, que sí
     *                   trae hora (`26 de agosto 2026 • 09:23 hs`), el relativo
     *                   OCUPA el lugar de la hora conservando el `'•'` del SSR
     *                   (`26 de agosto 2026 • hace 2 horas`) y este separador no
     *                   se usa; la hora vuelve entera al salir de la ventana.
     */
    CONFIG_relativeTime?: {
        enabled: boolean;
        maxAgeHours?: number;
        scope?: RelativeTimeScope;
        keepAbsolute?: RelativeTimeKeepAbsolute;
        separator?: string;
    };
    CONFIG_deferBanners?: {
        common?: boolean;
        middle?: boolean;
        innote?: boolean;
    };
    /**
     * [banners] Nomenclatura de keys de banners. **Solo gatea los renombres que
     * REUSAN un nombre existente**; el resto de la nomenclatura nueva
     * (`post_header`, `pre_footer`, `pre_header`,
     * `destacado_middle`, `block_N_middle`, `body_N`) no pasa por acá: son
     * nombres nuevos, sin colisión posible, y se resuelven siempre con fallback
     * canónico → legacy vía `findBanner`.
     *
     * - `'legacy'` (**default**) — comportamiento histórico, byte-idéntico.
     *   Los middles dinámicos del home siguen siendo `middle_dynamic_<slot>` y
     *   los middles de nota siguen numerados desde `middle_2`. El banner
     *   interno del destacado es `destacado_1` con `rightOnlyBanner` y
     *   `destacado_2` sin él.
     * - `'v2'` — los middles dinámicos del home pasan a `middle_<slot>` (con
     *   fallback a `middle_dynamic_<slot>`) y la nota renumera sus middles
     *   arrancando en `middle_1`. El banner interno del destacado es siempre
     *   `destacado_1` (`rightOnlyBanner` ya no cambia el índice) y
     *   `destacado_2` queda para el banner externo, que renderiza el sitio.
     *
     * POR QUÉ ES UN FLAG Y NO UN FALLBACK MÁS. Estos casos no son un
     * renombre, son un SWAP: `middle_N` sigue existiendo después del cambio pero
     * apunta a otra posición física. Con fallback gradual, un sitio a medio
     * migrar resolvería el `middle_1` viejo (estático, arriba) desde la posición
     * nueva (dinámica, abajo) y duplicaría el banner. El flag garantiza que no
     * exista estado mixto: se da vuelta el mismo día que se renombran las keys
     * en el CMS.
     *
     * Cutover por sitio. Un sitio en `'legacy'` no ve NINGÚN cambio de
     * comportamiento por este refactor.
     */
    CONFIG_bannerKeys?: 'legacy' | 'v2';
    /**
     * [banners] Rutas cuyo contenido de banners depende de que exista un query
     * string (ej. `'buscar'`: sin query no hay resultados → no hay banners). Para
     * esas rutas, cuando el query está vacío: `GenerateHead` NO emite los
     * preconnects de banners (`<BannersPreconnect>`) ni los `headscripts`, y cada
     * sitio debería saltarse el fetch de banners en su `LayoutCore` usando
     * `bannersEnabledForRequest(route, query)`. El resto de rutas nunca se gatea.
     *
     * Default (si no se define): `['buscar']`. Para desactivar el gate por
     * completo: `[]`. Aditivo/retro-compatible: solo afecta buscar-sin-query, que
     * en esta familia de templates nunca renderiza banners (el render del
     * `LandingTemplate` ya está gateado por `amount > 0`). Se tipa como `string[]`
     * (no `MetadataDefaultsKeys[]`) para evitar el import circular config ↔
     * metadata_defaults; las claves válidas son las de `MetadataDefaultsKeys`.
     */
    CONFIG_bannersRequireQuery?: string[];
    /**
     * TTL (ms) del cache in-memory SSR para `getMainMenu` / `getBanners` vía API CMS.
     * Default 45000. `0` desactiva el cache. También configurable en
     * `BUCKET_ORIGIN.cacheTtlMs` (tiene prioridad si está definido).
     */
    CONFIG_configCacheTtlMs?: number;
    PAGE_SWIPER?: {
        home: boolean;
        autor: boolean;
        ultimasnoticias: boolean;
        seccion: boolean;
        tema: boolean;
        buscar: boolean;
    };
    ANALYTICS_ga4?: string | undefined;
    ANALYTICS_marfeel?: string | undefined;
    ANALYTICS_gtm?: string | undefined;
    ANALYTICS_comscore?: string | undefined;
    COGNITO_AUTH_PREFIX?: string;
    COGNITO_CLIENT_ID?: string;
    COGNITO_DOMAIN?: string;
    COGNITO_REDIRECT_URI?: string;
    CAPTCHA_PROJECT?: string;
    CAPTCHA_KEY?: string;
    COMMENTS_CAPTCHA_API_KEY?: string;
    CAPTCHA_KEY_V2?: string;
    /**
     * [kill switch] Desactiva TODOS los usos de reCAPTCHA de la librería en un
     * solo lugar. Con `true`:
     *
     * - no se inyecta el script de enterprise (`ReCaptchaRender`,
     *   `CommentLazyLoader`),
     * - no se renderiza el widget v2 (`FormActions`, `ReportPop`),
     * - `getCaptchaToken` NO toca `window.grecaptcha` y devuelve el sentinel
     *   `RECAPTCHA_DISABLED_TOKEN`,
     * - las verificaciones server-side (`createAssessment`,
     *   `verifyCaptchaToken`, `verifyCaptchaTokenEnterprise`) cortan antes del
     *   fetch a Google y devuelven "pasó" (score 1 / `true`),
     * - la validación de forms (`isFormValid`) deja de exigir token.
     *
     * Default `false`: el comportamiento es EXACTAMENTE el actual, así que subir
     * de versión sin declarar el flag no cambia nada en ningún repo (el flag es
     * puramente aditivo y retro-compatible).
     *
     * Es un flag de SEGURIDAD: en `true` los endpoints quedan sin protección
     * anti-bot, así que se usa para desbloquear un sitio (keys mal
     * configuradas, cuota agotada, captcha rompiendo el flujo), no como default.
     *
     * Los componentes cliente lo leen del prop `API_ENV` (el singleton de
     * `initLibrary` no está garantizado en cada isla de hidratación), por eso hay
     * que incluir `CONFIG_blockRecaptcha` en el `API_ENV_KEYS` de cada sitio que
     * pase config al cliente. Los helpers server-side lo leen del singleton, o
     * del parámetro explícito cuando lo reciben.
     */
    CONFIG_blockRecaptcha?: boolean;
    SHOW_TAG_BY_SECTION?: boolean;
    FETCH_SIZE_MORE_NEWS?: number;
    FETCH_SIZE_RELATED_NEWS?: number;
    SHOW_NEWS_MORE_NEWS?: boolean;
    SHOW_NEWS_RELATED_NEWS?: boolean;
    SHOW_DEV_RANKING?: boolean;
    SHOW_GOOGLE_PROFILE?: boolean;
    MORE_NEWS_SSR?: boolean;
    /**
     * Activa el auditor de HTML client-side inline (panel de debug en Shadow DOM).
     * Se setea una vez en `initLibrary` y se propaga a todas las páginas vía GenerateHead.
     * Default `false`.
     */
    HTML_AUDIT?: boolean;
    /** nonce opcional para CSP estricta del <script> inline del auditor. */
    HTML_AUDIT_NONCE?: string;
    /**
     * Activa el panel de debug de fetch/servicios (DebugStore + DebugPanel).
     * Flag propio e independiente de HTML_AUDIT (auditor de HTML). Default
     * `false`: sin el flag el store no acumula y el panel no se renderiza.
     */
    DEBUG_ENABLED?: boolean;
    NEWS_JOURNALIST_COMPONENT?: 'op1' | 'op2' | 'op3';
    COMPONENTS?: {
        PlayIcon?: ComponentType<SVGProps<SVGSVGElement>>;
    };
    USE_QUOTE_IN_QUERY_TAG_HOME?: boolean;
    FETCH_TAG_BASED_RELATED_NEWS?: boolean;
    SUB_PUBLICATION_PREFIX_IN_ROUTES?: {
        buscar: boolean;
        autor: boolean;
        tema: boolean;
    };
    LINK_REMOVE?: string;
    MULTIPUBLICATION_FETCHES?: any;
    /**
     * [origen alternativo] Sirve `getMainMenu`/`getBanners` desde un bucket S3
     * de configs estáticas en vez del CMS, devolviendo el mismo shape de
     * respuesta que el endpoint original (`{ data: [...] }`). `url` y
     * `clientName` son obligatorios dentro del objeto porque solo tienen
     * sentido junto a al menos un toggle en `true`; sin `BUCKET_ORIGIN` el
     * comportamiento no cambia (sigue yendo al CMS). Si un archivo no existe
     * en el bucket para un sitio/tipo dado, el request falla simple (sin
     * fallback automático al CMS) — igual que cualquier otro fetch fallido.
     *
     * [offline] Cuando `PUBLIC_IS_OFFLINE === 'true'`, todos los archivos de bucket
     * se leen de la subcarpeta `offline/` del mismo directorio
     * (`.../${subtype}/offline/${subtype}.json`) y, si fallan tras agotar
     * reintentos, NO caen al CMS ni al archivo online: se devuelve vacío. Ver
     * `resolveBucketOriginUrl`.
     */
    BUCKET_ORIGIN?: BucketOriginConfig;
};

export declare interface Link {
    url: string;
    canonical: string;
    internal: string;
    target: string;
    redirect: boolean;
}

export declare function LinkComponent(props: any): JSX.Element;

/** Se emite cuando el boton agrego tarjetas: lo escucha `initRelativeTime`. */
export declare const LIST_APPENDED_EVENT = "list:appended";

/**
 * Rutas de listado que el boton "Ver mas" sabe recorrer. Es la key con la que
 * viaja el `route` desde el boton hasta `buildLoadMoreRequest` y hasta el
 * endpoint propio del sitio; cada una resuelve a un endpoint distinto del CMS.
 *
 * `cartonista` NO es una `MetadataDefaultsKeys` (esa ruta se cuelga de la key
 * 'autor' para menu / banners / schemas), pero SI es una ruta de listado a
 * estos efectos.
 */
export declare const LISTING_ROUTES: readonly ["seccion", "tema", "ultimas-noticias", "autor", "cartonista"];

export declare type ListingRoute = (typeof LISTING_ROUTES)[number];

/**
 * Boton "Ver mas": reemplaza a ANTERIOR/SIGUIENTE en las rutas que el sitio
 * marca en `CONFIG_listLoadMore`.
 *
 * Se renderiza en el SERVIDOR (sin `client:`): el boton esta en el HTML desde el
 * primer byte, no hay salto de layout ni espera de hidratacion. Lo unico que
 * corre en el cliente es `initListLoadMore`, que lee todo de estos `data-*`.
 *
 * Va con las clases del paginador (`sass-com-np-content` + `sass-com-np-linkStyled`)
 * y en el mismo lugar del arbol a proposito: mismo alto, mismo radio, mismo
 * color y mismo hover que los links que reemplaza, sin CSS nuevo salvo el reset
 * del <button>.
 */
declare const ListLoadMore: FC<ListLoadMoreProps>;
export { ListLoadMore }
export { ListLoadMore as ListLoadMoreComponent }

/**
 * Forma larga del toggle {@link LibraryConfig.CONFIG_listLoadMore}.
 */
export declare type ListLoadMoreConfig = {
    /** Kill switch. `false` apaga la feature aunque el objeto este presente. */
    enabled?: boolean;
    /** Que rutas llevan boton. Default: todas las de {@link LISTING_ROUTES}. */
    routes?: ListingRoute[];
    /**
     * Tope de paginas que el boton deja alcanzar, contando la pagina 1 que ya
     * pinto el SSR: 5 => 4 clicks (paginas 2, 3, 4 y 5) y despues el boton se
     * saca del DOM. Default 5.
     */
    maxPages?: number;
    /** Endpoint propio del sitio. Default `/api/get-more-list`. */
    endpoint?: string;
    /**
     * `newstype` del pedido. Tiene que ser el MISMO que usa el router del sitio
     * para la pagina 1 (`config.newsType`), o la tarjeta 46 no sale del mismo
     * universo que la 45. Sin valor, el param no se manda y el CMS aplica su
     * default.
     */
    newsType?: string;
    /**
     * `imagesizes` del pedido. Mismo criterio: el corte con el que el router
     * pidio la pagina 1 (tipicamente `imageSizes.note.listStandard`). Sin valor,
     * el param no se manda y el CMS devuelve sus cortes por default — o sea,
     * imagenes con otra medida que las del SSR.
     */
    imageSizes?: string;
    /** `exclude` del pedido. Default: el mismo de los routers de listado. */
    exclude?: string;
    /**
     * Opt-in: el browser le pide las notas al CMS por `/hit/*` en vez de al
     * endpoint propio. Ahorra el paso por el SSR, pero obliga a publicar los dos
     * tokens (`PUBLIC_X_SECURITY_TOKEN` y `PUBLIC_X_SECURITY_WAF_TOKEN`) en el
     * HTML de la pagina. Default `false`.
     */
    cdnDirect?: boolean;
    /** Overrides por ruta de `newsType` / `imageSizes`. */
    routeOverrides?: Partial<Record<ListingRoute, ListLoadMoreRouteOverride>>;
};

export declare type ListLoadMoreHandlerOptions = {
    /** Tamano del lote. Es el `config.newsListLimit` del sitio. */
    size: number;
    cfg?: LibraryConfig;
    /**
     * Techo del pedido al CMS. Sin esto, un lote alto que tarda mas de lo normal
     * se corta solo del lado de Node y el boton queda sin salida. Default 20 s
     * (medido: hay lotes que tardan ~9 s, y el resto de la app no pone timeout).
     */
    timeoutMs?: number;
};

export declare type ListLoadMoreProps = {
    /** Ruta de listado. Es la key con la que viaja hasta el endpoint. */
    route: string;
    /** Slug del listado: seccion, tag (`...-t1234`) o usuario del autor. */
    slug: string;
    /** Cuantas notas ya pinto el SSR. Lote incompleto = no hay pagina siguiente. */
    renderedCount: number;
    /** Tamano del lote (`NEWS_PER_SECTION`). */
    batchSize: number;
    /** Pagina que ya esta en pantalla. El boton arranca en `currentPage + 1`. */
    currentPage?: number;
    texts?: {
        [key: string]: string | undefined;
    };
    paths: RoutePathConfig;
    /** Clase de speculation rules, para sacarla de los clones. */
    prerenderClass?: string;
    /**
     * Variante de tarjeta con la que se pinto el listado (el `option` de
     * `SectionCardServerComponent`). Las variantes de opinion montan
     * `OpinionCard2`, que el renderer no sabe completar.
     */
    cardOption?: string;
    /** Override del contenedor al que se le hace `appendChild`. */
    targetSelector?: string;
    /** Override del selector de la tarjeta molde dentro de ese contenedor. */
    itemSelector?: string;
};

/** Overrides de los params del CMS para una ruta puntual. */
export declare type ListLoadMoreRouteOverride = {
    newsType?: string;
    imageSizes?: string;
};

export declare const LiveBlogHeader: FC<Props_43>;

export declare type LoadMoreCmsRequest = {
    /** Nombre del endpoint del CMS, sin host ni version de path. */
    path: string;
    params: Record<string, string>;
};

declare const Location_2: FC<Props_23>;
export { Location_2 as Location }

export declare function LoginForm({ API_ENV, texts, }: Props_14): JSX.Element;

export declare type Logo = {
    url: string;
    width: number;
    height: number;
    alt: string;
};

declare interface Main {
    title: Title;
    uppertitle: boolean;
    subtitle: Subtitle;
    summary: boolean;
    tags: Tag[];
    hiddentags: string;
    person: boolean;
    categories: boolean;
    sources: boolean;
}

export declare interface MainBlock1Props extends SectionCardProps, NewDescriptionBlockProps {
    banner?: ReactNode;
    banners?: BannerResponse[];
    rightOnlyBanner?: boolean;
    customSectionCardStyles?: CSSProperties;
    customNewsDescriptionStyles?: CSSProperties;
    paths: RoutePathConfig;
    showSuper?: boolean;
    textPosition?: 'center' | 'start';
    heightImageOverwrite?: string;
    heightImageOverwriteMobile?: string;
    speculationPrerenderClass?: string;
}

export declare class MainComponentServices {
    exclude: string;
    config: any;
    /**
     * @deprecated Ya no se lee: los tamaños salen de `this.contract` (§3). Bigfish
     * pasaba `imgSizesVideo` acá (quirk documentado en el snapshot de Fase 0), por
     * eso `this.imgSizes.lg` resolvía a `video.lg` dentro de los destacados. Ese
     * quirk quedó saldado: los destacados son de NOTAS y hoy leen slots de
     * `contract.note` (ver cada getter). Se mantiene el parámetro posicional por
     * retrocompat hasta Fase 3.
     */
    imgSizes: any;
    configVersion: string;
    axiosApi: AxiosInstance | undefined;
    customMainImagesSize: string | undefined;
    /** Contrato de tamaños resuelto UNA vez (§3); el resto consume `this.contract.<slot>`. */
    readonly contract: ImageSizesContract;
    constructor(config: Config, imgSizes: any, axiosApi: AxiosInstance, exclude?: string, customMainImagesSizes?: string, imageSizes?: ImageSizesContractInput);
    getNewsListZone(params: Params): Promise<AxiosResponse<NewListResponse, any, {}> | undefined>;
    getOutstandingBlock(params: Params): Promise<{
        data: {
            data: Array<Outstanding>;
        };
    } | undefined>;
    getNewsListZoneWrapper(section: string, zone: string, size: number, imagesizes?: string): Promise<AxiosResponse<NewListResponse, any, {}> | undefined>;
    getNewsDestacadoDiario(section: string, zone: string): Promise<never[] | AxiosResponse<NewListResponse, any, {}>>;
    getNewsDestacadoDiarioImage(section: string, zone: string): Promise<never[] | AxiosResponse<NewListResponse, any, {}>>;
    getNewsAltoImpacto(section: string, zone: string): Promise<AxiosResponse<NewListResponse, any, {}> | undefined>;
    getNewsDestacadoVertical(section: string, zone: string): Promise<never[] | AxiosResponse<NewListResponse, any, {}>>;
    getNewsDestacadoHorizontal(section: string, zone: string): Promise<never[] | AxiosResponse<NewListResponse, any, {}>>;
    GetByOptions: any;
    getMainBlockData(params: Params, section?: string, zone?: string): Promise<{
        section: string;
        news: never[];
        live?: undefined;
    } | {
        section: string;
        news: any;
        live: {
            iframe: string | undefined;
            title: string | undefined;
        };
    }>;
}

export declare const Marfeel: () => "" | JSX.Element | undefined;

export declare const MasNoticiasLazyLoader: ({ section, internalPath, stylesConfig, paths, API_ENV, fetchConfig, }: MasNoticiasLazyLoaderProps) => JSX.Element;

declare type MasNoticiasLazyLoaderProps = {
    section: string;
    internalPath: string;
    stylesConfig: {
        [key: string]: any;
    };
    isVisibleDefault?: boolean;
    paths: RoutePathConfig;
    API_ENV: LibraryConfig;
    fetchConfig: FetchConfig;
};

export declare interface MenuResponse {
    description: string;
    alt: string;
    image: boolean;
    link: string;
    target: string;
    parameters: boolean;
    subitem: false | Array<MenuResponse>;
    external: boolean;
}

export declare type Metadata = {
    title: string;
    description: string;
    sections?: Array<Metadata>;
    alternates: {
        [key: string]: string;
    };
};

export declare const metadata_defaults: {
    [key in MetadataDefaultsKeys]: any;
};

export declare type MetadataDefaultsKeys = '404' | 'home' | 'slug' | 'news' | 'anuncia' | 'autor' | 'buscar' | 'contacto' | 'pages' | 'seccion' | 'tema' | 'ultimas-noticias' | 'video' | 'videos' | 'auth';

export declare const metadataToJSX: (metadata: any) => JSX_2.Element[];

export declare const MiddleSection: FC<Props_26>;

export declare const Modulo1x3: FC<Modulo1x3Props>;

export declare const Modulo1x3Card: FC<Modulo1x3CardProps>;

declare interface Modulo1x3CardProps {
    title: string;
    content: Array<NewListResponseData>;
    hasLines?: boolean;
    slot_id?: string;
    isHome?: boolean;
    showNewsLikeTitle?: boolean;
    paths: RoutePathConfig;
    speculationPrerenderClass?: string;
}

declare interface Modulo1x3Props extends Modulo3ColumnasProps, Omit<SectionProps, 'children'> {
}

export declare const Modulo1x4: FC<Modulo1x4Props>;

declare interface Modulo1x4Props {
    title: string;
    titleUrl?: string;
    content: Array<NewListResponseData>;
    share?: Omit<NoteShare, 'googleProfile'>;
    banner?: ReactNode;
    banners?: BannerResponse[];
    slot_id?: string;
    isHome?: boolean;
    hasLines?: boolean;
    paths: RoutePathConfig;
    speculationPrerenderClass?: string;
}

export declare const Modulo1x5: FC<Modulo1x5Props>;

declare interface Modulo1x5Props {
    title: string;
    titleUrl?: string;
    content: Array<NewListResponseData>;
    share?: Omit<NoteShare, 'googleProfile'>;
    banner?: ReactNode;
    banners?: BannerResponse[];
    slot_id?: string;
    isHome?: boolean;
    hasLines?: boolean;
    paths: RoutePathConfig;
    speculationPrerenderClass?: string;
}

export declare type Modulo1XN = {
    hasLines?: boolean;
    '--news-description-title-active-color'?: string;
} & SectionCardCSS & SectionCSS;

export declare const Modulo2Columnas: FC<Modulo2ColumnasProps>;

declare interface Modulo2ColumnasProps {
    title: ReactNode;
    news: Array<NewListResponseData>;
    share?: Omit<NoteShare, 'googleProfile'>;
    bannerArray?: ReactNode[];
    halfPageBanner?: ReactNode;
    backgroundColor?: string;
    isHome?: boolean;
    paths: RoutePathConfig;
}

export declare const Modulo3Columnas: FC<Modulo3ColumnasProps>;

declare interface Modulo3ColumnasProps {
    content: Array<NewListResponseData> | Array<VideoResponseData>;
    banners?: BannerResponse[];
    slot_id?: string;
    /** [banners] slot_id con el que se armaban estas keys antes del renombre.
     *  Se consulta solo si la canonica no esta en la respuesta del CMS. */
    legacySlotId?: string;
    isHome?: boolean;
    hasLines?: boolean;
    bannerPositionIndex?: Array<number>;
    isVideo?: boolean;
    paths: RoutePathConfig;
    showVideoTime?: boolean;
    showVideosubtitle?: boolean;
    showVideoAuthor?: boolean;
    speculationPrerender?: SpeculationPrerenderConfig;
    speculationPrerenderClass?: string;
}

export declare const ModuloBlockNews: FC<OptionCardBlockProps_2>;

export declare const ModuloNewsletter: FC<ModuloNewsletterProps>;

declare interface ModuloNewsletterProps {
    title: string;
    sibtitle: string;
    image: ReactNode;
    texts: textsType;
    termsLink: string;
    submitFunction: () => void;
    linkUrl?: string;
}

export declare const ModuloOpinion: FC<OptionCardBlockProps>;

export declare type MoreNewsPage = {
    items: NewListResponseData[];
    /** Mismo criterio que el `showNext` del paginador: lote incompleto = no hay mas. */
    hasMore: boolean;
};

declare type Network = {
    title: string;
    slug: string;
    url: string;
    label: string;
    show: boolean;
    showInSchema: boolean;
};

export declare const new_speculationRules_home: {
    prefetch: {
        where: {
            href_matches: string;
        };
        eagerness: string;
    }[];
    prerender: ({
        where: {
            and: ({
                selector_matches: string;
                href_matches?: undefined;
            } | {
                href_matches: string;
                selector_matches?: undefined;
            })[];
            href_matches?: undefined;
        };
        eagerness: string;
    } | {
        where: {
            href_matches: string;
            and?: undefined;
        };
        eagerness: string;
    })[];
};

export declare const new_speculationRules_note: {
    prefetch: ({
        urls: string[];
        eagerness: string;
        where?: undefined;
    } | {
        where: {
            and: ({
                href_matches: string;
                not?: undefined;
            } | {
                not: {
                    selector_matches: string;
                };
                href_matches?: undefined;
            })[];
        };
        eagerness: string;
        urls?: undefined;
    })[];
    prerender: {
        where: {
            and: ({
                selector_matches: string;
                href_matches?: undefined;
                not?: undefined;
            } | {
                href_matches: string;
                selector_matches?: undefined;
                not?: undefined;
            } | {
                not: {
                    selector_matches: string;
                };
                selector_matches?: undefined;
                href_matches?: undefined;
            })[];
        };
        eagerness: string;
    }[];
};

export declare const new_speculationRules_noteList: {
    prefetch: ({
        urls: string[];
        eagerness: string;
        where?: undefined;
    } | {
        where: {
            and: ({
                href_matches: string;
                not?: undefined;
            } | {
                not: {
                    selector_matches: string;
                };
                href_matches?: undefined;
            })[];
        };
        eagerness: string;
        urls?: undefined;
    })[];
    prerender: {
        where: {
            and: ({
                selector_matches: string;
                href_matches?: undefined;
                not?: undefined;
            } | {
                href_matches: string;
                selector_matches?: undefined;
                not?: undefined;
            } | {
                not: {
                    selector_matches: string;
                };
                selector_matches?: undefined;
                href_matches?: undefined;
            })[];
        };
        eagerness: string;
    }[];
};

export declare const new_speculationRules_section: {
    prefetch: ({
        urls: string[];
        eagerness: string;
        where?: undefined;
    } | {
        where: {
            href_matches: string;
        };
        eagerness: string;
        urls?: undefined;
    })[];
    prerender: ({
        where: {
            and: ({
                selector_matches: string;
                href_matches?: undefined;
            } | {
                href_matches: string;
                selector_matches?: undefined;
            })[];
            href_matches?: undefined;
        };
        eagerness: string;
    } | {
        where: {
            href_matches: string;
            and?: undefined;
        };
        eagerness: string;
    })[];
};

export declare const NewDescriptionBlock: FC<NewDescriptionBlockProps>;

declare interface NewDescriptionBlockProps {
    imageSize?: {
        height: string;
        width: string;
    };
    block: Array<NewListResponseData>;
    fontSizeTitle?: string;
    lineHeightTitle?: string;
    fontSizeTitleMobile?: string;
    lineHeightTitleMobile?: string;
    priorityHigh?: boolean;
    itemReverseOrder?: boolean;
    customNewsDescriptionStyles?: CSSProperties;
    paths: RoutePathConfig;
    speculationPrerenderClass?: string;
}

export declare interface NewListResponse {
    success: boolean;
    site: string;
    publication: string;
    entity: Entity;
    data: Array<NewListResponseData>;
}

export declare type NewListResponseData = {
    external?: {
        iframe?: string;
        httpstream?: boolean;
    };
    related?: {
        automatic?: boolean;
        news?: {
            path: string;
            inhome: boolean;
        }[];
    };
    info: Info;
    config?: any;
    social?: {
        title: string;
        description: string;
        images: {
            facebook: string;
            twitter?: string;
        };
    };
    main: {
        title: {
            home: string;
            section: string;
            article: string;
            seo?: string;
        };
        uppertitle?: string;
        subtitle: {
            rendered: string;
            striped: string;
        };
        summary?: {
            rendered: string;
        };
        tags: {
            name: string;
            slug: string;
            url: string;
            approved: boolean;
            id: string;
        }[];
        sources?: {
            name: string;
        }[];
    };
    body?: {
        rendered: string;
        striped: string;
    };
    authors: Array<Author>;
    preview: Preview;
    keywords?: {
        tags: Array<Tag>;
        hiddentags: boolean;
        person: boolean;
    };
    hascontent?: {
        hasgalleryvideosflash: boolean;
        hasgalleryvideosyoutube: boolean;
        hasgalleryvideosembedded: boolean;
        hasgalleryimages: boolean;
        hasaudios: boolean;
        hasfiles: boolean;
        hasitemlist: boolean;
        hasembeddedimage: boolean;
        hasembeddedvideoyoutube: boolean;
        hasembeddedvideolink: boolean;
        hasembeddedvideoembedded: boolean;
        hasembeddedvideogallery: boolean;
        hasembeddedvideolist: boolean;
        hasembeddedimagegallery: boolean;
        hasembeddedaudio: boolean;
        hasembeddedaudiogallery: boolean;
        hasembeddedaudiolist: boolean;
        hasembeddedpinterest: boolean;
        hasembeddedvine: boolean;
        hasembeddedinstagram: boolean;
        hasembeddedtwitter: boolean;
        hasembeddedfacebook: boolean;
        hasembeddedembedded: boolean;
        hasembeddedpoll: boolean;
        hasembeddedstorify: boolean;
        hasembeddedflickr: boolean;
        hasembeddedimagecomparator: boolean;
        hasembeddedyoutube: boolean;
        hasembeddediframe: boolean;
        hasembeddedevent: boolean;
        hasembeddedrelatednews: boolean;
        hasembeddedjwplayer: boolean;
        hasembeddedbrid: boolean;
    };
};

export declare const NewListResponseDataPH: NewListResponseDataPlaceholder;

export declare type NewListResponseDataPlaceholder = Omit<NewListResponseData, 'authors' | 'preview'> & {
    authors: {
        firstname: string;
        lastname: string;
        fullname: string;
        image: undefined;
        name: string;
        internaluser: boolean;
    }[];
    preview?: NewListResponseData['preview'];
};

declare interface News {
    path: string;
    inhome: boolean;
}

export declare const News_Content: (props: Props_11) => Promise<JSX.Element | undefined>;

export declare const NewsArticle: ({ realPath, config, BASE_URL, axiosApi, schemasCustomEndpoints, }: NewsArticleProps) => Promise<JSX.Element[]>;

declare interface NewsArticleProps {
    realPath: string;
    config: Config;
    BASE_URL: string;
    axiosApi: AxiosInstance;
    schemasCustomEndpoints?: string[];
}

export declare const NewsComponent: (props: Props_10) => Promise<JSX.Element | undefined>;

export declare const NewsContent: FC<Props_37>;

declare interface NewsDescriptionBlockCSS extends NewsDescriptionCSS {
    '--news-description-block-padding-main'?: string;
    '--news-description-block-image-display'?: string;
    '--news-description-block-index-display'?: string;
    '--aspect-ratio'?: string;
    '--section-card-image-box-shadow'?: string;
}

export declare const NewsDescriptionComponent: FC<NewsDescriptionProps>;

declare interface NewsDescriptionCSS extends SectionCardChipCSS {
    '--news-description-title-size-desk'?: string;
    '--news-description-title-line-height-desk'?: string;
    '--news-description-title-line-height-mobile'?: string;
    '--news-description-title-size-mobile'?: string;
    /** Clamp para ambos breakpoints. Lo pisan -desk / -mobile si estan definidos. */
    '--news-description-title-line-clamp'?: string;
    '--news-description-title-line-clamp-desk'?: string;
    '--news-description-title-line-clamp-mobile'?: string;
    '--news-description-title-color'?: string;
    '--news-description-title-hover-color'?: string;
    '--news-description-title-hover-decoration'?: string;
    '--news-description-content-gap'?: string;
    '--news-description-autor-display'?: string;
    '--news-description-autor-color'?: string;
    '--news-description-autor-text-transform'?: string;
    '--news-description-autor-font-size'?: string;
    '--news-description-autor-name-display'?: string;
    '--news-description-autor-name-color'?: string;
    '--news-description-autor-name-font-weight'?: string;
    '--news-description-subtitle-display'?: string;
}

declare type NewsDescriptionProps = {
    fontSizeSubTitle?: string;
    lineHeightSubTitle?: string;
    colorSubTitle?: string;
    cutSubtitle?: boolean;
    overImage?: 'left' | 'right' | 'default';
    share?: Omit<NoteShare, 'googleProfile'>;
    isTitle?: boolean;
    paths: RoutePathConfig;
    useNewHeaderFormat?: boolean;
    newsDescriptionSectionTag?: 'span' | 'h3';
    speculationPrerenderClass?: string;
} & NewListResponseData;

export declare interface NewsResponse {
    success: boolean;
    site: string;
    publication: string;
    data: DataNews[];
}

export declare const NextPrev: FC<Props_36>;

/**
 * Normaliza un valor crudo de `addtional` a URL absoluta para esa red.
 * Devuelve `''` si el valor no resuelve a nada linkeable, para que el
 * componente lo use con el mismo patron `{userX && (...)}` que el resto.
 */
export declare const normalizeAuthorSocialUrl: (network: AuthorSocialNetwork, rawValue: unknown) => string;

/** Normaliza un nombre de bloque: trim, minúsculas, espacios colapsados y alias. */
export declare const normalizeBlockName: (name: string) => string;

/**
 * Deja la entrada del ranking lista para `Readest`/`NewDescriptionBlock`.
 * Idempotente: una entrada ya normalizada (o una nota completa) se devuelve
 * tal cual, sin copia.
 */
export declare const normalizeRankingItem: (item: any, options?: NormalizeRankingOptions) => NewListResponseData | null;

/**
 * Normaliza la lista completa del ranking. Descarta las entradas sin título:
 * son las que hoy se cuelan como slot numerado en blanco.
 */
export declare const normalizeRankingList: (list: unknown, options?: NormalizeRankingOptions) => Array<NewListResponseData>;

export declare type NormalizeRankingOptions = {
    /** Prefijo de la ruta de ficha de video. Default: `video`. */
    videoPath?: string;
    /**
     * Sección sintética para las entradas de video, que no tienen una propia (el
     * bucket las manda como `section: { name: null }`). `name` sale de los textos
     * del sitio y `url` de `paths.videos`; si falta cualquiera de los dos el video
     * queda sin chip en vez de enlazar a una ruta inventada.
     */
    videoSection?: {
        name?: string;
        url?: string;
        slug?: string;
    };
};

/**
 * Normaliza el payload del bucket sin tocar su envoltorio, sea la respuesta de
 * axios (`{ data: { data: [...] } }`) o el fallback de `resilientFetch`
 * (`{ data: [...] }`).
 */
export declare const normalizeRankingResponse: <T>(response: T, options?: NormalizeRankingOptions) => T;

export declare const NOTA_PRERENDER_CLASS = "nota-prerender";

export declare type NoteShare = {
    variant: 'outline' | 'container' | 'custom';
    options?: Array<NoteShareOption>;
    url: string;
    googleProfile?: {
        url: string;
        likeSocial: boolean;
    };
    googleSourceShare?: string;
    whatsappUrl?: string;
    customButton?: boolean;
};

export declare type NoteShareOption = 'X' | 'Email' | 'LinkedIn' | 'Whatsapp' | 'FaceBook';

export declare const OpinionCard2: FC<OpinionCardProps>;

declare interface OpinionCardProps {
    data: NewListResponseData;
    autorIcon: any;
    paths: RoutePathConfig;
    speculationPrerenderClass?: string;
}

declare interface OptionCardBlockProps {
    title: ReactNode;
    banner?: ReactNode;
    titleUrl?: string;
    halfPageBanner?: ReactNode;
    news: Array<NewListResponseData>;
    isOpinion?: boolean;
    backgroundColor?: string;
    autorIcon: ReactNode;
    customStyles?: CSSProperties;
    paths: RoutePathConfig;
}

declare interface OptionCardBlockProps_2 {
    title: ReactNode;
    banner?: ReactNode;
    titleUrl?: string;
    halfPageBanner?: ReactNode;
    news: Array<NewListResponseData>;
    paths: RoutePathConfig;
    isHome?: boolean;
}

export declare const OrgList: ({ config, socials }: {
    config: Config;
    socials: Socials;
}) => JSX.Element;

export declare interface Original {
    scale: string;
    url: string;
    width: number;
    height: number;
}

export declare interface Outstanding {
    key: string;
    value: string;
    config: string;
    /** HTML del player cuando el destacado es "En vivo". */
    iframe?: string;
    titulo?: string;
}

declare interface OutstandingNewsCSS extends NewsDescriptionCSS {
    '--outstanding-news-head-background'?: string;
    '--outstanding-news-head-gap-mobile'?: string;
    '--outstanding-news-head-gap-desk'?: string;
    '--outstanding-news-head-title-color'?: string;
    '--outstanding-news-head-subtitle-color'?: string;
    '--outstanding-news-head-content-padding-desk'?: string;
    '--outstanding-news-head-content-padding-mobile'?: string;
    '--outstanding-news-head-content-gap-desk'?: string;
    '--outstanding-news-head-content-gap-mobile'?: string;
    '--outstanding-news-head-content-box-shadow'?: string;
    '--outstanding-news-head-boder-img'?: string;
    '--outstanding-news-head-border-radius'?: string;
    '--outstanding-news-head-content-align-items-desk'?: string;
    '--outstanding-news-head-content-align-items-mobile'?: string;
    '--image-backdrop-border'?: string;
}

export declare type Params = {
    publication?: number;
    exclude?: string;
    newstype?: string;
    size?: number;
    page?: number;
    imagesizes?: string;
    order?: string;
    template?: string;
    path?: string;
    query?: string;
    zone?: string;
    tagid?: string;
    tagtype?: number;
    section?: string;
    user?: string;
    search?: string;
    mode?: string;
    ranking?: string;
    onmainpage?: string;
    value?: string;
    related?: number;
};

export declare function parseConfigOriginCacheKey(cacheKey: string): {
    kind: 'menu' | 'banners';
    origin: 'api' | 'bucket';
    target: string;
};

export declare const parseTags: (keywords: any) => string;

export declare const pathnameSplit: (pathname: string) => {
    slug: string;
    path: string;
};

/**
 * Selecciona la variante de HTML del banner según el scope.
 * - Si el value no tiene markers [tag]...[/tag] → devuelve value as-is (legacy).
 * - Si tiene markers → busca match exacto por scope; fallback a [general]; si no hay nada, ''.
 * Los markers se eliminan del output: solo se devuelve el contenido interno.
 */
export declare const pickBannerVariant: (value: string, scope?: BannerScope) => string;

/**
 * Subconjunto de config necesario para resolver prefijos.
 * Se acepta como argumento opcional para poder usar estos helpers en
 * componentes client (donde `getConfig()` no está inicializado y la config
 * llega vía prop `API_ENV`). Si no se pasa, cae en `getConfig()` (server).
 */
declare type PrefixConfig = {
    PUBLIC_SERVICE_PREFIX?: string;
    PUBLIC_IS_SUB_PUBLICATION?: string;
    FORCE_SUB_PUBLICATION_PREFIX?: string;
    LINK_REMOVE?: string;
};

export declare interface PreloadImage {
    href: string;
    media?: string;
    fetchPriority?: 'high' | 'low' | 'auto';
}

export declare const PreloadImages: default_2.FC<PreloadImagesProps>;

declare interface PreloadImagesProps {
    images: PreloadImage[];
}

export declare interface Preview {
    sizes: Array<SizeImage>;
    original?: {
        url: string;
        width?: number;
        height?: number;
    };
    description: string | false;
    copyright?: string | false;
    photographer?: string | false;
}

/** Única función que imprime: nada de `console.warn` en el runtime de la app (§3.1). */
export declare function printImageSizesReport(report: ImageSizesCheckReport, label?: string): void;

export declare const processExtractedRelatedNews: (relatedNews: string[][], getNews: (params: any) => any, imagesizes?: string) => Promise<any[]>;

export declare type PromiseArray = {
    [key: string]: {
        promise?: Promise<any>;
        custom_extractData?: (val: any) => any;
    };
};

export declare type Props = {
    params: {
        news: string;
    };
    config: Config;
};

declare type Props_10 = {
    custom_complement?: any;
    ranking?: NewListResponseData[];
    banners: BannerResponse[];
    news?: NewListResponseData[];
    autor?: AutorInfo[];
    newsRelatedResponses?: (NewListResponseData[] | undefined)[];
    newsRelatedListResponses?: (NewListResponseData[] | undefined)[];
    itemList?: ItemList[];
    slug: string;
    socials: any;
    getVideos: {
        iframe: () => void;
        schema: () => void;
    };
    autorIcon: ReactNode;
    noteShare?: NoteShare;
    stylesConfig: {
        [key: string]: any;
    };
    relatedNewsList: any;
    moreNewsSSR?: any;
    texts: textsType;
    paths: RoutePathConfig;
    internalPath: string;
    showComments?: boolean;
    commonServices: CommonServices;
    API_ENV: LibraryConfig;
    fetchConfig: FetchConfig;
    headerSectionStyles?: {
        common: CSSProperties;
        liveblogs: CSSProperties;
    };
    readestCustomStyles?: CSSProperties;
    newsDescriptionSectionTag?: 'span' | 'h3';
    customSummary?: ReactNode;
    subtitleBeforeImage?: boolean;
};

declare type Props_11 = {
    banners: BannerResponse[];
    news?: NewListResponseData;
    newsRelatedResponses?: (NewListResponseData[] | undefined)[];
    newsRelatedListResponses?: (NewListResponseData[] | undefined)[];
    itemList?: ItemList[];
    slug: string;
    socials: any;
    getVideos: {
        iframe: () => void;
        schema: () => void;
    };
    autorIcon: ReactNode;
    noteShare?: NoteShare;
    texts: textsType;
    paths: RoutePathConfig;
    commonServices: CommonServices;
    scope?: BannerScope;
    customSummary?: ReactNode;
    customAfterJournalistComponent?: ReactNode;
    subtitleBeforeImage?: boolean;
    headerSectionStyles?: {
        common: CSSProperties;
        liveblogs: CSSProperties;
    };
};

declare type Props_12 = {
    option: string;
    news: Array<NewListResponseData>;
    paths: RoutePathConfig;
    commonServices: CommonServices;
    banners: BannerResponse[];
    headerSectionStyles?: {
        common: CSSProperties;
        liveblogs: CSSProperties;
    };
    newsDescriptionSectionTag?: 'span' | 'h3';
    scope?: BannerScope;
    subtitleBeforeImage?: boolean;
};

declare type Props_13 = {
    query: string;
    hasContent: boolean;
    texts: textsType;
};

declare type Props_14 = {
    API_ENV: {
        COGNITO_AUTH_PREFIX: string;
        PUBLIC_ENV: string;
        CAPTCHA_KEY: string;
        /** Kill switch de reCAPTCHA. Sin definir: captcha activo (como hoy). */
        CONFIG_blockRecaptcha?: boolean;
        PUBLIC_SERVICE_PREFIX?: string;
        PUBLIC_IS_SUB_PUBLICATION?: string;
        FORCE_SUB_PUBLICATION_PREFIX?: string;
    };
    texts?: textsType;
};

declare type Props_15 = {
    texts?: textsType;
    API_ENV: {
        COGNITO_AUTH_PREFIX: string;
        PUBLIC_ENV: string;
        CAPTCHA_KEY: string;
        /** Kill switch de reCAPTCHA. Sin definir: captcha activo (como hoy). */
        CONFIG_blockRecaptcha?: boolean;
    };
    termsAndConditionsUrl?: string;
};

declare type Props_16 = {
    option: string;
    item: NewListResponseData;
    autorIcon: ReactNode;
    paths: RoutePathConfig;
    speculationPrerenderClass?: string;
};

declare type Props_17 = {
    containerId: string;
    containerId2: string;
};

declare type Props_18 = {
    component: string;
    slot_id: string;
    data: any;
    banners: BannerResponse[];
    isHome?: boolean;
};

declare type Props_19 = {
    children: ReactNode;
    stylesConfigEntry: {
        [key: string]: any;
    };
};

declare type Props_2 = {
    id?: string;
    dimensionValues?: {
        [key: string]: string;
    };
    event_analytics?: BannerResponse;
    eventReplaces?: EventReplaces;
};

declare type Props_20 = {
    component: string;
    data: any;
    banners: BannerResponse[];
    rightOnlyBanner?: boolean;
    isHome?: boolean;
    commonServices?: CommonServices;
    texts?: textsType;
};

declare type Props_21 = {
    slots: any;
    DYNAMIC_SLOT_SUBINDEXES: number;
    stylesConfig: ConfigDynamic;
    AutorIcon: any;
    config: Config;
    banners: BannerResponse[];
    showTagBySection?: boolean;
    pathname?: string;
};

declare type Props_22 = {
    StylesConfigMain: ConfigMain;
    config: Config;
    banners: BannerResponse[];
    axiosApi: AxiosInstance;
    commonServices?: CommonServices;
    textPosition?: 'start' | 'center';
    /** Contrato de tamaños (mismo que usa el home router). */
    imageSizes?: ImageSizesContractInput;
    section?: string;
    zone?: string;
    exclude?: string;
    customMainImagesSize?: string;
    /** Datos del player/título del destacado "En vivo". */
    live?: {
        iframe?: string;
        title?: string;
    };
    texts?: textsType;
};

declare type Props_23 = {
    place: string;
};

declare type Props_24 = {
    children: ReactNode;
    desktopWidth?: string;
    className?: string;
};

declare type Props_25 = {
    children: ReactNode;
    show: boolean;
    order?: number;
    id?: string;
};

declare type Props_26 = {
    children: ReactNode;
};

declare type Props_27 = {
    banners: Array<BannerResponse>;
    /**
     * Sufijo numérico histórico: la key resuelta es `middle_${index}`. Se sigue
     * soportando tal cual — todos los call sites que no migraron lo usan.
     * Ignorado si se pasa `name`.
     */
    index?: string | number;
    /**
     * Key canónica COMPLETA, sin prefijo `middle_`. Es la vía para las
     * posiciones que dejaron de ser un middle numerado (`post_header`,
     * `pre_footer`, `pre_header`, `destacado_middle`, `block_N_middle`).
     */
    name?: string;
    /**
     * Key(s) con las que esta posición se llamaba antes. Solo se consultan si la
     * canónica no está en la respuesta del CMS. Ver `findBanner`.
     */
    legacy?: BannerLegacyKey;
    scope?: BannerScope;
};

declare type Props_28 = {
    banners: Array<BannerResponse>;
    /** Key canónica (nomenclatura nueva). */
    name: string;
    /**
     * Key(s) con las que esta misma posición se llamaba antes. Se usan solo si
     * `name` NO está en la respuesta del CMS, así el renombre es inerte hasta
     * que se actualicen los banners. Ver `findBanner`.
     */
    legacy?: BannerLegacyKey;
    scope?: BannerScope;
};

declare type Props_29 = {
    title?: string;
    content: Array<NewListResponseData>;
    customNewsDescriptionStyles?: CSSProperties;
    isHome?: boolean;
    paths: RoutePathConfig;
    speculationPrerenderClass?: string;
    /** Prefijo de la ficha de video para las entradas de video del ranking. */
    videoPath?: string;
    /**
     * Label del chip de video. Default: `videosSectionTitle` de los textos del
     * idioma activo. Los sitios lo pasan desde su propio `getTexts()`.
     */
    videosSectionLabel?: string;
};

declare type Props_3 = {
    AssetsPrefix: string | Record<string, string>;
    AssetsPath: string;
    isDev: boolean;
};

declare type Props_30 = {
    title: string;
    sibtitle: string;
    image: ReactNode;
    texts: textsType;
    className?: string;
    termsLink: string;
    termsLinkTarget?: string;
    submitFunction: any;
    linkUrl?: string;
};

declare type Props_31 = {
    title: string;
    sibtitle: string;
    image: ReactNode;
    texts: textsType;
    linkUrl?: string;
    termsLink?: string;
};

declare type Props_32 = {
    whatsappLink: string;
    terms: string;
};

declare type Props_33 = {
    socials: any;
    socialNetworks: any;
    freeZone: Array<MenuResponse>;
    menu: Array<MenuResponse>;
    logo: ReactNode;
    copyrigth?: string;
    customBlock?: ReactNode;
    custom_styles?: React.CSSProperties;
};

declare type Props_34 = {
    noteShare?: NoteShare;
    url?: string;
};

declare type Props_35 = {
    video: VideoResponseData;
    type: string;
};

declare type Props_36 = {
    currentPage: number;
    showNext: boolean;
    maxPages: number;
    pathname: string;
    query: string;
    texts: {
        [key: string]: string;
    };
    block_subPublication?: boolean;
};

declare type Props_37 = {
    children: ReactNode;
    paginatorComponent?: ReactNode;
    grid?: 3 | 4;
    className?: string;
};

declare type Props_38 = {
    children: ReactNode;
    className?: string;
};

declare type Props_39 = {
    title: string;
    description: string;
    buttonText?: string;
    logo: any;
    backgroundImgURL?: string;
};

declare type Props_4 = {
    axiosApi: AxiosInstance;
    banners: BannerResponse[];
    config: Config;
    socials: Socials;
    defaultMetadataName: MetadataDefaultsKeys;
    meta: any;
    imgSizes?: any;
    texts?: textsType;
    pathname: string;
    slug?: string;
    query?: string;
    internalPath?: string;
    /**
     * Datos ya resueltos por el render de la página (prop drilling) para que los
     * handlers de metadata paginada eviten el fetch duplicado. Todos los campos son
     * OPCIONALES y CRUDOS (no formateados): el paquete sigue armando el `<title>`.
     * Si el campo que un handler necesita no llega, hace fallback → fetch + log.
     */
    metaSource?: {
        /** seccion → section.info.section.name */
        sectionName?: string;
        /** tema → entity.name */
        tagName?: string;
        /** autor → info.fullname (derivable de `autor` ya drilleado, ver abajo) */
        fullname?: string;
        /** rutas paginadas → !(data.length < newsListLimit) */
        hasNextPage?: boolean;
    };
    speculationType?: 'Common' | 'Home' | 'Nota' | 'NotaLista';
    preloadImageUrl?: PreloadImage[];
    schemasImages?: {
        preview: {
            format: string;
            width: string;
            height: string;
            url: string;
        }[];
    }[];
    autor?: AutorInfo;
    listAutor?: NewListResponseData[];
    currentNew?: NewListResponseData;
    custom_metadata?: Metadata;
    custom_scriptReplaces?: {
        '[author_replace]': string;
        '[section_replace]': string;
        '[tag_replace]': string;
        '[url_replace]': string;
    };
    custom_Speculation?: string;
    headConfig?: Partial<headConfig>;
    head_custom_elements?: any;
    schemasCustomEndpoints?: string[];
    /** Reporte SSR de menú/banners (cache/dedup/network). Solo con HTML_AUDIT. */
    configOriginAuditReport?: ConfigOriginAuditReport | null;
};

declare type Props_40 = {
    label: string;
} & InputHTMLAttributes<HTMLInputElement>;

declare type Props_41 = {
    label: string;
    options: Array<SelectItem>;
} & InputHTMLAttributes<HTMLSelectElement>;

declare interface Props_42 extends DetailedHTMLProps<TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement> {
    label: string;
}

declare type Props_43 = {
    fontSizeSubTitle?: string;
    lineHeightSubTitle?: string;
    commonServices?: CommonServices;
} & NewListResponseData;

declare type Props_44 = {
    itemList: Array<ItemList>;
};

declare type Props_45 = {
    autor: AutorInfo;
    autorIcon: any;
    className?: string;
    /** Si true, usa iconos rellenos (filled) para redes sociales en lugar de outline */
    socialIconsFilled?: boolean;
    /** Si true, renderiza los iconos de redes sociales por medio de imagen (custom) */
    socialIconsCustom?: boolean;
    /**
     * Si true, pinta el cargo del autor (`USER_JOBTITLE` / `USER_POSITION`) entre
     * el nombre y el mail. Apagado por defecto: hasta ahora el cargo solo se
     * usaba para el `jobTitle` del schema ProfilePage y ningun sitio lo mostraba,
     * asi que el header no cambia salvo que el consumidor lo prenda.
     */
    showPosition?: boolean;
    /**
     * Si true, el mail deja de salir como bloque de texto (`.sass-com-ah1-email`)
     * y pasa a ser UNA RED MAS dentro de `.sass-com-ah1-social`: un icono de
     * sobre que linkea al `mailto:`. Es como lo pinta el sitio viejo de Debate
     * (`getSocialFollowLink` tiene `mail: 'mailto:{username}'` y la ficha del
     * autor no tiene linea de mail aparte).
     *
     * Apagado por defecto: los sitios que hoy muestran el mail en texto lo
     * siguen mostrando igual. A diferencia del bloque de texto, esta variante SI
     * respeta el flag del CMS (`USER_MOSTRAR_MAIL` / `USER_SHOWEMAIL`).
     */
    showEmailAsSocial?: boolean;
    /**
     * Si true, la bio del autor se pinta como HTML en lugar de texto escapado.
     *
     * El CMS deja cargar la descripcion con formato (`<br>` entre parrafos,
     * negritas, links), pero React escapa los children: el redactor que separo
     * su bio en cinco bloques veia los `<br>` literales en la ficha. Con el
     * toggle prendido el markup se interpreta, pasado antes por
     * `sanitizeRichText`: sobreviven los tags de formato y los links, y se caen
     * `<script>`, `<iframe>`, los handlers `on*` y los `href="javascript:"`.
     *
     * Apagado por defecto: los sitios que hoy tienen `<`/`>` en la bio como
     * texto (o que no cargan HTML) no cambian.
     *
     * El nodo pasa de `<p>` a `<div>` cuando esta prendido -- un `<p>` no puede
     * contener `<p>` ni `<ul>` y el browser cerraria el parrafo antes de tiempo,
     * partiendo la ficha. La clase (`.sass-com-ah1-description`) es la misma.
     */
    allowBioHtml?: boolean;
};

declare type Props_46 = {
    autor: AutorInfo;
    autorIcon: any;
    /** Si true, usa iconos rellenos (filled) para redes sociales en lugar de outline */
    socialIconsFilled?: boolean;
    /**
     * Si true, la bio se pinta como HTML sanitizado en lugar de texto escapado.
     * Mismo contrato que en `AutorHeader1`: pasa el formato del CMS (`<br>`,
     * negritas, links) y no pasa nada ejecutable. Apagado por defecto.
     */
    allowBioHtml?: boolean;
};

declare type Props_47 = {
    children: ReactNode;
    banner: ReactNode;
    bannerTop: ReactNode;
    readestTitle: string;
    ranking: Array<NewListResponseData>;
    paths: RoutePathConfig;
    readestCustomStyles?: CSSProperties;
    /** Label del chip de sección de los videos del ranking (textos del sitio). */
    videosSectionLabel?: string;
};

declare type Props_48 = {
    video: VideoResponseData;
    videoList: Array<VideoResponseData>;
    type: string;
    mainVideoStyles?: CSSProperties;
    listVideoStyles?: CSSProperties;
    paths: RoutePathConfig;
    goBackLink?: string;
    titleGoBack?: string;
    banner?: {
        banners: Array<BannerResponse>;
        bannerName: string;
    };
    relatedName?: string;
};

declare interface Props_49 {
    autor: AutorInfo;
    autorIcon: any;
    texts: textsType;
    paths: RoutePathConfig;
}

declare type Props_5 = {
    children: ReactNode;
    defaultRouteName: MetadataDefaultsKeys;
    banners: BannerResponse[];
    pathname: string;
    config: Config;
    slug?: string;
    internalPath?: string;
    currentNew?: NewListResponseData;
    tagsParsed?: string;
    scriptReplaces: {
        [key in 'before' | 'after']: {
            active: boolean;
            customData: {
                '[author_replace]': string;
                '[section_replace]': string;
                '[tag_replace]': string;
                '[url_replace]': string;
            } | undefined;
        };
    };
    body_custom_elements?: any;
};

declare type Props_50 = {
    news: NewListResponseData;
    autorIcon: ReactNode;
    texts: textsType;
    paths: RoutePathConfig;
};

declare type Props_51 = {
    tag: string;
    description: string;
    img: string;
    className?: string;
    url?: string;
    social?: {
        facebook: string;
        twitter: string;
        linkedin: string;
        google: string;
        instagram: string;
    };
};

declare type Props_52 = {
    googleSourceShare?: string;
    googleProfile?: string;
    whatsAppShare?: string;
    text: textsType;
};

declare type Props_53 = {
    news: NewListResponseData;
    socials: any;
    autorIcon: ReactNode;
    noteShare?: NoteShare;
    texts: textsType;
    paths: RoutePathConfig;
};

declare type Props_6 = {
    pathname?: string;
    slug?: string;
    config?: Config;
    currentNew?: NewListResponseData;
    internalPath?: string;
};

declare type Props_7 = {
    showTitle?: boolean;
} & NewsDescriptionProps;

declare type Props_8 = {
    option: string;
    slug: string;
    currentPage: number;
    data: Array<NewListResponseData>;
    banners?: BannerResponse[];
    ranking: Array<NewListResponseData>;
    PAGINATION_MAX_PAGES: number;
    NEWS_PER_SECTION: number;
    pathname: string;
    autorIcon: ReactNode;
    texts: {
        [key: string]: string;
    };
    paths: RoutePathConfig;
    readestCustomStyles?: CSSProperties;
    speculationPrerender?: {
        class: string;
        length?: number;
    };
    custom_bannerPosition?: {
        [key: number]: number;
    };
    /**
     * [listados] Identidad del listado para el boton "Ver mas". Es lo UNICO que
     * cada ruta agrega para sumarse a la feature; el on/off vive en
     * `CONFIG_listLoadMore` (initLibrary), asi que con el toggle apagado este prop
     * no hace nada.
     *
     * `slug` va aparte del prop `slug` del componente a proposito: ese prop es la
     * VARIANTE de tarjeta (`option` de `SectionCardServerComponent`), y en varios
     * repos no coincide con el slug real del listado.
     */
    loadMore?: {
        route: string;
        slug: string;
    };
};

declare type Props_9 = {
    data: FreeZoneResponse[];
};

export declare const Readest: FC<Props_29>;

/**
 * Token que devuelve `getCaptchaToken` cuando reCAPTCHA está desactivado por
 * `CONFIG_blockRecaptcha`. Es un placeholder no vacío a propósito: los call
 * sites cortan con "Captcha token no generado" ante un token falsy, y el
 * server ni lo mira porque su verificación también está gateada por el flag.
 */
export declare const RECAPTCHA_DISABLED_TOKEN = "recaptcha-disabled";

export declare const ReCaptchaRender: ({ defaultRouteName }: {
    defaultRouteName: string;
}) => false | "" | JSX.Element | null | undefined;

export declare function RegisterForm({ texts, API_ENV, termsAndConditionsUrl }: Props_15): JSX.Element;

declare interface Related {
    automatic: boolean;
    news: News[];
}

declare interface Relatedexternal {
    news: boolean;
}

/**
 * Marca un elemento como hidratable a fecha relativa. El valor es el timestamp
 * en milisegundos (el mismo número que consume `formatDate`).
 */
export declare const RELATIVE_TIME_ATTR = "data-rel-ts";

/**
 * Texto literal a preservar ANTES del relativo, para las superficies donde el
 * elemento contiene `"Autor - fecha"` en un ÚNICO nodo de texto (super,
 * block-video-2/3, fast-render de la home). Existe para no partir ese texto en
 * nodos nuevos: el hidratador reescribe el `textContent` como `prefix + relativo`.
 *
 * Duplica el nombre del autor en el HTML; al ser una repetición literal dentro
 * del mismo documento, gzip/brotli la resuelven como back-reference.
 */
export declare const RELATIVE_TIME_PREFIX_ATTR = "data-rel-prefix";

/**
 * Superficie a la que pertenece el elemento, para que `CONFIG_relativeTime.scope`
 * pueda prender/apagar por familia sin que el hidratador tenga que adivinar la
 * ruta ni conocer selectores de componentes.
 *
 * - `'note'`   → la fecha del ENCABEZADO de la nota (`JournalistArticule3/4/5`)
 *                y la de los comentarios: solo existen dentro de una nota.
 * - `'summary'`→ tarjetas y listados (home, sección, tag, autor, búsqueda,
 *                "más noticias", videos, opinión). Es el DEFAULT.
 *
 * `'summary'` no se emite: la ausencia del atributo YA significa summary. Así
 * el HTML de las 8 superficies que ya existían no cambia ni un byte, y el HTML
 * emitido por versiones anteriores (sin el atributo) se sigue clasificando
 * bien.
 */
export declare const RELATIVE_TIME_SCOPE_ATTR = "data-rel-scope";

/**
 * Props JSX del contrato. Devuelve `{}` (spread vacío, cero atributos en el
 * HTML) si el timestamp no sirve: la superficie queda exactamente como hoy.
 */
export declare const relativeTimeAttrs: (ts: number | undefined, prefix?: string, surface?: RelativeTimeSurface) => Record<string, string | number>;

/**
 * La misma info que `relativeTimeAttrs`, para los emisores de HTML-string
 * (`homeCardFastRender`). Devuelve `''` o un fragmento que ARRANCA con espacio,
 * listo para concatenar dentro del tag.
 */
export declare const relativeTimeAttrsHTML: (ts: number | undefined, prefix?: string, surface?: RelativeTimeSurface) => string;

/**
 * Dónde el relativo se AGREGA al absoluto en lugar de reemplazarlo
 * (`CONFIG_relativeTime.keepAbsolute`). Mismas familias que
 * {@link RelativeTimeScope}, más `'none'`.
 *
 * - `'notes'`     — el encabezado de la nota y los comentarios quedan
 *                   `"13 de agosto 2026 • 01:18 hs · hace 3 horas"`; las
 *                   tarjetas y listados siguen reemplazando. **Es el default.**
 * - `'all'`       — se preserva el absoluto en todas las superficies.
 * - `'summaries'` — se preserva solo en tarjetas y listados.
 * - `'none'`      — el relativo reemplaza el texto en todas partes
 *                   (comportamiento previo a esta opción).
 *
 * Preservar el absoluto no agrega nodos al DOM: el hidratador reescribe el
 * mismo nodo de texto con `absoluto + separator + relativo`.
 */
export declare type RelativeTimeKeepAbsolute = RelativeTimeScope | 'none';

declare type RelativeTimeOptions = {
    /**
     * Gana sobre `CONFIG_relativeTime.enabled`. Sin ninguno de los dos en `true`
     * el hidratador es un no-op: no observa, no agenda y no toca el DOM.
     */
    enabled?: boolean;
    /**
     * Ventana del relativo. Default `CONFIG_relativeTime.maxAgeHours`, o 48.
     * Las familias de `keepAbsolute` la topean en
     * {@link KEEP_ABSOLUTE_MAX_AGE_HOURS}.
     */
    maxAgeHours?: number;
    /**
     * Qué familias de superficie hidratar. Default `CONFIG_relativeTime.scope`,
     * o `'all'` — que es exactamente el comportamiento previo al toggle.
     */
    scope?: RelativeTimeScope;
    /**
     * Dónde el relativo se AGREGA al absoluto en lugar de reemplazarlo. Default
     * `CONFIG_relativeTime.keepAbsolute`, o `'notes'`.
     */
    keepAbsolute?: RelativeTimeKeepAbsolute;
    /**
     * Separador entre el absoluto y el relativo. Default
     * `CONFIG_relativeTime.separator`, o {@link DEFAULT_RELATIVE_SEPARATOR}.
     */
    separator?: string;
    /** Cada cuánto refresca el texto. Default 60_000. `0` desactiva el refresco. */
    refreshMs?: number;
    /**
     * Idioma del texto relativo: `'en'` -> `"3 hours ago"`; cualquier otro valor
     * -> español. Acepta el tag completo (`'en-US'`, `'es-MX'`): se normaliza al
     * subtag primario.
     *
     * Existe porque este hidratador corre en el CLIENTE, y ahí el singleton de
     * `initLibrary` no está poblado: `initLibrary()` se llama en el frontmatter
     * de `Layout.astro`, que es servidor. Sin este parámetro el relativo caía
     * SIEMPRE al español, también en los builds con `PUBLIC_LNG=en`. Ver
     * {@link resolveDateConfig} para la cadena de fallbacks.
     */
    PUBLIC_LNG?: string;
    /**
     * Zona horaria del absoluto. Mismo motivo que {@link RelativeTimeOptions.PUBLIC_LNG}:
     * en cliente el singleton no la trae. La usa `formatDate`, al que este
     * hidratador solo llega por el borde de la ventana.
     */
    DATE_TIMEZONE?: string;
    /** Raíz del query. Default `document`. */
    root?: ParentNode;
};

/**
 * Alcance de la fecha relativa (`CONFIG_relativeTime.scope`).
 *
 * - `'all'`       — todo el sitio, **incluida la fecha del encabezado de la
 *                   nota** (`JournalistArticule3/4/5`) y la de los comentarios.
 *                   Es el default y el comportamiento previo al toggle.
 * - `'summaries'` — solo tarjetas y listados: home, sección, tag, autor,
 *                   búsqueda, "más noticias", videos, opinión. El encabezado de
 *                   la nota y los comentarios quedan en absoluto.
 * - `'notes'`     — solo lo que vive dentro de la nota: encabezado y
 *                   comentarios. Los listados quedan en absoluto.
 *
 * La clasificación viaja en el HTML como `data-rel-scope="note"` (la ausencia
 * del atributo significa `summary`), así que no depende de detectar la ruta.
 */
export declare type RelativeTimeScope = 'all' | 'summaries' | 'notes';

/** Familia de superficie. Ver `RELATIVE_TIME_SCOPE_ATTR`. */
export declare type RelativeTimeSurface = 'note' | 'summary';

export declare const removePages: (pathname: string) => string;

export declare type RenderCardContext = {
    /** Base de las imagenes relativas (`getEnvironmentUrl()` resuelto en el SSR). */
    imageBase: string;
    paths: RoutePathConfig;
    /** `SHOW_TAG_BY_SECTION`: la volanta muestra el primer tag y no la seccion. */
    showTagBySection: boolean;
    /** `PUBLIC_LNG` (el mismo valor que lee `formatDate` del singleton en el SSR). */
    lng: string;
    timeZone: string;
    /** Clase de speculation rules a sacar del clon. */
    prerenderClass?: string;
};

export declare function renderCardFast(template: Element, item: NewListResponseData, ctx: RenderCardContext): Element;

declare type ReplaceProps = {
    '[author_replace]': string;
    '[section_replace]': string;
    '[tag_replace]': string;
    '[url_replace]': string;
};

declare type replaces = {
    '[author_replace]': string;
    '[section_replace]': string;
    '[tag_replace]': string;
    '[url_replace]': string;
};

export declare interface ReplyType {
    id: string;
    state?: number;
    date: CommentDate;
    featured?: number;
    text: string;
    user: UserType | false;
}

export declare const REPORT_REASONS: {
    readonly spam: "Es spam o contenido comercial no deseado";
    readonly inappropriate: "Lenguaje inadecuado";
    readonly hate: "Discurso o símbolos de odio";
    readonly misinformation: "Información falsa o fraude";
    readonly terrorism: "Promueve el terrorismo";
    readonly intellectual: "Violación de propiedad intelectual";
    readonly bullying: "Bullying o acoso";
};

/**
 * Registra en el **debugPanel** (`DebugStore`, gated por `DEBUG_ENABLED`) que un
 * recurso de `BUCKET_ORIGIN` agotó los reintentos. En un sitio con el toggle
 * prendido, el bucket es el MÉTODO ÚNICO: NO se cae al CMS (eso solo pasa con el
 * toggle OFF, en sitios sin migrar). El recurso se sirve VACÍO y esta entrada
 * deja constancia explícita del "servido vacío, sin fallback" para que la falla
 * se NOTE en el panel en vez de quedar enmascarada. (El fallo de red crudo ya lo
 * registra `resilientFetch`; esta entrada agrega la decisión de no-fallback.)
 * Ver `PLAN_DYNAMIC_SLOTS_BUCKET_ORIGIN.md` §7.
 */
export declare function reportBucketOriginExhausted(kind: string, url: string): void;

export declare function reportComment({ publication, username, id, type, baseUrl, captchaToken, apiToken, securityToken, COMMENTS_VARS, }: ReportCommentParams): Promise<{
    type: string;
    message: string;
    status: number;
    data: any;
}>;

export declare interface ReportCommentParams {
    publication: string;
    username: string;
    id: string;
    type: string;
    baseUrl: string;
    captchaToken: string;
    apiToken: string;
    securityToken: string;
    COMMENTS_VARS: any;
}

export declare type ReportReasonKey = keyof typeof REPORT_REASONS;

/**
 * Grupos requeridos del contrato: los que `resolveImageSizes` completa con el
 * default congelado y el assert exige enteros. Los slots OPCIONALES sin default
 * obligatorio (`squareLg` a nivel raíz, `featured*` dentro de `note`) se manejan
 * aparte — no participan del assert obligatorio. Derivado (no hardcode) para que
 * un grupo requerido nuevo entre solo y siga cubierto por el guard de completitud.
 */
export declare type RequiredGroup = Exclude<keyof ImageSizesContract, 'squareLg'>;

/**
 * Defaults alineados con AWS SDK JS v3 (`standard` retry + NodeHttpHandler):
 * - maxAttempts 3 → 1 intento + 2 reintentos (`retries = 2`)
 * - backoff exponencial con full jitter (base 100ms, cap 20s)
 * - timeout por intento (SSR): el SDK no lo pone por defecto; acá sí para no
 *   colgar el render si el bucket no responde. El timeout ESCALA por intento
 *   (2500 → 5000 → 10000): el primer request de una instancia SSR fría paga
 *   DNS + TCP + TLS contra S3 y puede superar los 2500ms; sin escalado, los 3
 *   intentos caen por timeout y la PRIMERA carga se sirve vacía.
 */
export declare const RESILIENT_FETCH_DEFAULTS: {
    readonly retries: 2;
    readonly timeoutMs: 2500;
    readonly maxTimeoutMs: 10000;
    readonly baseDelayMs: 100;
    readonly maxDelayMs: 20000;
};

/**
 * Reintenta `fn` con backoff exponencial + jitter (paridad SDK `standard`),
 * acotando cada intento con `timeoutMs` (un fetch a un bucket S3 colgado no
 * debe bloquear el request indefinidamente).
 * Si se agotan los reintentos (o el error no es reintentable, ej. 404), registra el
 * fallo en DebugStore y devuelve `fallback` en vez de rechazar: una falla del bucket
 * no debe tumbar el render del sitio consumidor.
 */
export declare function resilientFetch<T, F>(fn: () => Promise<T> | T, fallback: F, { label, endpoint, params, retries, timeoutMs, maxTimeoutMs, baseDelayMs, maxDelayMs, }: ResilientFetchOptions): Promise<T | F>;

export declare interface ResilientFetchOptions {
    /** Identifica el fetch en logs y en el DebugStore (ej. '/news-list-zone', 'bucket:menu'). */
    label: string;
    endpoint?: string;
    params?: Record<string, any>;
    /**
     * Reintentos adicionales tras el primer intento.
     * Default 2 → 3 intentos totales (paridad con `maxAttempts: 3` del SDK).
     */
    retries?: number;
    /** Timeout del PRIMER intento; los reintentos lo duplican hasta `maxTimeoutMs`. */
    timeoutMs?: number;
    maxTimeoutMs?: number;
    baseDelayMs?: number;
    maxDelayMs?: number;
}

export declare function resolveBucketMenuSubtype(path?: string): string;

/**
 * Arma la URL del recurso en el bucket:
 * `${base}/${clientName}/${site}/${type}/${subtype}/${subtype}.json`.
 *
 * En modo offline (`PUBLIC_IS_OFFLINE === 'true'`) el consumidor pasa
 * `offline = true` y el archivo se resuelve dentro de la subcarpeta `offline/`
 * del MISMO directorio: `.../${subtype}/offline/${subtype}.json`. La variante
 * offline es un archivo aparte que convive con el de producción
 * (`.../${subtype}/${subtype}.json`); el consumidor NO cae al CMS ni al archivo
 * online si la offline falla (ver getMainMenu/getBanners/getDynamicSlots/destacado).
 */
export declare function resolveBucketOriginUrl(bucket: BucketOriginConfig, servicePrefix: string | undefined, type: 'menu' | 'banners' | 'bloques', subtype: string, offline?: boolean): string;

/** {@link ListLoadMoreConfig} con todos los defaults ya aplicados. */
export declare type ResolvedListLoadMore = {
    routes: readonly ListingRoute[];
    maxPages: number;
    endpoint: string;
    newsType: string;
    imageSizes: string;
    exclude: string;
    cdnDirect: boolean;
    routeOverrides?: Partial<Record<ListingRoute, ListLoadMoreRouteOverride>>;
};

/**
 * Recibe lo que el app mande hoy (contrato completo, parcial, o nada) y
 * devuelve SIEMPRE un contrato completo. Los constructores públicos del
 * paquete llaman esto una sola vez, en su punto de entrada, y de ahí en
 * adelante consumen `contract.<slot>` sin condicionales ni valores propios.
 *
 * Puede tirar (vía `assertImageSizesContract`) si un slot provisto por el
 * app no matchea el formato esperado — enforcement doble (§3): tipos en
 * build, assert en runtime.
 */
export declare function resolveImageSizes(input: ImageSizesContractInput | undefined): ImageSizesResolution;

/**
 * El toggle del boton "Ver mas" con los defaults aplicados, o `null` si el
 * sitio no lo prendio. Fuente UNICA de la resolucion: la consumen el componente,
 * el armador de params y el endpoint.
 */
export declare function resolveListLoadMore(cfg?: Pick<LibraryConfig, 'CONFIG_listLoadMore'>): ResolvedListLoadMore | null;

/** Clase de prerender para una nota por índice (primer slot: todas las notas). */
export declare function resolveSpeculationPrerenderClass(index: number, speculationPrerenderClass?: string, speculationPrerender?: SpeculationPrerenderConfig): string | undefined;

export declare interface RoutePathConfig {
    autor: string | 'autor';
    tema: string | 'tema';
    buscar: string | 'buscar';
    seccion: string | 'seccion';
    contacto?: string | 'contacto';
    anuncia?: string | 'anuncia';
    'ultimas-noticias': string | 'ultimas-noticias';
    /**
     * Segmento del listado de videos. Opcional a propósito: es lo que habilita el
     * chip de sección en las entradas de video del ranking, y no todos los sitios
     * tienen la ruta. Sin él no se inventa un `/videos` que daría 404.
     */
    videos?: string | 'videos';
}

export declare function runConfigOriginComparison(params: {
    axiosApi: AxiosInstance;
    servicePrefix: string;
    configVersion: string;
    runs?: number;
}): Promise<ConfigOriginComparisonReport | null>;

/**
 * Devuelve el HTML con SOLO los tags y atributos de la allowlist. Lo que no
 * esta permitido pierde el markup pero mantiene el texto.
 *
 * @example
 * sanitizeRichText('a<br>b<script>x()</script><a href="javascript:x()">c</a>')
 * // 'a<br />b<a>c</a>'
 */
export declare const sanitizeRichText: (html?: string | null) => string;

export declare function ScriptHydrator({ containerId, containerId2 }: Props_17): null;

declare type ScriptProps = {
    name: string;
    banners: BannerResponse[];
    replaces?: ReplaceProps;
    strategy?: 'afterInteractive' | 'lazyOnload' | 'beforeInteractive' | 'worker' | undefined;
};

export declare const SearchSection: FC<Props_13>;

export declare const Section: ForwardRefExoticComponent<SectionProps & RefAttributes<HTMLDivElement>>;

export declare const SectionCard: FC<SectionCardProps>;

export declare const SectionCard2: FC<SectionCardProps_2>;

export declare const SectionCard5: FC<NewListResponseData & {
    showNewsLikeTitle?: boolean;
    hasShadow?: boolean;
    textAlignment?: string;
    speculationPrerenderClass?: string;
    isHome?: boolean;
}>;

declare interface SectionCardCarouselProps extends Omit<SectionProps, 'children'> {
    content: Array<NewListResponseData>;
    slot_id: string;
    isHome?: boolean;
    autorIcon: ReactNode;
    paths: RoutePathConfig;
    speculationPrerenderClass?: string;
}

declare interface SectionCardChipCSS {
    '--section-card-chip-display'?: string;
    '--section-card-chip-display-mobile'?: string;
    '--section-card-chip-weight'?: string;
    '--section-card-chip-line-height'?: string;
    '--section-card-chip-letter-spacing'?: string;
    '--section-card-chip-text-transform'?: string;
    '--section-card-chip-background'?: string;
    '--section-card-chip-padding'?: string;
    '--section-card-chip-border'?: string;
    '--section-card-chip-border-radius'?: string;
    '--section-card-chip-color'?: string;
    '--section-card-chip-position'?: string;
    '--section-card-chip-left'?: string;
    '--super-content-news-height'?: string;
}

declare interface SectionCardCSS extends NewsDescriptionCSS {
    '--section-card-image-border-radius'?: string;
    '--section-card-image-box-shadow'?: string;
    '--section-card-news-description-padding-desk'?: string;
    '--section-card-news-description-padding-mobile'?: string;
    '--section-card-background'?: string;
    '--section-card-border'?: string;
    '--section-card-border-radius-content'?: string;
    '--section-card-border-radius-content-mobile'?: string;
    '--section-card-box-shadow'?: string;
    '--section-img-card-border-bottom'?: string;
}

declare interface SectionCardProps extends Omit<NewsDescriptionProps, 'preview'>, Omit<ImageProps_2, 'info'> {
    isLarge?: boolean;
    sectionCardNewsDescClass?: string;
    customSectionCardStyles?: CSSProperties;
    speculationPrerenderClass?: string;
    videos?: Array<VideoItem>;
}

declare interface SectionCardProps_2 extends Omit<NewsDescriptionProps, 'preview'>, ImageProps_2 {
    titleGradient?: boolean;
    heightImageOverwrite?: string;
    speculationPrerenderClass?: string;
}

declare interface SectionCardProps_3 extends Omit<{
    fontSizeSubTitle?: string;
    lineHeightSubTitle?: string;
    colorSubTitle?: string;
    cutSubtitle?: boolean;
    overImage?: 'left' | 'right' | 'default';
    share?: Omit<NoteShare, 'googleProfile'>;
    isTitle?: boolean;
    paths: RoutePathConfig;
} & ItemFormatedType, 'preview'>, Omit<{
    preview: Preview;
    isVideo?: boolean;
    isLarge?: boolean;
    priorityHigh?: boolean;
    BackDropAuxHeigthMobile?: string;
}, 'info'> {
    isLarge?: boolean;
    sectionCardNewsDescClass?: string;
    customSectionCardStyles?: CSSProperties;
}

export declare const SectionCardServerComponent: FC<Props_16>;

declare interface SectionCSS {
    '--section-title-color'?: string;
    '--section-title-sideLines'?: string;
    '--section-title-bottomLine'?: string;
    '--section-title-read-more'?: string;
    '--section-title-read-more-color'?: string;
    '--section-title-read-more-hover-color'?: string;
    '--section-title-read-more-font-size-desk'?: string;
    '--section-title-read-more-line-height-desk'?: string;
    '--section-title-read-more-font-size-mobile'?: string;
    '--section-title-read-more-line-height-mobile'?: string;
    '--section-title-font-size'?: string;
    '--section-title-font-family'?: string;
    '--section-line-color'?: string;
    '--section-title-text-transform'?: string;
    '--section-line-width'?: string;
    '--section-background-color'?: string;
    '--section-back-drop-heigth'?: string;
    '--section-content-padding'?: string;
    '--section-title-padding-desk'?: string;
    '--section-title-padding-mobile'?: string;
    '--section-title-tab-background'?: string;
    '--section-title-tab-width'?: string;
    '--section-title-tab-height'?: string;
    '--section-title-border-top'?: string;
    '--section-title-read-more-color-mobile'?: string;
}

declare interface SectionProps {
    title: ReactNode;
    className?: string;
    titleUrl?: string;
    isOpinion?: boolean;
    children: ReactNode;
    isTitle?: boolean;
    noHeading?: boolean;
}

export declare const SectionServerComponent: FC<Props_8>;

declare type SelectItem = {
    label: string;
    value: string | number;
};

export declare function shareButtons({ noteShare }: Props_34): JSX.Element | null;

/**
 * `true` si la ruta dejo de paginar de verdad, o sea si el sitio tiene que
 * recortar la metadata de paginado: sin `rel=prev` / `rel=next` y con el
 * canonical sin `/page/N`. Hoy es exactamente "esta ruta usa el boton", y existe
 * aparte para que los consumidores expresen la intencion y no la condicion.
 */
export declare function shouldDisablePagination(route: string, cfg?: Pick<LibraryConfig, 'CONFIG_listLoadMore'>): boolean;

export declare const ShowSection: FC<Props_25>;

declare interface Size {
    size: string;
    url: string;
    width: number;
    height: number;
}

export declare interface SizeImage {
    url: string;
    width: number;
    height: number;
    scale?: string;
}

/** Formato: `"w:{n},h:{n},t:{n}[,c:{hex}];"` (uno o más, cada uno separado y terminado en `;`). */
export declare type SizeString = string;

declare interface Social {
    title: boolean;
    description: boolean;
    images: boolean;
    tags: boolean;
}

export declare const socialIcons: {
    [key: string]: any;
};

export declare const SocialNetworks: {
    FaceBook: string;
    Instagram: string;
    WhatsApp: string;
    TikTok: string;
    Youtube: string;
    X: string;
    Gnews: string;
    Podcast: string;
    Telegram: string;
    LinkedIn: string;
    Spotify: string;
    Threads: string;
    Pinterest: string;
};

export declare type Socials = {
    [x: string]: Network;
};

export declare const SoftwareApplication: ({ config }: {
    config: Config;
}) => JSX.Element | null;

export declare type SoftwareApplicationData = {
    name?: string;
    url: string;
    operatingSystem: string;
    applicationCategory: string;
    applicationSubCategory?: string;
    offers: {
        price: string;
        priceCurrency: string;
    };
    aggregateRating?: {
        ratingValue: string;
        ratingCount: string;
        bestRating?: string;
    };
    description?: string;
    downloadUrl?: string;
    softwareVersion?: string;
    contentRating?: string;
};

export declare function SourceButtons({ googleSourceShare, googleProfile, whatsAppShare, text, }: Props_52): JSX.Element;

export declare type SourceButtonsType = {
    sourceButtons?: {
        googleSourceShare?: string;
        googleProfile?: string;
        whatsAppShare?: string;
    };
};

export declare type SpeculationPrerenderConfig = {
    class: string;
    length?: number;
};

export declare const SpeculationRules: ({ active, type, customSpeculation }: {
    active: boolean;
    type: "Home" | "Common" | "Nota" | "NotaLista";
    customSpeculation?: string;
}) => false | JSX.Element;

export declare const Spin: ({ className }: {
    className?: string;
}) => JSX.Element;

/**
 * Card de persona para páginas de staff.
 * API deliberadamente chica: solo nombre / foto / descripcion / perfilUrl.
 * Visualmente parte de OpinionCard2 (avatar + textos), sin el bloque de nota.
 */
export declare const StaffCard: FC<StaffCardProps>;

declare interface StaffCardProps {
    nombre: string;
    foto?: string;
    /** Acepta HTML de formato del CMS (`<br>`, `<strong>`, links); pasa por `sanitizeRichText`. */
    descripcion?: string;
    perfilUrl?: string;
    /** Fallback cuando no hay `foto`. */
    autorIcon?: ReactNode;
    /** Texto del CTA. Default: "Ver perfil". */
    profileLinkLabel?: string;
}

export declare function StaticSlotWrapper({ children, stylesConfigEntry, }: Props_19): JSX.Element;

/**
 * Texto plano: saca los tags y colapsa espacios. Es lo que necesita cualquier
 * consumidor que NO renderiza HTML (schemas JSON-LD, `meta description`,
 * `aria-label`, `title`), donde un `<br>` literal seria basura visible.
 */
export declare const stripHtml: (html?: string | null) => string;

export declare const SubscribeColumn: (props: Props_30) => JSX.Element;

export declare const SubscribeRow: FC<Props_31>;

export declare const SubscribeWhatsAppColumn: FC<Props_32>;

declare interface Subtitle {
    rendered: string;
    striped: string;
}

export declare type Super = {
    '--super-content-news-color'?: string;
    '--super-content-news-border-top'?: string;
    '--super-content-news-position'?: string;
    '--super-content-news-bottom'?: string;
    '--super-content-news-width'?: string;
    '--super-content-news-margin'?: string;
    '--super-content-news-margin-mobile'?: string;
    '--super-content-news-bottom-mobile'?: string;
    '--super-content-news-align-items-mobile'?: string;
    '--super-content-news-align-items-desk'?: string;
    '--super-title-text-align-mobile'?: string;
    '--super-title-text-align-desk'?: string;
    '--super-content-linkTitle-justify-content'?: string;
    '--super-content-news-padding-mobile'?: string;
    '--super-content-news-margin-bottom'?: string;
    '--super-content-news-margin-bottom-mobile'?: string;
    '--super-title-text-color'?: string;
    '--super-content-news-box-shadow'?: string;
    '--super-description-news-display'?: string;
    '--section-card-tagmx-display'?: string;
    '--super-description-news-text-align'?: string;
    '--super-content-news-gap'?: string;
    '--super-content-linkTitle-align-content'?: string;
    '--super-description-news-color'?: string;
};

export declare interface Tag {
    approved: boolean;
    name: string;
    id: string;
    info: boolean | TagInfo;
    /** @deprecated Prefer `info.image` from CMS note payloads */
    image?: Preview;
}

export declare const TagHeader: FC<Props_51>;

export declare interface TagInfo {
    description?: {
        rendered: string;
        striped: string;
    } | false;
    url?: string | false;
    template?: string | false;
    image?: Preview | false;
}

export declare const TagSection: FC<TagSectionProps>;

declare interface TagSectionProps {
    tags?: Array<Tag>;
    title?: string;
    paths: RoutePathConfig;
}

/** Loguea el resumen en consola, limpia el buffer y devuelve el reporte (SSR). */
export declare function takeConfigOriginAuditReport(comparison?: ConfigOriginComparisonReport | null): ConfigOriginAuditReport | null;

/** Cabecera / edición (barra superior) */
export declare type TextsHeader = {
    menuText: string;
    editionText: string;
};

/** Bloques de listados y búsqueda en home y secciones */
export declare type TextsListsAndSearch = {
    readestTitle: string;
    enVivoButton: string;
    /** Título del bloque destacado "En vivo" (ej. "Reportes de MiSitio en vivo"). */
    destacadoLiveTitle: string;
    relatedNewsTitle: string;
    moreNewsTitle: string;
    searchKeyWord: string;
    /**
     * Label del chip de sección de las entradas de video del ranking (las notas
     * traen la sección del CMS; los videos no tienen una). Opcional: sin valor el
     * video queda sin chip en vez de mostrar un texto inventado.
     */
    videosSectionTitle?: string;
};

/** Etiquetas de segmentos de URL (paths) */
export declare type TextsPathLabels = {
    autor: string;
    tema: string;
    buscar: string;
    seccion: string;
    'ultimas-noticias': string;
    /** Listado de videos. Opcional: no todos los sitios tienen la ruta. */
    videos?: string;
};

/** Cinta de ediciones y copyright */
export declare type TextsSiteChrome = {
    tapeTitle: string;
    sideCopyright: string;
    footerCopyright: string;
};

/**
 * Textos del sitio: campos base + claves extra + `comentarios` opcional.
 * El índice `string` vale `string | undefined`, así `texts[k]` (con `k: string`) encaja en APIs que esperan solo strings.
 * Los literales con `comentarios` deben cerrarse con `as unknown as textsType` (el índice string no admite el objeto en el literal).
 */
export declare type textsType = textsTypeBase & Record<string, string | undefined>;

/** Textos de sitio fijos + comentarios (misma forma que ComentariosTexts: varias piezas unidas) */
export declare type textsTypeBase = TextsHeader & TextsListsAndSearch & TextsSiteChrome & SourceButtonsType & TextsPathLabels & {
    comentarios?: ComentariosTexts;
};

export declare const TimeLine: FC<Props_44>;

declare interface Title {
    home: string;
    section: string;
    article: string;
}

export declare const toISOWithTimeZone: (value: number | string, timeZone: string) => string;

/**
 * Devuelve la URL pública de la edición CONFIANDO en la URL que entrega el CMS
 * (`info.link.canonical`, items de breadcrumb, etc.), que es correcta en la
 * enorme mayoría de los casos. Solo la reescribe cuando detecta el síntoma
 * concreto de que el CMS filtró el PATH INTERNO de la publicación principal:
 * el `pathname` arranca con el **service prefix** de la API (`/soyfutbolen`).
 *
 * Esa señal aparece tanto con origin ajeno (canonical:
 * `https://www.debate.com.mx/soyfutbolen/news/x.html`) como con el origin
 * público correcto (breadcrumb: `https://www.soyfutbol.com/soyfutbolen/...`);
 * en ambos casos `soyfutbolen` es el prefijo interno y hay que mapearlo al
 * front prefix público. Se arma: origin público + front prefix + path sin el
 * service prefix. El origin ajeno queda normalizado como efecto.
 *
 * IMPORTANTE — el swap sólo se habilita si el sitio DECLARA que el service
 * prefix es un namespace interno, vía front prefix (`FORCE_SUB_PUBLICATION_PREFIX`
 * / `PUBLIC_IS_SUB_PUBLICATION`) o vía `LINK_REMOVE` apuntando al mismo prefijo.
 * Sin esa declaración el "swap" degeneraría en un BORRADO de segmento, y el
 * nombre del service prefix puede coincidir con el de una sección real: en
 * `futbol.radioformula.com.mx` (`PUBLIC_SERVICE_PREFIX=futbol`, sin front
 * prefix) el canonical `.../futbol/nota.html` apunta a la sección `/futbol`,
 * no a un namespace filtrado, y reescribirlo rompía la URL.
 *
 * Todo lo demás se devuelve sin tocar → retrocompatible:
 *   - URL ya correcta (path bajo `/en`, no bajo `/soyfutbolen`),
 *   - canónica cross-domain intencional de contenido sindicado (path NO bajo
 *     el service prefix),
 *   - publicación principal (sin service prefix → return temprano),
 *   - sitio con service prefix pero sin front prefix ni `LINK_REMOVE` (no hay
 *     namespace interno declarado → return temprano),
 *   - subpublicación directa (`frontPrefix === servicePrefix`: el swap deja el
 *     path igual y el origin ya es el propio → no-op).
 *
 * @param cmsUrl       URL absoluta tal como la entrega el CMS.
 * @param publicOrigin Origin público de la edición (sin path), ej.
 *                     `https://www.soyfutbol.com`.
 */
export declare function toPublicEditionUrl(cmsUrl: string | undefined, publicOrigin: string, cfg?: PrefixConfig): string | undefined;

/**
 * Convierte un path o URL del CMS en la URL pública de COMPARTIR de la edición,
 * GARANTIZANDO el front prefix (`/en`). A diferencia de `toPublicEditionUrl`
 * —que confía en el CMS y solo reescribe el síntoma de path interno filtrado—,
 * este helper SIEMPRE deja la forma canónica pública, porque las URLs de
 * compartir apuntan siempre a la misma edición y deben ser la forma navegable
 * (`/en/news/...`), nunca el namespace interno (`/soyfutbolen/...`) ni la forma
 * sin prefijo (`/news/...`). Pensado para los call-sites que arman la URL por
 * concatenación (share de WhatsApp / comentarios / clipboard), que se saltean
 * el prefijado que sí aplica `<Link>`/`getFrontPrefix`.
 *
 * Reglas:
 *   1. Sin front prefix (publicación principal) → no-op (retrocompat).
 *   2. Si el path arranca con el service prefix interno (`/soyfutbolen`) → se
 *      quita.
 *   3. Se antepone el front prefix (`/en`) de forma idempotente (no duplica si
 *      el path ya lo tiene).
 *
 * Acepta URL absoluta (`https://host/soyfutbolen/x`) o path relativo
 * (`/soyfutbolen/x`), preservando query y hash.
 *
 * @param cmsUrl URL absoluta o path relativo tal como se arma en el call-site.
 * @param cfg    Config de prefijos. En cliente (donde `getConfig()` puede no
 *               estar inicializado) se DEBE pasar explícito.
 */
export declare function toPublicShareUrl(cmsUrl: string | undefined, cfg?: PrefixConfig): string | undefined;

export declare function TrimPathname(url: string): string;

export declare const TwitterHydration: ({ currentNew }: {
    currentNew?: NewListResponseData;
}) => false | JSX.Element | undefined;

export declare type TypeHomePreview = 'iframe' | 'videoYouTube' | 'imagen' | 'fotogaleria' | 'videoEmbedded' | 'clip';

export declare const urlReplaces: (internalPath: string) => string;

/**
 * Hook to get the Play icon component (for use in client components)
 *
 * @example
 * // Client components ('use client')
 * const PlayIcon = usePlayIcon();
 * return <PlayIcon className="my-class" />
 *
 * @returns ComponentType<SVGProps<SVGSVGElement>>
 */
export declare function usePlayIcon(): ComponentType<SVGProps<SVGSVGElement>>;

export declare interface UserType {
    username: string;
    firstname: string;
    lastname?: string;
    picture?: string;
}

export declare const validateHttpUrl: (url: string) => string;

/**
 * Verifica el token de reCAPTCHA usando la API de Google
 * @param token El token generado por el cliente
 * @param projectId El ID del proyecto de Google Cloud
 * @param captchaKey La clave del sitio de reCAPTCHA
 * @param captchaAction El nombre de la acción que corresponde al token
 * @param config Config del sitio para leer el kill switch
 *   `CONFIG_blockRecaptcha`. Si se omite se cae al singleton de `initLibrary`.
 * @returns Una promesa que se resuelve con la puntuación de riesgo
 */
export declare const verifyCaptchaTokenEnterprise: ({ token, projectId, captchaKey, apiKey, captchaAction, config, }: {
    token: string;
    projectId: string;
    captchaKey: string;
    apiKey: string;
    captchaAction: captchaActionType;
    config?: Pick<LibraryConfig, "CONFIG_blockRecaptcha">;
}) => Promise<number>;

export declare const VideoBlock3: FC<Props_35>;

export declare const VideoBlock4: FC<Props_48>;

export declare const VideoCarousel: FC<VideoCarouselProps>;

declare interface VideoCarouselProps {
    titleUrl?: string;
    content: Array<VideoResponseData>;
    title?: string;
    slot_id?: string;
    identificador?: number;
}

export declare const VideoEmbeddedHeader: ({ newsformated, internal, commonServices, }: {
    newsformated: NewListResponseData;
    internal?: string;
    commonServices: CommonServices;
}) => Promise<JSX.Element | null>;

export declare interface VideoItem {
    type: string;
    path: string;
    title: string;
    description: string;
    duration: string;
    size?: string;
    image: Preview;
    code: string;
    clip: string;
}

/**
 * El ranking (bucket GA4) mezcla notas y videos, pero NO los emite con la misma
 * forma: la nota llega completa (`info.link.url`, `main.title.home/section`,
 * `config`, `authors`…) y el video llega degradado —solo `info.link.internal` +
 * `info.link.canonical`, `main.title.article` y `preview`—.
 *
 * Sin normalizar, un video ocupa un slot en blanco: `NewDescriptionBlock` no
 * pinta la imagen (condiciona a `main.title.home`), `NewsDescription` no pinta
 * el título (lee `main.title.section`) ni lo enlaza (lee `info.link.url`).
 *
 * Este helper lleva cualquier entrada del ranking a `NewListResponseData`
 * completo, resolviendo la URL pública del video (flash, youtube y embedded).
 */
export declare type VideoOp = 'vf' | 'vy' | 've';

export declare interface VideoResponseData {
    config: {
        autoplay: boolean;
        mute: boolean;
    };
    info: {
        type: string;
        size: boolean;
        path: string;
        bitrate: boolean;
        creator: string;
        date: {
            created: number;
            modified: number;
        };
        duration: {
            rendered: string;
            striped: number;
        };
        link: {
            canonical: string;
            internal: string;
            target: string;
            url: string;
        };
    };
    main: {
        agency: boolean;
        author: boolean;
        categories: string;
        code: string;
        description: string;
        tags: string;
        title: string;
        image: ImageProps;
    };
}

declare interface VideoSchemasProps {
    realPath: string;
    config: Config;
    axiosApi: AxiosInstance;
}

export declare const VideosSchemas: ({ realPath, config, axiosApi }: VideoSchemasProps) => Promise<JSX.Element | null | undefined>;

export declare const VideoYoutubeHeader: ({ newsformated, internal, commonServices, }: {
    newsformated: NewListResponseData;
    internal?: string;
    commonServices: CommonServices;
}) => Promise<JSX.Element | null>;

export declare const WebsiteList: ({ config }: {
    config: Config;
}) => JSX.Element;

export declare function withPreviewFallback(item: NewListResponseData): NewListResponseData;

/**
 * Prefija una clase base con `nota-prerender` cuando corresponde.
 * Usar solo en el link principal de título/texto de la card, nunca en links de imagen.
 */
export declare function withSpeculationPrerenderClass(baseClass: string, prerenderClass?: string): string;

export { }