import * as React$1 from 'react';
import { useState, Dispatch, SetStateAction, ReactNode } from 'react';
import { CheckboxProps as CheckboxProps$1 } from '@patternfly/react-core/dist/dynamic/components/Checkbox';
import { FormProps as FormProps$1 } from '@patternfly/react-core/dist/dynamic/components/Form';
import { FormSelectProps as FormSelectProps$1 } from '@patternfly/react-core/dist/dynamic/components/FormSelect';
import { TextProps } from '@patternfly/react-core/dist/dynamic/components/Text';
import { TextAreaProps } from '@patternfly/react-core/dist/dynamic/components/TextArea';
import { TextInputProps } from '@patternfly/react-core/dist/dynamic/components/TextInput';
import { SwitchProps as SwitchProps$1 } from '@patternfly/react-core/dist/dynamic/components/Switch';
import { ButtonVariant } from '@patternfly/react-core/dist/dynamic/components/Button';
import { ModalProps } from '@patternfly/react-core/dist/dynamic/components/Modal';
import { BreadcrumbItemProps } from '@patternfly/react-core/dist/dynamic/components/Breadcrumb';
import { FilterChipsFilter } from '@redhat-cloud-services/frontend-components/FilterChips';
import { DeepReadonly } from 'ts-essentials';
import { Middleware } from 'redux';
import * as react_fetching_library from 'react-fetching-library';
import { QueryResponse, RequestInterceptor, ResponseInterceptor } from 'react-fetching-library';
import * as _redhat_cloud_services_javascript_clients_shared from '@redhat-cloud-services/javascript-clients-shared';
import * as endpoints from '@redhat-cloud-services/rbac-client';
import { AccessPagination } from '@redhat-cloud-services/rbac-client/types';

interface OuiaComponentProps {
    ouiaId?: string;
    ouiaSafe?: boolean;
}
interface UseOuiaReturn {
    'data-ouia-component-type': string;
    'data-ouia-component-id'?: string;
    'data-ouia-safe': boolean;
}
declare const setOuiaPage: (type: string, action?: string | undefined, objectId?: string | undefined) => void;
declare const getOuiaPropsFactory: (module: string) => (type: string, oiuaProps: OuiaComponentProps) => UseOuiaReturn;
declare const withoutOuiaProps: <T extends OuiaComponentProps>(props: T) => Omit<T, "ouiaId" | "ouiaSafe">;
declare const ouiaIdConcat: (ouiaIdParent: string | undefined, ouiaId: string) => string;

declare const AppSkeleton: React$1.FunctionComponent<OuiaComponentProps>;

interface RenderIfProps {
    renderIf: () => boolean;
    children: React$1.ReactNode;
}
interface RenderIfTrueFalse {
    _value?: boolean;
    children: React$1.ReactNode;
}
declare const RenderIfTrue: React$1.FunctionComponent<RenderIfTrueFalse>;
declare const RenderIfFalse: React$1.FunctionComponent<RenderIfTrueFalse>;
declare const RenderIf: React$1.FunctionComponent<RenderIfProps>;

declare enum ExporterType {
    JSON = "json",
    CSV = "csv"
}
declare const exporterTypeFromString: (value: string) => ExporterType;

interface Exporter<T> {
    readonly type: ExporterType;
    export(elements: Array<T>): Blob;
}

declare enum ImmutableContainerSetMode {
    INCLUDE = 0,
    EXCLUDE = 1
}
declare class ImmutableContainerSet<T> {
    readonly mode: ImmutableContainerSetMode;
    private readonly set;
    constructor(set?: Iterable<T>, mode?: ImmutableContainerSetMode);
    static include<T>(included?: Iterable<T>): ImmutableContainerSet<T>;
    static exclude<T>(excluded?: Iterable<T>): ImmutableContainerSet<T>;
    values(): T[];
    add(value: T): ImmutableContainerSet<T>;
    addIterable(values: Iterable<T>): ImmutableContainerSet<T>;
    remove(value: T): ImmutableContainerSet<T>;
    removeIterable(values: Iterable<T>): ImmutableContainerSet<T>;
    size(max?: number): number;
    contains(value: T): boolean;
    private update;
}

