next-intl 3.25.0 → 4.0.0-beta-00a79d4

package/dist/types/navigation/shared/createSharedNavigationFns.d.ts

@@ -0,0 +1,386 @@
+import type { Locale } from 'use-intl';
+import { type RoutingConfigLocalizedNavigation, type RoutingConfigSharedNavigation } from '../../routing/config.tsx';
+import type { DomainsConfig, LocalePrefixMode, Locales, Pathnames } from '../../routing/types.tsx';
+import { type HrefOrHrefWithParams, type QueryParams } from './utils.tsx';
+type PromiseOrValue<Type> = Type | Promise<Type>;
+/**
+ * Shared implementations for `react-server` and `react-client`
+ */
+export default function createSharedNavigationFns<const AppLocales extends Locales, const AppPathnames extends Pathnames<AppLocales> = never, const AppLocalePrefixMode extends LocalePrefixMode = 'always', const AppDomains extends DomainsConfig<AppLocales> = never>(getLocale: () => PromiseOrValue<Locale>, routing?: [AppPathnames] extends [never] ? RoutingConfigSharedNavigation<AppLocales, AppLocalePrefixMode, AppDomains> | undefined : RoutingConfigLocalizedNavigation<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>): {
+    config: Omit<{}, "localePrefix" | "localeCookie" | "alternateLinks" | "localeDetection"> & {
+        localePrefix: {
+            mode: "never";
+        } | {
+            mode: "always";
+            prefixes?: Partial<Record<string, string>> | undefined;
+        } | {
+            mode: "as-needed";
+            prefixes?: Partial<Record<string, string>> | undefined;
+        };
+        localeCookie: import("../../routing/config.tsx").InitializedLocaleCookieConfig;
+        localeDetection: NonNullable<boolean | undefined>;
+        alternateLinks: NonNullable<boolean | undefined>;
+    };
+    Link: import("react").ForwardRefExoticComponent<Omit<{
+        slot?: string | undefined;
+        style?: import("react").CSSProperties | undefined;
+        title?: string | undefined;
+        locale?: Locale | undefined;
+        onError?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        children?: import("react").ReactNode | undefined;
+        ref?: import("react").LegacyRef<HTMLAnchorElement> | undefined;
+        replace?: boolean | undefined;
+        prefix?: string | undefined;
+        key?: import("react").Key | null | undefined;
+        as?: (string | import("url").UrlObject) | undefined;
+        scroll?: boolean | undefined;
+        shallow?: boolean | undefined;
+        passHref?: boolean | undefined;
+        prefetch?: (boolean | null) | undefined;
+        legacyBehavior?: boolean | undefined;
+        onMouseEnter?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+        onTouchStart?: React.TouchEventHandler<HTMLAnchorElement> | undefined;
+        onClick?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+        download?: any;
+        hrefLang?: string | undefined;
+        media?: string | undefined;
+        ping?: string | undefined;
+        target?: import("react").HTMLAttributeAnchorTarget | undefined;
+        type?: string | undefined;
+        referrerPolicy?: import("react").HTMLAttributeReferrerPolicy | undefined;
+        defaultChecked?: boolean | undefined;
+        defaultValue?: string | number | readonly string[] | undefined;
+        suppressContentEditableWarning?: boolean | undefined;
+        suppressHydrationWarning?: boolean | undefined;
+        accessKey?: string | undefined;
+        autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {});
+        autoFocus?: boolean | undefined;
+        className?: string | undefined;
+        contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+        contextMenu?: string | undefined;
+        dir?: string | undefined;
+        draggable?: (boolean | "true" | "false") | undefined;
+        enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
+        hidden?: boolean | undefined;
+        id?: string | undefined;
+        lang?: string | undefined;
+        nonce?: string | undefined;
+        spellCheck?: (boolean | "true" | "false") | undefined;
+        tabIndex?: number | undefined;
+        translate?: "yes" | "no" | undefined;
+        radioGroup?: string | undefined;
+        role?: import("react").AriaRole | undefined;
+        about?: string | undefined;
+        content?: string | undefined;
+        datatype?: string | undefined;
+        inlist?: any;
+        property?: string | undefined;
+        rel?: string | undefined;
+        resource?: string | undefined;
+        rev?: string | undefined;
+        typeof?: string | undefined;
+        vocab?: string | undefined;
+        autoCorrect?: string | undefined;
+        autoSave?: string | undefined;
+        color?: string | undefined;
+        itemProp?: string | undefined;
+        itemScope?: boolean | undefined;
+        itemType?: string | undefined;
+        itemID?: string | undefined;
+        itemRef?: string | undefined;
+        results?: number | undefined;
+        security?: string | undefined;
+        unselectable?: "on" | "off" | undefined;
+        inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+        is?: string | undefined;
+        popover?: "" | "auto" | "manual" | undefined;
+        popoverTargetAction?: "toggle" | "show" | "hide" | undefined;
+        popoverTarget?: string | undefined;
+        onToggle?: import("react").ToggleEventHandler<HTMLAnchorElement> | undefined;
+        onBeforeToggle?: import("react").ToggleEventHandler<HTMLAnchorElement> | undefined;
+        inert?: boolean | undefined;
+        tw?: string | undefined;
+        "aria-activedescendant"?: string | undefined;
+        "aria-atomic"?: (boolean | "true" | "false") | undefined;
+        "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+        "aria-braillelabel"?: string | undefined;
+        "aria-brailleroledescription"?: string | undefined;
+        "aria-busy"?: (boolean | "true" | "false") | undefined;
+        "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
+        "aria-colcount"?: number | undefined;
+        "aria-colindex"?: number | undefined;
+        "aria-colindextext"?: string | undefined;
+        "aria-colspan"?: number | undefined;
+        "aria-controls"?: string | undefined;
+        "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
+        "aria-describedby"?: string | undefined;
+        "aria-description"?: string | undefined;
+        "aria-details"?: string | undefined;
+        "aria-disabled"?: (boolean | "true" | "false") | undefined;
+        "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+        "aria-errormessage"?: string | undefined;
+        "aria-expanded"?: (boolean | "true" | "false") | undefined;
+        "aria-flowto"?: string | undefined;
+        "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+        "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+        "aria-hidden"?: (boolean | "true" | "false") | undefined;
+        "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+        "aria-keyshortcuts"?: string | undefined;
+        "aria-label"?: string | undefined;
+        "aria-labelledby"?: string | undefined;
+        "aria-level"?: number | undefined;
+        "aria-live"?: "off" | "assertive" | "polite" | undefined;
+        "aria-modal"?: (boolean | "true" | "false") | undefined;
+        "aria-multiline"?: (boolean | "true" | "false") | undefined;
+        "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+        "aria-orientation"?: "horizontal" | "vertical" | undefined;
+        "aria-owns"?: string | undefined;
+        "aria-placeholder"?: string | undefined;
+        "aria-posinset"?: number | undefined;
+        "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
+        "aria-readonly"?: (boolean | "true" | "false") | undefined;
+        "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+        "aria-required"?: (boolean | "true" | "false") | undefined;
+        "aria-roledescription"?: string | undefined;
+        "aria-rowcount"?: number | undefined;
+        "aria-rowindex"?: number | undefined;
+        "aria-rowindextext"?: string | undefined;
+        "aria-rowspan"?: number | undefined;
+        "aria-selected"?: (boolean | "true" | "false") | undefined;
+        "aria-setsize"?: number | undefined;
+        "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+        "aria-valuemax"?: number | undefined;
+        "aria-valuemin"?: number | undefined;
+        "aria-valuenow"?: number | undefined;
+        "aria-valuetext"?: string | undefined;
+        dangerouslySetInnerHTML?: {
+            __html: string | TrustedHTML;
+        } | undefined;
+        onCopy?: import("react").ClipboardEventHandler<HTMLAnchorElement> | undefined;
+        onCopyCapture?: import("react").ClipboardEventHandler<HTMLAnchorElement> | undefined;
+        onCut?: import("react").ClipboardEventHandler<HTMLAnchorElement> | undefined;
+        onCutCapture?: import("react").ClipboardEventHandler<HTMLAnchorElement> | undefined;
+        onPaste?: import("react").ClipboardEventHandler<HTMLAnchorElement> | undefined;
+        onPasteCapture?: import("react").ClipboardEventHandler<HTMLAnchorElement> | undefined;
+        onCompositionEnd?: import("react").CompositionEventHandler<HTMLAnchorElement> | undefined;
+        onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLAnchorElement> | undefined;
+        onCompositionStart?: import("react").CompositionEventHandler<HTMLAnchorElement> | undefined;
+        onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLAnchorElement> | undefined;
+        onCompositionUpdate?: import("react").CompositionEventHandler<HTMLAnchorElement> | undefined;
+        onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLAnchorElement> | undefined;
+        onFocus?: import("react").FocusEventHandler<HTMLAnchorElement> | undefined;
+        onFocusCapture?: import("react").FocusEventHandler<HTMLAnchorElement> | undefined;
+        onBlur?: import("react").FocusEventHandler<HTMLAnchorElement> | undefined;
+        onBlurCapture?: import("react").FocusEventHandler<HTMLAnchorElement> | undefined;
+        onChange?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
+        onChangeCapture?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
+        onBeforeInput?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
+        onBeforeInputCapture?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
+        onInput?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
+        onInputCapture?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
+        onReset?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
+        onResetCapture?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
+        onSubmit?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
+        onSubmitCapture?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
+        onInvalid?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
+        onInvalidCapture?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
+        onLoad?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onErrorCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onKeyDown?: import("react").KeyboardEventHandler<HTMLAnchorElement> | undefined;
+        onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLAnchorElement> | undefined;
+        onKeyPress?: import("react").KeyboardEventHandler<HTMLAnchorElement> | undefined;
+        onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLAnchorElement> | undefined;
+        onKeyUp?: import("react").KeyboardEventHandler<HTMLAnchorElement> | undefined;
+        onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLAnchorElement> | undefined;
+        onAbort?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onAbortCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onCanPlay?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onCanPlayCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onCanPlayThrough?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onDurationChange?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onDurationChangeCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onEmptied?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onEmptiedCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onEncrypted?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onEncryptedCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onEnded?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onEndedCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadedData?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadedDataCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadedMetadata?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadStart?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onLoadStartCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onPause?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onPauseCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onPlay?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onPlayCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onPlaying?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onPlayingCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onProgress?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onProgressCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onRateChange?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onRateChangeCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onResize?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onResizeCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSeeked?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSeekedCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSeeking?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSeekingCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onStalled?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onStalledCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSuspend?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSuspendCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onTimeUpdate?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onVolumeChange?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onWaiting?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onWaitingCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onAuxClick?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onAuxClickCapture?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onClickCapture?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onContextMenu?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onContextMenuCapture?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onDoubleClick?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onDoubleClickCapture?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onDrag?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragCapture?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragEnd?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragEndCapture?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragEnter?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragEnterCapture?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragExit?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragExitCapture?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragLeave?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragLeaveCapture?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragOver?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragOverCapture?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragStart?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDragStartCapture?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDrop?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onDropCapture?: import("react").DragEventHandler<HTMLAnchorElement> | undefined;
+        onMouseDown?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseDownCapture?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseLeave?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseMove?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseMoveCapture?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseOut?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseOutCapture?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseOver?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseOverCapture?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseUp?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseUpCapture?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+        onSelect?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onSelectCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
+        onTouchCancel?: import("react").TouchEventHandler<HTMLAnchorElement> | undefined;
+        onTouchCancelCapture?: import("react").TouchEventHandler<HTMLAnchorElement> | undefined;
+        onTouchEnd?: import("react").TouchEventHandler<HTMLAnchorElement> | undefined;
+        onTouchEndCapture?: import("react").TouchEventHandler<HTMLAnchorElement> | undefined;
+        onTouchMove?: import("react").TouchEventHandler<HTMLAnchorElement> | undefined;
+        onTouchMoveCapture?: import("react").TouchEventHandler<HTMLAnchorElement> | undefined;
+        onTouchStartCapture?: import("react").TouchEventHandler<HTMLAnchorElement> | undefined;
+        onPointerDown?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerDownCapture?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerMove?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerMoveCapture?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerUp?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerUpCapture?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerCancel?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerCancelCapture?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerEnter?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerLeave?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerOver?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerOverCapture?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerOut?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onPointerOutCapture?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onGotPointerCapture?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onLostPointerCapture?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
+        onScroll?: import("react").UIEventHandler<HTMLAnchorElement> | undefined;
+        onScrollCapture?: import("react").UIEventHandler<HTMLAnchorElement> | undefined;
+        onWheel?: import("react").WheelEventHandler<HTMLAnchorElement> | undefined;
+        onWheelCapture?: import("react").WheelEventHandler<HTMLAnchorElement> | undefined;
+        onAnimationStart?: import("react").AnimationEventHandler<HTMLAnchorElement> | undefined;
+        onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLAnchorElement> | undefined;
+        onAnimationEnd?: import("react").AnimationEventHandler<HTMLAnchorElement> | undefined;
+        onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLAnchorElement> | undefined;
+        onAnimationIteration?: import("react").AnimationEventHandler<HTMLAnchorElement> | undefined;
+        onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLAnchorElement> | undefined;
+        onTransitionEnd?: import("react").TransitionEventHandler<HTMLAnchorElement> | undefined;
+        onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLAnchorElement> | undefined;
+        onTransitionCancel?: import("react").TransitionEventHandler<HTMLAnchorElement> | undefined;
+        onTransitionCancelCapture?: import("react").TransitionEventHandler<HTMLAnchorElement> | undefined;
+        onTransitionRun?: import("react").TransitionEventHandler<HTMLAnchorElement> | undefined;
+        onTransitionRunCapture?: import("react").TransitionEventHandler<HTMLAnchorElement> | undefined;
+        onTransitionStart?: import("react").TransitionEventHandler<HTMLAnchorElement> | undefined;
+        onTransitionStartCapture?: import("react").TransitionEventHandler<HTMLAnchorElement> | undefined;
+        href: [AppPathnames] extends [never] ? string | import("url").UrlObject : keyof AppPathnames extends infer T ? T extends keyof AppPathnames ? T extends `${string}[[...${string}` ? T | ({
+            pathname: T;
+            params?: import("./StrictParams.tsx").default<T> | undefined;
+        } & Omit<import("url").UrlObject, "pathname">) : T extends `${string}[${string}` ? {
+            pathname: T;
+            params: import("./StrictParams.tsx").default<T>;
+        } & Omit<import("url").UrlObject, "pathname"> : T | ({
+            pathname: T;
+        } & Omit<import("url").UrlObject, "pathname">) : never : never;
+    }, "ref"> & import("react").RefAttributes<HTMLAnchorElement>>;
+    redirect: (args: Omit<Parameters<(args: {
+        /** @see https://next-intl-docs.vercel.app/docs/routing/navigation#getpathname */
+        href: [AppPathnames] extends [never] ? string | {
+            pathname: string;
+            query?: QueryParams;
+        } : HrefOrHrefWithParams<keyof AppPathnames>;
+        locale: Locale;
+    } & (([AppPathnames] extends [never] ? RoutingConfigSharedNavigation<AppLocales, AppLocalePrefixMode, AppDomains> | undefined : RoutingConfigLocalizedNavigation<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>) | undefined extends undefined ? {} : AppLocalePrefixMode extends "as-needed" ? [AppDomains] extends [never] ? {} : {
+        /**
+         * In case you're using `localePrefix: 'as-needed'` in combination with `domains`, the `defaultLocale` can differ by domain and therefore the locales that need to be prefixed can differ as well. For this particular case, this parameter should be provided in order to compute the correct pathname. Note that the actual domain is not part of the result, but only the pathname is returned.
+         * @see https://next-intl-docs.vercel.app/docs/routing/navigation#getpathname
+         */
+        domain: AppDomains[number]["domain"];
+    } : {}), _forcePrefix?: boolean) => string>[0], "domain"> & Partial<([AppPathnames] extends [never] ? RoutingConfigSharedNavigation<AppLocales, AppLocalePrefixMode, AppDomains> | undefined : RoutingConfigLocalizedNavigation<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>) | undefined extends undefined ? {} : AppLocalePrefixMode extends "as-needed" ? [AppDomains] extends [never] ? {} : {
+        /**
+         * In case you're using `localePrefix: 'as-needed'` in combination with `domains`, the `defaultLocale` can differ by domain and therefore the locales that need to be prefixed can differ as well. For this particular case, this parameter should be provided in order to compute the correct pathname. Note that the actual domain is not part of the result, but only the pathname is returned.
+         * @see https://next-intl-docs.vercel.app/docs/routing/navigation#getpathname
+         */
+        domain: AppDomains[number]["domain"];
+    } : {}>, type?: import("next/navigation.js").RedirectType | undefined) => never;
+    permanentRedirect: (args: Omit<Parameters<(args: {
+        /** @see https://next-intl-docs.vercel.app/docs/routing/navigation#getpathname */
+        href: [AppPathnames] extends [never] ? string | {
+            pathname: string;
+            query?: QueryParams;
+        } : HrefOrHrefWithParams<keyof AppPathnames>;
+        locale: Locale;
+    } & (([AppPathnames] extends [never] ? RoutingConfigSharedNavigation<AppLocales, AppLocalePrefixMode, AppDomains> | undefined : RoutingConfigLocalizedNavigation<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>) | undefined extends undefined ? {} : AppLocalePrefixMode extends "as-needed" ? [AppDomains] extends [never] ? {} : {
+        /**
+         * In case you're using `localePrefix: 'as-needed'` in combination with `domains`, the `defaultLocale` can differ by domain and therefore the locales that need to be prefixed can differ as well. For this particular case, this parameter should be provided in order to compute the correct pathname. Note that the actual domain is not part of the result, but only the pathname is returned.
+         * @see https://next-intl-docs.vercel.app/docs/routing/navigation#getpathname
+         */
+        domain: AppDomains[number]["domain"];
+    } : {}), _forcePrefix?: boolean) => string>[0], "domain"> & Partial<([AppPathnames] extends [never] ? RoutingConfigSharedNavigation<AppLocales, AppLocalePrefixMode, AppDomains> | undefined : RoutingConfigLocalizedNavigation<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>) | undefined extends undefined ? {} : AppLocalePrefixMode extends "as-needed" ? [AppDomains] extends [never] ? {} : {
+        /**
+         * In case you're using `localePrefix: 'as-needed'` in combination with `domains`, the `defaultLocale` can differ by domain and therefore the locales that need to be prefixed can differ as well. For this particular case, this parameter should be provided in order to compute the correct pathname. Note that the actual domain is not part of the result, but only the pathname is returned.
+         * @see https://next-intl-docs.vercel.app/docs/routing/navigation#getpathname
+         */
+        domain: AppDomains[number]["domain"];
+    } : {}>, type?: import("next/navigation.js").RedirectType | undefined) => never;
+    getPathname: (args: Parameters<(args: {
+        /** @see https://next-intl-docs.vercel.app/docs/routing/navigation#getpathname */
+        href: [AppPathnames] extends [never] ? string | {
+            pathname: string;
+            query?: QueryParams;
+        } : HrefOrHrefWithParams<keyof AppPathnames>;
+        locale: Locale;
+    } & (([AppPathnames] extends [never] ? RoutingConfigSharedNavigation<AppLocales, AppLocalePrefixMode, AppDomains> | undefined : RoutingConfigLocalizedNavigation<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>) | undefined extends undefined ? {} : AppLocalePrefixMode extends "as-needed" ? [AppDomains] extends [never] ? {} : {
+        /**
+         * In case you're using `localePrefix: 'as-needed'` in combination with `domains`, the `defaultLocale` can differ by domain and therefore the locales that need to be prefixed can differ as well. For this particular case, this parameter should be provided in order to compute the correct pathname. Note that the actual domain is not part of the result, but only the pathname is returned.
+         * @see https://next-intl-docs.vercel.app/docs/routing/navigation#getpathname
+         */
+        domain: AppDomains[number]["domain"];
+    } : {}), _forcePrefix?: boolean) => string>[0]) => string;
+};
+export {};

