react-i18next

const FlatNamespace: any;

const FlatNamespace: any;

const I18nContext: React.Context<{ i18n: i18n }>;

const I18nextProvider: React.FunctionComponent<I18nextProviderProps>;

const IcuTrans: IcuTransComponent;

const IcuTransWithoutContext: IcuTransWithoutContextComponent;

const initReactI18next: ThirdPartyModule;

const Key: any;

const Key: any;

const KeyPrefix: any;

const KeyPrefixSelector: any;

const KPrefix: any;

const KPrefix: any;

const KPrefix: any;

const Ns: any;

const Ns: any;

const ParseKeys: any;

const ParseKeys: any;

const Trans: TransSelector | TransLegacy;

const TransWithoutContext: TransSelector | TransLegacy;

const useTranslation: UseTranslationLegacy;

composeInitialProps: (ForComponent: any) => (ctx: unknown) => Promise<any>;

getDefaults: () => ReactOptions;

getI18n: () => i18n;

getInitialProps: () => {
    initialI18nStore: { [ns: string]: {} };
    initialLanguage: string;
};

nodesToString: (
    children: React.ReactNode,
    i18nOptions?: ReactOptions,
    i18n?: i18n,
    i18nKey?: string
) => string;

setDefaults: (options: ReactOptions) => void;

setI18n: (instance: i18n) => void;

Translation: <
    Ns extends unknown = undefined,
    KPrefix extends KeyPrefix<FallbackNs<Ns>> = undefined
>(
    props: TranslationProps<Ns, KPrefix>
) => any;

useSSR: (initialI18nStore: Resource, initialLanguage: string) => void;

withSSR: () => <Props>(WrappedComponent: React.ComponentType<Props>) => {
    ({
        initialI18nStore,
        initialLanguage,
        ...rest
    }: {
        initialI18nStore: Resource;
        initialLanguage: string;
    } & Props): React.FunctionComponentElement<Props>;
    getInitialProps: (ctx: unknown) => Promise<any>;
};

withTranslation: <
    Ns extends unknown = undefined,
    KPrefix extends KeyPrefix<FallbackNs<Ns>> = undefined
>(
    ns?: Ns,
    options?: { withRef?: boolean; keyPrefix?: KPrefix }
) => <
    C extends React.ComponentType<any>,
    ResolvedProps = React.JSX.LibraryManagedAttributes<
        C,
        $Subtract<React.ComponentProps<C>, WithTranslationProps>
    >
>(
    component: C
) => React.ComponentType<
    Omit<ResolvedProps, keyof WithTranslation<Ns, undefined>> & WithTranslationProps
>;

type ErrorArgs = readonly [string, ErrorMeta | undefined, ...any[]];

type ErrorCode =
    | 'NO_I18NEXT_INSTANCE'
    | 'NO_LANGUAGES'
    | 'DEPRECATED_OPTION'
    | 'TRANS_NULL_VALUE'
    | 'TRANS_INVALID_OBJ'
    | 'TRANS_INVALID_VAR'
    | 'TRANS_INVALID_COMPONENTS'
    | 'USE_T_BEFORE_READY'
    | 'SUSPENDED_WHILE_LOADING';

type FallbackNs<Ns> = Ns extends undefined
    ? _DefaultNamespace
    : Ns extends Namespace
    ? Ns
    : _DefaultNamespace;

type IcuTransProps<
    Key extends ParseKeys<Ns, TOpt, KPrefix>,
    Ns extends Namespace = _DefaultNamespace,
    KPrefix = undefined,
    TContext extends string | undefined = undefined,
    TOpt extends TOptions & { context?: TContext } = { context: TContext }
> = IcuTransWithoutContextProps<Key, Ns, KPrefix, TContext, TOpt>;

type IcuTransWithoutContextProps<
    Key extends ParseKeys<Ns, TOpt, KPrefix>,
    Ns extends Namespace = _DefaultNamespace,
    KPrefix = undefined,
    TContext extends string | undefined = undefined,
    TOpt extends TOptions & { context?: TContext } = { context: TContext }
> = {
    /** The i18n key to look up the translation */
    i18nKey: Key;
    /** The default translation in ICU format with numbered tags (e.g., "<0>Click here</0>") */
    defaultTranslation: string;
    /** Declaration tree describing React components and their props */
    content: IcuTransContentDeclaration[];
    /** Optional namespace(s) for the translation */
    // see TransProps.ns: keep single-namespace values assignable when `t` fixes Ns to an array
    ns?: Ns | (Ns extends readonly (infer S extends string)[] ? S : never);
    /**
     * Values for ICU variable interpolation. Under `parseInterpolation: 'icu'`
     * (or `'mf2'`) they are typed from the message.
     */
    values?: [TypeOptions['parseInterpolation']] extends ['icu'] | ['mf2']
        ? InterpolationMap<
              TFunctionReturn<
                  Ns,
                  KPrefix extends string
                      ? `${KPrefix}${TypeOptions['keySeparator']}${Key & string}`
                      : Key,
                  TOpt
              >
          >
        : Record<string, any>;
    /** i18next instance. If not provided, uses global instance */
    i18n?: i18n;
    /** Custom translation function */
    t?: TFunction<Ns, KPrefix>;
};

type TransProps<
    Key extends ParseKeys<Ns, TOpt, KPrefix>,
    Ns extends Namespace = _DefaultNamespace,
    KPrefix = undefined,
    TContext extends string | undefined = undefined,
    TOpt extends TOptions & { context?: TContext } = { context: TContext },
    E = React.HTMLProps<HTMLDivElement>
> = E & {
    children?: TransChild | readonly TransChild[];
    components?:
        | readonly React.ReactElement[]
        | { readonly [tagName: string]: React.ReactElement };
    count?: number;
    context?: TContext;
    defaults?: string;
    i18n?: i18n;
    i18nKey?: Key | Key[];
    // allow a single namespace from an array-typed `t` (e.g. useTranslation(['ns'])); TS7 intersects
    // inference candidates from `t` and `ns`, so a bare `Ns` here rejects ns="ns" when t is passed
    ns?: Ns | (Ns extends readonly (infer S extends string)[] ? S : never);
    parent?: string | React.ComponentType<any> | null; // used in React.createElement if not null
    tOptions?: TOpt;
    // keep the return type inside this property: as a type parameter of `Trans`, it was also
    // computed for every key of the namespace, which is slow with large resources
    values?: InterpolationMap<
        TFunctionReturn<Ns, _AppendKeyPrefix<Key, KPrefix>, TOpt>
    >;
    shouldUnescape?: boolean;
    t?: TFunction<Ns, KPrefix>;
};

type UseTranslationOptions<KPrefix> = {
    i18n?: i18n;
    useSuspense?: boolean;
    keyPrefix?: KPrefix;
    bindI18n?: string | false;
    nsMode?: 'fallback' | 'default';
    lng?: string;
    // other of these options might also work: https://github.com/i18next/i18next/blob/master/index.d.ts#L127
};

type UseTranslationResponse<Ns extends Namespace, KPrefix> = [
    t: TFunction<Ns, KPrefix>,
    i18n: i18n,
    ready: boolean
] & {
    t: TFunction<Ns, KPrefix>;
    i18n: i18n;
    ready: boolean;
};