declare class Page {
    static readonly NO_SIZE = -1;
    readonly index: number;
    readonly size: number;
    readonly filter?: Filter;
    readonly sort?: Sort;
    private constructor();
    hasFilter(): boolean;
    start(): number;
    end(): number;
    withPage(index: number): Page;
    nextPage(): Page;
    withSort(sort: Sort | undefined): Page;
    toQuery(): Record<string, string | ReadonlyArray<string>>;
    static of(index: number, size?: number, filter?: Filter, sort?: Sort): Page;
    static defaultPage(): Page;
    static lastPageForElements(count: number, size: number): Page;
}
declare class FilterElement {
    readonly column: string;
    readonly operator: Operator;
    readonly value: string | Array<string>;
    constructor(column: string, operator: Operator, value: string | Array<string>);
}
declare class Filter {
    private _elements;
    readonly elements: DeepReadonly<FilterElement[]>;
    constructor();
    and(column: string, operator: Operator, value: string | Array<string>): this;
}
declare class Sort {
    readonly column: string;
    readonly direction: Direction;
    private constructor();
    static by(column: string, direction: Direction): Sort;
}
declare enum Direction {
    ASCENDING = "ASC",
    DESCENDING = "DESC"
}
declare enum Operator {
    EQUAL = "EQUAL",
    LIKE = "LIKE",
    ILIKE = "ILIKE",
    NOT_EQUAL = "NOT_EQUAL",
    BOOLEAN_IS = "BOOLEAN_IS"
}
declare type OnSortHandlerType = (index: number, column: string, direction: Direction) => void;

declare type Verb = string;
declare type What = string;
declare type App = string;
declare type WhatPermissions = Array<Verb>;
declare type AppPermissions = Record<What, WhatPermissions>;
declare type RbacPermission = Record<App, AppPermissions>;
declare class Rbac {
    private permissions;
    constructor(permissions: RbacPermission);
    hasPermission(app: App, what: What, verb: Verb): boolean;
    private hasWhatPermission;
    private hasAppPermission;
}

interface HasToString {
    toString: () => string;
}

declare type Setter<T> = (val: T | ((prev: T) => T)) => void;
declare type StandardFilterEnum<T> = Record<keyof T, string>;
declare type FilterContent = string | Array<string> | undefined;
declare type EnumElement<Enum> = Enum[keyof Enum];
declare type FilterBase<Enum extends StandardFilterEnum<any>, T> = Record<EnumElement<Enum>, T>;
declare type OptionalFilterBase<Enum extends StandardFilterEnum<any>, T> = FilterBase<Enum, T | undefined>;
declare type Filters<Enum extends StandardFilterEnum<any>> = FilterBase<Enum, FilterContent>;
declare type SetFilters<Enum extends StandardFilterEnum<any>> = FilterBase<Enum, Setter<FilterContent>>;
declare type ClearFilterElement<Enum extends StandardFilterEnum<any>> = {
    [P in EnumElement<Enum>]?: FilterContent;
};
declare type ClearFilters<Enum extends StandardFilterEnum<any>> = (columns: ClearFilterElement<Enum>) => void;
declare const stringValue: (val: string | Array<string> | undefined, separator?: string) => string;
declare const arrayValue: (val: string | Array<string> | undefined, separator?: string) => Array<string>;

interface Entitlement {
    is_entitled: boolean;
}
interface UserData {
    username: string;
    email: string;
    first_name: string;
    last_name: string;
    is_active: boolean;
    is_org_admin: boolean;
    is_internal: boolean;
    locale: string;
}
interface Internal {
    org_id: string;
    account_id: number;
}
interface Identity {
    account_number: string;
    type: string;
    user: UserData;
    internal: Internal;
}
interface User {
    identity: Identity;
    entitlements: Record<string, Entitlement>;
}
declare type InsightsType = {
    chrome: {
        init: () => void;
        identifyApp: (appId: string) => Promise<void>;
        getApp: () => string;
        getBundle: () => string;
        getEnvironment: () => 'ci' | 'qa' | 'prod' | 'stage';
        on: (type: string, callback: ((event: any) => void)) => void;
        auth: {
            getUser: () => Promise<User>;
        };
        isProd: boolean;
        isBeta: () => boolean;
        isPenTest: () => boolean;
    };
};
declare const waitForInsights: () => Promise<InsightsType>;
declare const getInsights: () => InsightsType;

