/// <reference types="react" />
/// <reference types="node" />
import React$1 from 'react';
import { FieldInputProps, FormikProps } from 'formik';
import { SelectChangeEvent, SxProps, Theme } from '@mui/material';
import { ParsedUrlQuery } from 'querystring';

type UseUiHidableProps = {
    key: string;
    defaultValue?: boolean;
};
declare const useUIHidable: (props: UseUiHidableProps) => {
    hide: () => any;
    show: () => any;
    toggle: () => any;
    visible: boolean;
};

type ClientOnlyProps = {
    children: React$1.ReactNode;
};
declare const ClientOnly: React$1.FC<ClientOnlyProps>;

declare function useLocalStorage<ValueType>(key: string, defaultValue: ValueType): any[];

type CustomSetProps<T = any> = {
    onChange: ({ value, event, }: {
        value: T;
        event?: React.ChangeEvent | SelectChangeEvent<any>;
    }) => void;
    onTouched?: (value?: boolean) => void;
};
type AdvancedFieldProps<T = any> = FieldInputProps<T> & {
    helperText?: any;
    error?: boolean;
};
type CustomFieldProps<T = any> = Omit<AdvancedFieldProps<T>, 'onChange'> & CustomSetProps<T>;

declare class FormikHelper<T> {
    formik: FormikProps<T>;
    constructor(formik: FormikProps<T>);
    HasErrorTouched(field: string): boolean;
    GetFieldPropsCustom(field: string): CustomFieldProps;
    GetFieldPropsCustomSet(field: string): CustomSetProps;
    GetFieldPropsAdvanced(field: string): AdvancedFieldProps;
    GetHelperText(field: string): Pick<AdvancedFieldProps, 'helperText' | 'error'>;
}

declare const useFormikHelper: <T>(formik: FormikProps<T>) => FormikHelper<T>;

declare class AnchorScroller {
    /**
     *
     */
    private _url?;
    private _anchorPosition;
    constructor();
    scrollToAnchorIfExists(): void;
    getAnchorElementId(): string | null;
    private getAnchorPosition;
}

type UseAnchorScrollProps = {
    timeoutMs?: number;
};
declare const useAnchorScroll: (props?: UseAnchorScrollProps | undefined) => void;

type QueryParamType = 'string' | 'string?' | 'string[]' | 'number' | 'number?' | 'number[]';
type ReturnValueEntry<TInQueryParamType extends QueryParamType> = TInQueryParamType extends 'number' ? number : TInQueryParamType extends 'number?' ? number | undefined : TInQueryParamType extends 'number[]' ? number[] : TInQueryParamType extends 'string' ? string : TInQueryParamType extends 'string?' ? string | undefined : TInQueryParamType extends 'string[]' ? string | undefined : unknown;
type QueryType = ParsedUrlQuery[0];
type ReturnValue<TQueryParamsObject extends Record<string, QueryParamType>, TNullable extends boolean = false> = {
    [TKey in keyof TQueryParamsObject]: TNullable extends true ? undefined | ReturnValueEntry<TQueryParamsObject[TKey]> : ReturnValueEntry<TQueryParamsObject[TKey]>;
};
type UseQueryParametersProps<TQueryParamsObject extends Record<string, QueryParamType>, TNullable extends boolean> = {
    params: TQueryParamsObject;
    options?: {
        allowNullable: TNullable;
        onError?: (error: Error) => void;
    };
};

declare class QueryParamsValidator {
    private query;
    /**
     *
     */
    constructor(query: ParsedUrlQuery);
    reduceValues<T extends Record<string, QueryParamType>, TNullable extends boolean>({ params, }: UseQueryParametersProps<T, TNullable>): ReturnValue<T, TNullable> & {
        errors: string[];
    };
}

declare const useQueryParams: <T extends Record<string, QueryParamType>, TNullable extends boolean = false>({ params, options, query }: UseQueryParametersProps<T, TNullable> & {
    query: ParsedUrlQuery;
}) => ReturnValue<T, TNullable> & {
    errors: string[];
};

declare const parseNumberNullable: (value?: string) => number | undefined;

type SeoTagsType = {
    meta?: {
        title?: string | null;
        description?: string | null;
        keywords?: string | null;
    };
    og?: {
        title?: string | null;
        image?: string | null;
        url?: string | null;
        type?: string | null;
        description?: string | null;
    };
    twitter?: {
        card?: string | null;
        domain?: string | null;
        url?: string | null;
        title?: string | null;
        description?: string | null;
        image?: string | null;
    };
};
type SeoTagsProps = {
    meta?: SeoTagsType['meta'];
    og?: SeoTagsType['og'];
    twitter?: SeoTagsType['twitter'];
};
type CommonSiteSeoTags = {
    title: string;
    description: string;
    keywords: string;
    ogImage: string;
    ogType: string;
    ogUrl: string;
    domain: string;
};

declare const getCommonSeoTags: (meta: CommonSiteSeoTags) => SeoTagsProps;
declare const SeoTagsCommon: React$1.FC<{
    meta: CommonSiteSeoTags;
}>;
declare const SeoTags: React$1.FC<SeoTagsProps>;

type ComponentStyles = {
    [key: string]: SxProps<Theme>;
};

type PartialRecord<K extends keyof any, T> = {
    [P in K]?: T;
};
type RequiredNotNull<T> = {
    [P in keyof T]: NonNullable<T[P]>;
};
type Ensure<T, K extends keyof T> = T & RequiredNotNull<Pick<T, K>>;

export { AdvancedFieldProps, AnchorScroller, ClientOnly, CommonSiteSeoTags, ComponentStyles, CustomFieldProps, CustomSetProps, Ensure, FormikHelper, PartialRecord, QueryParamType, QueryParamsValidator, QueryType, RequiredNotNull, ReturnValue, ReturnValueEntry, SeoTags, SeoTagsCommon, SeoTagsProps, SeoTagsType, UseQueryParametersProps, getCommonSeoTags, parseNumberNullable, useAnchorScroll, useFormikHelper, useLocalStorage, useQueryParams, useUIHidable };