react-i18next

const FlatNamespace: any;

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

const I18nextProvider: React.FunctionComponent<I18nextProviderProps>;

const initReactI18next: ThirdPartyModule;

const KeyPrefix: any;

const KPrefix: any;

const Ns: any;

const TransWithoutContext: <
    Key extends ParseKeys<Ns, TOpt, KPrefix>,
    Ns extends Namespace = TypeOptions,
    KPrefix = undefined,
    TContext extends string = undefined,
    TOpt extends unknown = { context: TContext },
    E = React.HTMLProps<HTMLDivElement>
>(
    props: TransProps<Key, Ns, KPrefix, TContext, TOpt, E>
) => React.ReactElement;

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

getDefaults: () => ReactOptions;

getI18n: () => i18n;

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

setDefaults: (options: ReactOptions) => void;

setI18n: (instance: i18n) => void;

Trans: <
    Key extends ParseKeys<Ns, TOpt, KPrefix>,
    Ns extends Namespace = TypeOptions,
    KPrefix = undefined,
    TContext extends string = undefined,
    TOpt extends unknown = { context: TContext },
    E = React.HTMLProps<HTMLDivElement>
>(
    props: TransProps<Key, Ns, KPrefix, TContext, TOpt, E>
) => React.ReactElement;

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

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

useTranslation: () => any;

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';

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

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[];
    ns?: Ns;
    parent?: string | React.ComponentType<any> | null; // used in React.createElement if not null
    tOptions?: TOpt;
    values?: {};
    shouldUnescape?: boolean;
    t?: TFunction<Ns, KPrefix>;
};

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