declare const nonBetaEnvironments: readonly ["ci", "qa", "stage", "prod", "gov", "govStage"];
declare const betaEnvironments: ("ci-beta" | "qa-beta" | "prod-beta" | "stage-beta" | "gov-beta" | "govStage-beta")[];
declare type NonBetaEnvironment = typeof nonBetaEnvironments[number];
declare type BetaEnvironment = typeof betaEnvironments[number];
declare type Environment = NonBetaEnvironment | BetaEnvironment;
declare type Environments = Record<'all' | 'beta' | 'nonBeta' | 'prod' | 'nonProd' | 'ci' | 'qa' | 'stage' | 'govProd' | 'govStage', ReadonlyArray<Environment>>;
declare const Environments: Environments;
declare const getInsightsEnvironment: (insights: InsightsType) => Environment;

declare type SemiPartial<T, K extends keyof T> = Pick<T, K> & Partial<Omit<T, K>>;

declare type Headers<T> = Array<[keyof ReturnType<ExporterCsv<T>['serialize']>, string]>;
declare type ExporterHeaders<Exporter extends ExporterCsv<T>, T> = Array<[keyof ReturnType<Exporter['serialize']>, string]>;
declare type SerializedObject = {
    [key: string]: HasToString | undefined;
};
declare abstract class ExporterCsv<T> implements Exporter<T> {
    readonly type = ExporterType.CSV;
    private encode;
    export(elements: Array<T>): Blob;
    abstract headers(): Headers<T>;
    abstract serialize(element: T): SerializedObject;
}

declare abstract class ExporterJson<T> implements Exporter<T> {
    readonly type = ExporterType.JSON;
    export(elements: Array<T>): Blob;
}

declare enum NotificationType {
    SUCCESS = "success",
    DANGER = "danger",
    WARNING = "warning",
    INFO = "info"
}
declare const addNotification: (type: NotificationType, title: string, description: React.ReactNode, dismissable?: boolean | undefined) => void;
declare type ExplicitNotificationFunction = (title: string, description: React.ReactNode, dismissable?: boolean) => void;
declare const addSuccessNotification: ExplicitNotificationFunction;
declare const addDangerNotification: ExplicitNotificationFunction;
declare const addInfoNotification: ExplicitNotificationFunction;
declare const addWarningNotification: ExplicitNotificationFunction;
declare const clearNotifications: () => void;

declare type ExpectedQueryResponse<FROM> = QueryResponse<FROM> & {
    query: (...args: Array<any>) => Promise<QueryResponse<FROM>>;
};
declare type ExpectedMutateResponse<FROM> = QueryResponse<FROM> & {
    mutate: (...args: Array<any>) => Promise<QueryResponse<FROM>>;
};
declare type UseTransformQueryResponseTypeQuery<FROM, USE_QUERY_RESPONSE_FROM extends ExpectedQueryResponse<FROM>, TO> = Omit<USE_QUERY_RESPONSE_FROM, 'payload' | 'query'> & {
    query: (...args: Parameters<USE_QUERY_RESPONSE_FROM['query']>) => Promise<QueryResponse<TO>>;
    payload: undefined | TO;
};
declare type UseTransformQueryResponseTypeMutation<FROM, USE_QUERY_RESPONSE_FROM extends ExpectedMutateResponse<FROM>, TO> = Omit<USE_QUERY_RESPONSE_FROM, 'payload' | 'mutate'> & {
    mutate: (...args: Parameters<USE_QUERY_RESPONSE_FROM['mutate']>) => Promise<QueryResponse<TO>>;
    payload: undefined | TO;
};
interface UseTransformQueryResponseType {
    <FROM, TO, USE_QUERY_RESPONSE_FROM extends ExpectedQueryResponse<FROM>>(queryResponse: USE_QUERY_RESPONSE_FROM, adapter: (from: FROM) => TO): UseTransformQueryResponseTypeQuery<FROM, USE_QUERY_RESPONSE_FROM, TO>;
    <FROM, TO, USE_MUTATE_RESPONSE_FROM extends ExpectedMutateResponse<FROM>>(queryResponse: USE_MUTATE_RESPONSE_FROM, adapter: (from: FROM) => TO): UseTransformQueryResponseTypeMutation<FROM, USE_MUTATE_RESPONSE_FROM, TO>;
}
declare const useTransformQueryResponse: UseTransformQueryResponseType;