package/dist/types/{src/navigation → navigation}/shared/syncLocaleCookie.d.ts

@@ -1,7 +1,8 @@
-import { InitializedLocaleCookieConfig } from '../../routing/config';
+import type { Locale } from 'use-intl';
+import type { InitializedLocaleCookieConfig } from '../../routing/config.tsx';
 /**
  * We have to keep the cookie value in sync as Next.js might
  * skip a request to the server due to its router cache.
  * See https://github.com/amannn/next-intl/issues/786.
  */
-export default function syncLocaleCookie(localeCookie: InitializedLocaleCookieConfig, pathname: string | null, locale: string, nextLocale?: string): void;
+export default function syncLocaleCookie(localeCookie: InitializedLocaleCookieConfig, pathname: string | null, locale: Locale, nextLocale?: Locale): void;

package/dist/types/{src/navigation → navigation}/shared/utils.d.ts

@@ -1,8 +1,9 @@
 import type { ParsedUrlQueryInput } from 'node:querystring';
 import type { UrlObject } from 'url';
-import { ResolvedRoutingConfig } from '../../routing/config';
-import { DomainsConfig, LocalePrefixMode, Locales, Pathnames } from '../../routing/types';
-import StrictParams from './StrictParams';
+import type { Locale } from 'use-intl';
+import type { ResolvedRoutingConfig } from '../../routing/config.tsx';
+import type { DomainsConfig, LocalePrefixMode, Locales, Pathnames } from '../../routing/types.tsx';
+import type StrictParams from './StrictParams.tsx';
 type SearchParamValue = ParsedUrlQueryInput[keyof ParsedUrlQueryInput];
 type HrefOrHrefWithParamsImpl<Pathname, Other> = Pathname extends `${string}[[...${string}` ? // Optional catch-all
 Pathname | ({
@@ -22,7 +23,7 @@ export type HrefOrHrefWithParams<Pathname> = HrefOrHrefWithParamsImpl<Pathname,
     query?: QueryParams;
 }>;
 export declare function normalizeNameOrNameWithParams<Pathname>(href: HrefOrHrefWithParams<Pathname> | {
-    locale: string;
+    locale: Locale;
     href: HrefOrHrefWithParams<Pathname>;
 }): {
     pathname: Pathname;

package/dist/types/navigation.react-client.d.ts

@@ -0,0 +1 @@
+export * from './navigation/react-client/index.tsx';

package/dist/types/navigation.react-server.d.ts

@@ -0,0 +1 @@
+export * from './navigation/react-server/index.tsx';

package/dist/types/plugin/createMessagesDeclaration.d.ts

@@ -0,0 +1 @@
+export default function createMessagesDeclaration(messagesPath: string): void;

package/dist/types/plugin/createNextIntlPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { NextConfig } from 'next';
+import type { PluginConfig } from './types.tsx';
+export default function createNextIntlPlugin(i18nPathOrConfig?: string | PluginConfig): (nextConfig?: NextConfig) => NextConfig;

package/dist/types/plugin/getNextConfig.d.ts

@@ -0,0 +1,3 @@
+import type { NextConfig } from 'next';
+import type { PluginConfig } from './types.tsx';
+export default function getNextConfig(pluginConfig: PluginConfig, nextConfig?: NextConfig): NextConfig & Partial<NextConfig>;

package/dist/types/plugin/index.d.ts

@@ -0,0 +1 @@
+export { default } from './createNextIntlPlugin.tsx';

package/dist/types/plugin/types.d.ts

@@ -0,0 +1,6 @@
+export type PluginConfig = {
+    requestConfig?: string;
+    experimental?: {
+        createMessagesDeclaration?: string;
+    };
+};

package/dist/types/plugin/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function throwError(message: string): never;
+export declare function warn(message: string): void;

package/dist/types/plugin.d.ts

@@ -0,0 +1 @@
+export { default } from './plugin/index.tsx';

package/dist/types/{src/react-client → react-client}/index.d.ts

@@ -11,5 +11,4 @@ import { useFormatter as base_useFormatter, useTranslations as base_useTranslati
 export * from 'use-intl';
 export declare const useTranslations: typeof base_useTranslations;
 export declare const useFormatter: typeof base_useFormatter;
-export { default as useLocale } from './useLocale';
-export { default as NextIntlClientProvider } from '../shared/NextIntlClientProvider';
+export { default as NextIntlClientProvider } from '../shared/NextIntlClientProvider.tsx';

package/dist/types/react-server/NextIntlClientProviderServer.d.ts

@@ -0,0 +1,5 @@
+import type { ComponentProps } from 'react';
+import BaseNextIntlClientProvider from '../shared/NextIntlClientProvider.tsx';
+type Props = ComponentProps<typeof BaseNextIntlClientProvider>;
+export default function NextIntlClientProviderServer({ formats, locale, now, timeZone, ...rest }: Props): Promise<import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/types/react-server/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This is the main entry file when 'react-server' environments
+ * (i.e. RSC) import from 'next-intl'. Currently we export everything
+ * from `use-intl` core, but React-APIs are stubbed out.
+ *
+ * Make sure this mirrors the API from '../react-client'.
+ */
+export { default as useLocale } from './useLocale.tsx';
+export { default as useTranslations } from './useTranslations.tsx';
+export { default as useFormatter } from './useFormatter.tsx';
+export { default as useNow } from './useNow.tsx';
+export { default as useTimeZone } from './useTimeZone.tsx';
+export { default as useMessages } from './useMessages.tsx';
+export { default as NextIntlClientProvider } from './NextIntlClientProviderServer.tsx';
+export * from 'use-intl/core';

package/dist/types/{src/react-server → react-server}/testUtils.d.ts

@@ -1,2 +1,2 @@
-import { ReactNode } from 'react';
+import { type ReactNode } from 'react';
 export declare function renderToStream(children: ReactNode): Promise<string>;

package/dist/types/{src/react-server → react-server}/useConfig.d.ts

@@ -1,2 +1,2 @@
-import getConfig from '../server/react-server/getConfig';
+import getConfig from '../server/react-server/getConfig.tsx';
 export default function useConfig(hookName: string): Awaited<ReturnType<typeof getConfig>>;

package/dist/types/react-server/useFormatter.d.ts

@@ -0,0 +1,2 @@
+import type { useFormatter as useFormatterType } from 'use-intl';
+export default function useFormatter(): ReturnType<typeof useFormatterType>;

package/dist/types/react-server/useLocale.d.ts

@@ -0,0 +1,2 @@
+import type { useLocale as useLocaleType } from 'use-intl';
+export default function useLocale(): ReturnType<typeof useLocaleType>;

package/dist/types/react-server/useMessages.d.ts

@@ -0,0 +1,2 @@
+import type { useMessages as useMessagesType } from 'use-intl';
+export default function useMessages(): ReturnType<typeof useMessagesType>;

package/dist/types/react-server/useNow.d.ts

@@ -0,0 +1,2 @@
+import type { useNow as useNowType } from 'use-intl';
+export default function useNow(options?: Parameters<typeof useNowType>[0]): ReturnType<typeof useNowType>;

package/dist/types/react-server/useTimeZone.d.ts

@@ -0,0 +1,2 @@
+import type { useTimeZone as useTimeZoneType } from 'use-intl';
+export default function useTimeZone(): ReturnType<typeof useTimeZoneType>;

package/dist/types/{src/routing → routing}/config.d.ts

@@ -1,5 +1,5 @@
-import type { NextResponse } from 'next/server';
-import { DomainsConfig, LocalePrefix, LocalePrefixConfigVerbose, LocalePrefixMode, Locales, Pathnames } from './types';
+import type { NextResponse } from 'next/server.js';
+import type { DomainsConfig, LocalePrefix, LocalePrefixConfigVerbose, LocalePrefixMode, Locales, Pathnames } from './types.tsx';
 type CookieAttributes = Pick<NonNullable<Parameters<typeof NextResponse.prototype.cookies.set>['2']>, 'maxAge' | 'domain' | 'partitioned' | 'path' | 'priority' | 'sameSite' | 'secure' | 'name'>;
 export type RoutingConfig<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode, AppPathnames extends Pathnames<AppLocales> | undefined, AppDomains extends DomainsConfig<AppLocales> | undefined> = {
     /**
@@ -68,8 +68,6 @@ export declare function receiveRoutingConfig<AppLocales extends Locales, AppLoca
     localeDetection: boolean | NonNullable<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>["localeDetection"]>;
     alternateLinks: boolean | NonNullable<RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>["alternateLinks"]>;
 };
-export declare function receiveLocaleCookie(localeCookie?: boolean | CookieAttributes): InitializedLocaleCookieConfig;
 export type InitializedLocaleCookieConfig = false | LocaleCookieConfig;
 export type LocaleCookieConfig = Omit<CookieAttributes, 'name' | 'maxAge' | 'sameSite'> & Required<Pick<CookieAttributes, 'name' | 'maxAge' | 'sameSite'>>;
-export declare function receiveLocalePrefixConfig<AppLocales extends Locales, AppLocalePrefixMode extends LocalePrefixMode>(localePrefix?: LocalePrefix<AppLocales, AppLocalePrefixMode>): LocalePrefixConfigVerbose<AppLocales, AppLocalePrefixMode>;
 export {};

package/dist/types/{src/routing → routing}/defineRouting.d.ts

@@ -1,3 +1,3 @@
-import { RoutingConfig } from './config';
-import { DomainsConfig, LocalePrefixMode, Locales, Pathnames } from './types';
+import type { RoutingConfig } from './config.tsx';
+import type { DomainsConfig, LocalePrefixMode, Locales, Pathnames } from './types.tsx';
 export default function defineRouting<const AppLocales extends Locales, const AppLocalePrefixMode extends LocalePrefixMode = 'always', const AppPathnames extends Pathnames<AppLocales> = never, const AppDomains extends DomainsConfig<AppLocales> = never>(config: RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>): RoutingConfig<AppLocales, AppLocalePrefixMode, AppPathnames, AppDomains>;

package/dist/types/routing/index.d.ts

@@ -0,0 +1,3 @@
+export type { Pathnames, LocalePrefix, DomainsConfig, LocalePrefixMode } from './types.tsx';
+export { default as defineRouting } from './defineRouting.tsx';
+export type { RoutingConfig } from './config.tsx';

package/dist/types/routing.d.ts

@@ -0,0 +1 @@
+export * from './routing/index.tsx';

package/dist/types/{src/server → server}/react-client/index.d.ts

@@ -1,4 +1,4 @@
-import type { getFormatter as getFormatter_type, getLocale as getLocale_type, getMessages as getMessages_type, getNow as getNow_type, getRequestConfig as getRequestConfig_type, getTimeZone as getTimeZone_type, setRequestLocale as setRequestLocale_type, unstable_setRequestLocale as unstable_setRequestLocale_type } from '../react-server';
+import type { getFormatter as getFormatter_type, getLocale as getLocale_type, getMessages as getMessages_type, getNow as getNow_type, getRequestConfig as getRequestConfig_type, getTimeZone as getTimeZone_type, setRequestLocale as setRequestLocale_type } from '../react-server/index.tsx';
 export declare function getRequestConfig(...args: Parameters<typeof getRequestConfig_type>): ReturnType<typeof getRequestConfig_type>;
 export declare const getFormatter: typeof getFormatter_type;
 export declare const getNow: typeof getNow_type;
@@ -6,5 +6,4 @@ export declare const getTimeZone: typeof getTimeZone_type;
 export declare const getMessages: typeof getMessages_type;
 export declare const getLocale: typeof getLocale_type;
 export declare const getTranslations: () => never;
-export declare const unstable_setRequestLocale: typeof unstable_setRequestLocale_type;
 export declare const setRequestLocale: typeof setRequestLocale_type;

package/dist/types/server/react-server/RequestLocaleCache.d.ts

@@ -0,0 +1,3 @@
+import type { Locale } from 'use-intl';
+export declare function getCachedRequestLocale(): string | undefined;
+export declare function setCachedRequestLocale(locale: Locale): void;

package/dist/types/{src/server → server}/react-server/createRequestConfig.d.ts

@@ -1,3 +1,3 @@
-import type { GetRequestConfigParams, RequestConfig } from './getRequestConfig';
+import type { GetRequestConfigParams, RequestConfig } from './getRequestConfig.tsx';
 declare const _default: (params: GetRequestConfigParams) => RequestConfig | Promise<RequestConfig>;
 export default _default;

package/dist/types/{src/server → server}/react-server/getConfig.d.ts

@@ -1,7 +1,6 @@
-import { IntlConfig, _createIntlFormatters } from 'use-intl/core';
-declare function getConfigImpl(localeOverride?: string): Promise<IntlConfig & {
+import { type IntlConfig, type Locale, _createIntlFormatters } from 'use-intl/core';
+declare function getConfigImpl(localeOverride?: Locale): Promise<IntlConfig & {
     getMessageFallback: NonNullable<IntlConfig['getMessageFallback']>;
-    now: NonNullable<IntlConfig['now']>;
     onError: NonNullable<IntlConfig['onError']>;
     timeZone: NonNullable<IntlConfig['timeZone']>;
     _formatters: ReturnType<typeof _createIntlFormatters>;

package/dist/types/server/react-server/getConfigNow.d.ts

@@ -0,0 +1,4 @@
+import type { Locale } from 'use-intl';
+declare function getConfigNowImpl(locale?: Locale): Promise<Date | undefined>;
+declare const getConfigNow: typeof getConfigNowImpl;
+export default getConfigNow;

package/dist/types/server/react-server/getDefaultNow.d.ts

@@ -0,0 +1,3 @@
+declare function defaultNow(): Date;
+declare const getDefaultNow: typeof defaultNow;
+export default getDefaultNow;