declare type JoinType = (elements: Array<React$1.ReactNode>, GlueComponent: React$1.ElementType) => Array<React$1.ReactNode>;
declare const join: JoinType;
declare const joinClasses: (...args: string[]) => string;

declare const toUtc: (date: Date) => Date;
declare const fromUtc: (date: Date) => Date;

interface FetchingClientOptions {
    requestInterceptors?: Array<RequestInterceptor>;
    responseInterceptors?: Array<ResponseInterceptor>;
}
declare const createFetchingClient: (getInsights: () => InsightsType, options?: FetchingClientOptions | undefined) => {
    cache: {
        add: (action: react_fetching_library.Action<any, any>, value: react_fetching_library.QueryResponse<any>) => void;
        remove: (action: react_fetching_library.Action<any, any>) => void;
        get: (action: react_fetching_library.Action<any, any>) => (react_fetching_library.QueryResponse<any> & {
            timestamp: number;
        }) | undefined;
        getItems: () => {
            [key: string]: react_fetching_library.QueryResponse<any>;
        };
        setItems: (items: {
            [key: string]: react_fetching_library.QueryResponse<any>;
        }) => void;
    } | undefined;
    query: <T>(actionInit: react_fetching_library.Action<T, any>, skipCache?: boolean | undefined) => Promise<react_fetching_library.QueryResponse<T>>;
    suspenseCache: {
        add: (action: react_fetching_library.Action<any, any>, value: {
            fetch: any;
            response?: react_fetching_library.QueryResponse<any> | undefined;
        }) => void;
        remove: (action: react_fetching_library.Action<any, any>) => void;
        get: (action: react_fetching_library.Action<any, any>) => ({
            fetch: any;
            response?: react_fetching_library.QueryResponse<any> | undefined;
        } & {
            timestamp: number;
        }) | undefined;
        getItems: () => {
            [key: string]: {
                fetch: any;
                response?: react_fetching_library.QueryResponse<any> | undefined;
            };
        };
        setItems: (items: {
            [key: string]: {
                fetch: any;
                response?: react_fetching_library.QueryResponse<any> | undefined;
            };
        }) => void;
    };
};

declare const getBaseName: (pathname: string) => string;

declare const rbacApi: _redhat_cloud_services_javascript_clients_shared.BaseAPI & _redhat_cloud_services_javascript_clients_shared.APIFactoryResponse<typeof endpoints, {
    addPrincipalToGroup: unknown;
    addRoleToGroup: unknown;
    createCrossAccountRequests: unknown;
    createGroup: unknown;
    createRole: unknown;
    deleteGroup: unknown;
    deletePrincipalFromGroup: unknown;
    deleteRole: unknown;
    deleteRoleFromGroup: unknown;
    getCrossAccountRequest: unknown;
    getGroup: unknown;
    getPrincipalAccess: unknown;
    getPrincipalsFromGroup: unknown;
    getRole: unknown;
    getRoleAccess: unknown;
    getStatus: unknown;
    listCrossAccountRequests: unknown;
    listGroups: unknown;
    listPermissionOptions: unknown;
    listPermissions: unknown;
    listPrincipals: unknown;
    listRoles: unknown;
    listRolesForGroup: unknown;
    patchCrossAccountRequest: unknown;
    patchRole: unknown;
    putCrossAccountRequest: unknown;
    updateGroup: unknown;
    updateRole: unknown;
}>;
declare class RbacPermissionsBuilder {
    readonly accessPagination: AccessPagination;
    constructor(accessPagination: AccessPagination);
    build(): RbacPermission;
}
declare const fetchRBAC: (appQuery: string) => Promise<Rbac>;

declare const BetaIf: React$1.FunctionComponent<RenderIfTrueFalse>;
declare const BetaIfNot: React$1.FunctionComponent<RenderIfTrueFalse>;
declare type BetaDetectorProps = {
    children: React$1.ReactNode;
    isBeta: boolean;
};
declare const BetaDetector: React$1.FunctionComponent<BetaDetectorProps>;
interface InsightsBetaDetectorProps$1 extends Omit<BetaDetectorProps, 'isBeta'> {
    insights: InsightsType;
}
declare const InsightsBetaDetector: React$1.FunctionComponent<InsightsBetaDetectorProps$1>;

interface EmailOptInProps extends OuiaComponentProps {
    content: string;
    isBeta: boolean;
    bundle: string;
}
declare const EmailOptIn: React$1.FunctionComponent<EmailOptInProps>;
declare type Partials = 'isBeta' | 'bundle';
declare type InsightsEmailOptInPropsType = Partial<Pick<EmailOptInProps, Partials>> & Omit<EmailOptInProps, Partials>;
interface InsightsEmailOptInProps extends InsightsEmailOptInPropsType {
    insights: InsightsType;
}
declare const InsightsEmailOptIn: React$1.FunctionComponent<InsightsEmailOptInProps>;

interface EmptyStateSectionProps extends OuiaComponentProps {
    icon?: React$1.ComponentType<any>;
    iconColor?: string;
    title: string;
    content: React$1.ReactNode;
    action?: () => void;
    actionNode?: React$1.ReactNode;
    actionLabel?: string;
    className?: string;
}
declare const EmptyState: React$1.FunctionComponent<EmptyStateSectionProps>;

interface ErrorPageProps extends OuiaComponentProps {
    action: () => void;
    actionLabel: string;
    pageHeader: string;
    title: string;
    description: string;
}
interface ErrorPageState {
    hasError: boolean;
    error?: any;
}
declare class ErrorBoundaryPage extends React$1.Component<ErrorPageProps, ErrorPageState> {
    constructor(props: Readonly<ErrorPageProps>);
    executeAction: () => void;
    static getDerivedStateFromError(error: any): ErrorPageState;
    render(): React$1.ReactNode;
}

interface EnvDetectorProps {
    onEnvironment: ReadonlyArray<Environment> | Environment;
    currentEnvironment: Environment;
}
declare const EnvDetector: React$1.FunctionComponent<React$1.PropsWithChildren<EnvDetectorProps>>;
interface InsightsBetaDetectorProps extends Omit<EnvDetectorProps, 'currentEnvironment'> {
    insights: InsightsType;
}
declare const InsightsEnvDetector: React$1.FunctionComponent<React$1.PropsWithChildren<InsightsBetaDetectorProps>>;

interface CheckboxProps extends Omit<CheckboxProps$1, 'onChange' | 'ref' | 'ouiaId'> {
    name: string;
    isRequired?: boolean;
    ouiaId?: string;
}
declare const Checkbox: React$1.FunctionComponent<CheckboxProps>;

interface FormProps extends OuiaComponentProps, FormProps$1 {
}
declare const Form: React$1.FunctionComponent<FormProps>;

interface FormSelectProps extends OuiaComponentProps, Omit<FormSelectProps$1, 'onChange' | 'ref' | 'ouiaId'> {
    id: string;
    name: string;
    isRequired?: boolean;
}
declare const FormSelect: React$1.FunctionComponent<FormSelectProps>;

interface FormTextProps extends Omit<TextProps, 'ref' | 'ouiaId'> {
    id: string;
    name: string;
    isRequired?: boolean;
    ouiaId?: string;
}
declare const FormText: React$1.FunctionComponent<FormTextProps>;

interface FormTextAreaProps extends OuiaComponentProps, Omit<TextAreaProps, 'id' | 'name' | 'onChange'> {
    id: string;
    name: string;
}
declare const FormTextArea: React$1.FunctionComponent<FormTextAreaProps>;

interface FormTextInputProps extends Omit<TextInputProps, 'onChange' | 'innerRef' | 'ouiaId'> {
    id: string;
    name: string;
    hint?: string;
    ouiaId?: string;
}
declare const FormTextInput: React$1.FunctionComponent<FormTextInputProps>;

interface SwitchProps extends OuiaComponentProps, Omit<SwitchProps$1, 'onChange' | 'ref' | 'ouiaSafe' | 'ouiaId'> {
    id: string;
    name: string;
    isRequired?: boolean;
    labelOn?: string;
}
declare const Switch: React$1.FunctionComponent<SwitchProps>;

interface SectionProps extends OuiaComponentProps {
    className?: string;
    style?: React$1.CSSProperties;
}
declare const Section: React$1.FunctionComponent<SectionProps>;

interface ActionModalError {
    title: string;
    description: React$1.ReactNode | string;
}
interface ActionModalProps extends Pick<ModalProps, 'variant' | 'titleIconVariant'> {
    isOpen: boolean;
    isPerformingAction: boolean;
    title: string;
    content: React$1.ReactNode | string;
    error?: ActionModalError;
    onClose: (actionPerformed: boolean) => void;
    onAction: () => boolean | Promise<boolean>;
    actionButtonTitle: string;
    actionButtonVariant: ButtonVariant;
    actionButtonDisabled?: boolean;
    actionButtonHidden?: boolean;
    cancelButtonTitle?: string;
    cancelButtonVariant?: ButtonVariant;
}
declare const ActionModal: React$1.FunctionComponent<ActionModalProps>;

declare type ChangedProps$1 = 'isPerformingAction' | 'onAction';
declare type InheritedProps$1 = 'isOpen' | 'title' | 'content' | 'onClose' | 'error' | 'variant';
declare type DeleteModalProps = Omit<SemiPartial<ActionModalProps, InheritedProps$1>, ChangedProps$1> & {
    isDeleting: boolean;
    onDelete: () => boolean | Promise<boolean>;
};
declare const DeleteModal: React$1.FunctionComponent<DeleteModalProps>;

declare type ChangedProps = 'isPerformingAction' | 'onAction';
declare type InheritedProps = 'isOpen' | 'title' | 'content' | 'onClose' | 'error' | 'actionButtonDisabled' | 'variant' | 'titleIconVariant';
declare type SaveModalProps = Omit<SemiPartial<ActionModalProps, InheritedProps>, ChangedProps> & {
    isSaving: boolean;
    onSave: () => boolean | Promise<boolean>;
};
declare const SaveModal: React$1.FunctionComponent<SaveModalProps>;

declare type BreadcrumbLinkItemProps = Omit<BreadcrumbItemProps, 'component'> & OuiaComponentProps;
declare const BreadcrumbLinkItem: React$1.FunctionComponent<BreadcrumbLinkItemProps>;

declare const localUrl: (path: string, isBeta: boolean) => string;

declare type UseStateType = typeof useState;
declare type UseDebouncedStateReturn<T> = [T, Dispatch<SetStateAction<T>>, T, () => boolean | null];
declare type UseDebouncedStateType<T> = (initialValue: T, ms: number, useStateHook?: UseStateType) => UseDebouncedStateReturn<T>;
declare const useDebouncedState: <T>(initialValue: T, ms: number, useStateHook?: typeof useState | undefined) => UseDebouncedStateReturn<T>;

declare const useFilters: <FilterColumn extends StandardFilterEnum<any>>(initEnum: FilterColumn, debounce?: number, initUseStateFactory?: ((column: EnumElement<FilterColumn>) => typeof useState | undefined) | undefined) => {
    clearFilter: ClearFilters<FilterColumn>;
    filters: Filters<FilterColumn>;
    setFilters: SetFilters<FilterColumn>;
    debouncedFilters: Filters<FilterColumn>;
};

interface FilterColumnMetadataOptionsBase<T> {
    exclude?: Array<string>;
    default?: T;
    exclusive?: boolean;
    items: Array<{
        value: string;
        chipValue?: string;
        label: ReactNode;
    }>;
}
interface FilterColumnMetadataOptionsSingleValue extends FilterColumnMetadataOptionsBase<string> {
    exclusive?: true;
}
interface FilterColumnMetadataOptionsMultipleValue extends FilterColumnMetadataOptionsBase<Array<string>> {
    exclusive?: false;
}
interface FilterColumnMetadata {
    label: string;
    placeholder: string;
    options?: FilterColumnMetadataOptionsSingleValue | FilterColumnMetadataOptionsMultipleValue;
}
declare type OptionalColumnsMetada<Enum extends StandardFilterEnum<any>> = OptionalFilterBase<Enum, FilterColumnMetadata>;
declare type ColumnsMetada<Enum extends StandardFilterEnum<any>> = FilterBase<Enum, FilterColumnMetadata>;
declare const usePrimaryToolbarFilterConfig: <FilterColumn extends StandardFilterEnum<any>>(initEnum: FilterColumn, filters: Filters<FilterColumn>, setFilters: SetFilters<FilterColumn>, clearFilters: ClearFilters<FilterColumn>, meta: OptionalColumnsMetada<FilterColumn>, deleteTitle?: "Reset filters" | undefined) => {
    filterConfig: {
        items: {
            label: string;
            type: string;
            filterValues: {
                id: string;
                value: FilterContent;
                placeholder: string;
                onChange: (_event: any, value: string | Array<string>) => void;
                items: {
                    value: string;
                    chipValue?: string | undefined;
                    label: ReactNode;
                }[] | undefined;
            };
        }[];
    };
    activeFiltersConfig: {
        filters: FilterChipsFilter[];
        onDelete: (_event: any, rawFilterConfigs: any[]) => void;
    };
    deleteTitle: "Reset filters" | undefined;
};

declare type UseResolvedPromiseValueReturn<T> = T | undefined;
declare const usePromiseState: <T>(promise: Promise<T>) => UseResolvedPromiseValueReturn<T>;

interface UseSortReturn {
    sortBy: Sort | undefined;
    onSort: OnSortHandlerType;
}
declare const useSort: (defaultSort?: Sort | undefined) => UseSortReturn;

declare type AsyncFunction = () => (Promise<unknown> | unknown);
declare const useSyncInterval: (ms: number, callback: AsyncFunction, callImmediately?: boolean) => void;

declare type UseUrlStateResponse<T> = [T | undefined, Dispatch<SetStateAction<T | undefined>>];
declare type Serializer<T> = (value: T | undefined) => string | undefined;
declare type Deserializer<T> = (value: string | undefined) => T | undefined;
declare type UseUrlStateType<T> = (name: string, serializer: Serializer<T>, deserializer: Deserializer<T>, initialValue?: T) => UseUrlStateResponse<T>;
declare const useUrlState: <T>(name: string, serializer: Serializer<T>, deserializer: Deserializer<T>, initialValue?: T | undefined) => UseUrlStateResponse<T>;
declare type UseUrlStateStringType = (name: string, initialValue?: string) => UseUrlStateResponse<string>;
declare const useUrlStateString: (name: string, initialValue?: string | undefined) => UseUrlStateResponse<string>;

declare type Unpacked<T> = T extends (infer U)[] ? U : T;
declare const useUrlStateExclusiveOptions: <T extends string, AT extends T[]>(name: string, options?: AT | undefined, defaultValue?: Unpacked<AT> | undefined) => UseUrlStateResponse<Unpacked<AT>>;

declare const useUrlStateMultipleOptions: <T extends string>(name: string, options?: T[] | undefined, defaultValue?: T[] | undefined) => UseUrlStateResponse<T[]>;

declare type FeatureFlagCallback<T> = () => T;
declare type FeatureFlagSignature = {
    <T>(resolver: () => boolean, ifTrue: FeatureFlagCallback<T>, ifFalse?: FeatureFlagCallback<T>): T | undefined;
    <T>(resolver: () => boolean, ifTrue: FeatureFlagCallback<T> | undefined, ifFalse: FeatureFlagCallback<T>): T | undefined;
};
declare const useFeatureFlag: FeatureFlagSignature;

declare type EnvironmentFlagSignature = {
    <T>(currentEnvironment: Environment, targetEnvironments: Environment | ReadonlyArray<Environment>, ifTrue: FeatureFlagCallback<T>, ifFalse?: FeatureFlagCallback<T>): T | undefined;
    <T>(currentEnvironment: Environment, targetEnvironments: Environment | ReadonlyArray<Environment>, ifTrue: FeatureFlagCallback<T> | undefined, ifFalse: FeatureFlagCallback<T>): T | undefined;
};
declare const useEnvironmentFlag: EnvironmentFlagSignature;
declare type InsightsEnvironmentFlagSignature = {
    <T>(insights: InsightsType, targetEnvironments: Environment | ReadonlyArray<Environment>, ifTrue: FeatureFlagCallback<T>, ifFalse?: FeatureFlagCallback<T>): T | undefined;
    <T>(insights: InsightsType, targetEnvironments: Environment | ReadonlyArray<Environment>, ifTrue: FeatureFlagCallback<T> | undefined, ifFalse: FeatureFlagCallback<T>): T | undefined;
};
declare const useInsightsEnvironmentFlag: InsightsEnvironmentFlagSignature;

declare const restoreStore: () => void;
declare const initStore: <State, Reducer extends Record<string, any>>(initialState?: State | undefined, reducer?: Reducer | undefined, ...middleware: Middleware[]) => any;
declare const getStore: () => any;

export { ActionModal, ActionModalError, ActionModalProps, AppSkeleton, BetaDetector, BetaEnvironment, BetaIf, BetaIfNot, BreadcrumbLinkItem, Checkbox, ClearFilterElement, ClearFilters, ColumnsMetada, DeleteModal, DeleteModalProps, Deserializer, Direction, EmailOptIn, EmptyState, EmptyStateSectionProps, EnumElement, EnvDetector, Environment, Environments, ErrorBoundaryPage, Exporter, ExporterCsv, ExporterHeaders, ExporterJson, ExporterType, FeatureFlagCallback, FeatureFlagSignature, Filter, FilterBase, FilterColumnMetadata, FilterContent, Filters, Form, FormSelect, FormText, FormTextArea, FormTextInput, HasToString, Headers, ImmutableContainerSet, ImmutableContainerSetMode, InsightsBetaDetector, InsightsEmailOptIn, InsightsEnvDetector, InsightsType, NonBetaEnvironment, NotificationType, OnSortHandlerType, Operator, OptionalColumnsMetada, OptionalFilterBase, OuiaComponentProps, Page, Rbac, RbacPermission, RbacPermissionsBuilder, RenderIf, RenderIfFalse, RenderIfProps, RenderIfTrue, RenderIfTrueFalse, SaveModal, SaveModalProps, Section, SemiPartial, Serializer, SetFilters, Sort, StandardFilterEnum, Switch, UseDebouncedStateType, UseSortReturn, UseUrlStateResponse, UseUrlStateStringType, UseUrlStateType, addDangerNotification, addInfoNotification, addNotification, addSuccessNotification, addWarningNotification, arrayValue, clearNotifications, createFetchingClient, exporterTypeFromString, fetchRBAC, fromUtc, getBaseName, getInsights, getInsightsEnvironment, getOuiaPropsFactory, getStore, initStore, join, joinClasses, localUrl, ouiaIdConcat, rbacApi, restoreStore, setOuiaPage, stringValue, toUtc, useDebouncedState, useEnvironmentFlag, useFeatureFlag, useFilters, useInsightsEnvironmentFlag, usePrimaryToolbarFilterConfig, usePromiseState, useSort, useSyncInterval, useTransformQueryResponse, useUrlState, useUrlStateExclusiveOptions, useUrlStateMultipleOptions, useUrlStateString, waitForInsights, withoutOuiaProps };