@commercetools-frontend-extensions/change-history 8.38.0 → 8.39.1

package/dist/declarations/src/components/_types/change-history.d.ts

@@ -0,0 +1,5 @@
+import { ChangeType, ResourceTypes, Source } from "../../../types/src/generated/change-history.js";
+import { ValueOf } from "../../types/common-types.js";
+export type TResourceTypes = ValueOf<typeof ResourceTypes>;
+export type TChangeType = ValueOf<typeof ChangeType>;
+export type TSource = ValueOf<typeof Source>;

package/dist/declarations/src/components/change-history-list-connector/change-history-list-connector.d.ts

@@ -0,0 +1,42 @@
+import { ReactElement } from 'react';
+import type { TCustomer, TLocalizedString } from "../../../types/src/generated/ctp.js";
+import type { TOAuthClient } from "../../../types/src/generated/mc.js";
+import type { TResourceType } from "../../constants/index.js";
+import type { TSearchQuery } from "../../hooks/use-search-query-state/types.js";
+import type { TALUsers } from "../../types/common-types.js";
+import type { TConvertedChangeHistoryEntry } from "./conversions.js";
+export type TApiClients = Record<TOAuthClient['id'], TOAuthClient['name']>;
+export type TCustomers = Record<TCustomer['id'], TCustomer['email']>;
+export type TLocalizedStringObj = Array<TLocalizedString> | null;
+export type TLocalizedField = Record<string, string>;
+export type TChangeHistoryListConnectorProps = {
+    canViewCustomers: boolean;
+    canViewDeveloperSettings: boolean;
+    children: (props: {
+        isLoading: boolean;
+        changeHistoryFetcher: {
+            history: {
+                total: number;
+                results: TConvertedChangeHistoryEntry[];
+            };
+            searchQuery: TSearchQuery;
+        };
+        currentRecordsFetcher: {
+            total: number;
+        };
+        members: TALUsers;
+        apiClients: TApiClients;
+        customers: TCustomers;
+        refetchChangeHistory: () => void;
+    }) => ReactElement;
+    projectKey: string;
+    resourceId?: string;
+    allowedResourceTypes: TResourceType[];
+    inContextEntity?: TResourceType;
+    searchQuery: TSearchQuery;
+};
+declare const ChangeHistoryListConnector: {
+    (props: TChangeHistoryListConnectorProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+    displayName: string;
+};
+export default ChangeHistoryListConnector;

package/dist/declarations/src/components/change-history-list-connector/conversions.d.ts

@@ -0,0 +1,49 @@
+import type { TLocalizedStringObj } from "./change-history-list-connector.js";
+import { TFetchAllUsersOfOrganizationQuery, TFetchChangeHistoryQuery, TStore } from "../../../types/src/generated/change-history.js";
+import { TCustomer, TFetchCustomersQueryQuery, TFetchStoresQueryQuery } from "../../../types/src/generated/ctp.js";
+import { TFetchOAuthClientsQueryQuery } from "../../../types/src/generated/mc.js";
+import { TALUsers } from "../../types/common-types.js";
+import { TApiClients, TCustomers, TLocalizedField } from "./change-history-list-connector.js";
+export type TStoreDataWithName = TStore & {
+    name?: TLocalizedField;
+};
+export type TChangeHistoryResult = TFetchChangeHistoryQuery['changeHistory']['results'][number];
+export type TLabelData = TChangeHistoryResult['label'];
+export type TLabelDataWithUpdatedCustomer = Omit<TLabelData, 'customer'> & {
+    customer?: TFetchCustomersQueryQuery['customers']['results'][number] | null;
+};
+type TStoresResults = TFetchStoresQueryQuery['stores']['results'];
+type TFetchChangeHistoryChanges = TChangeHistoryResult['changes'][number];
+export type TConvertedFetchChangeHistoryChanges = Omit<TFetchChangeHistoryChanges, 'customLineItemNameAllLocales' | 'lineItemNameAllLocales'> & {
+    customLineItem: TLocalizedStringObj;
+    asset?: {
+        name: TLocalizedStringObj;
+    };
+    lineItem?: TLocalizedStringObj | {
+        name: TLocalizedStringObj;
+    };
+    textLineItem?: {
+        name: TLocalizedStringObj;
+    };
+};
+type TStoreResult = TStoresResults[number];
+export type TConvertedStoreResult = TStoreResult & {
+    name?: TLocalizedField;
+};
+export type TConvertedChangeHistoryEntry = {
+    label: TLabelData | TLabelDataWithUpdatedCustomer;
+    previousLabel: TLabelData | TLabelDataWithUpdatedCustomer;
+    changes: Array<TConvertedFetchChangeHistoryChanges | null>;
+    stores: Array<TConvertedStoreResult>;
+} & Omit<TChangeHistoryResult, 'label' | 'previousLabel' | 'changes' | 'stores'>;
+export type TChangeHistoryResponse = {
+    total?: number | null;
+    results: Array<TConvertedChangeHistoryEntry>;
+};
+export declare const gatherChangeHistoryFromGraphqlResponse: (changeHistoryData: TFetchChangeHistoryQuery, storesData?: TStoresResults, entityLabelCustomerData?: TEntityLabelCustomerData | null) => TChangeHistoryResponse;
+export declare const gatherMembersFromGraphqlResponse: (data: TFetchAllUsersOfOrganizationQuery | undefined) => TALUsers;
+export declare const gatherApiClientsFromGraphqlResponse: (data?: TFetchOAuthClientsQueryQuery) => TApiClients;
+export type TEntityLabelCustomerData = Record<TCustomer['id'], Pick<TCustomer, 'id' | 'email' | 'companyName'>>;
+export declare const gatherEntityLabelCustomerDataFromGraphqlResponse: (data: TFetchCustomersQueryQuery) => TEntityLabelCustomerData;
+export declare const gatherCustomersFromGraphqlResponse: (data?: TFetchCustomersQueryQuery) => TCustomers;
+export {};

package/dist/declarations/src/components/change-history-list-view/filter-definitions.d.ts

@@ -0,0 +1,37 @@
+import type { MessageDescriptor } from 'react-intl';
+import { TOption } from '@commercetools-frontend/ui-kit';
+import { TierLevels } from "../../../types/src/generated/change-history.js";
+import { TResourceType } from "../../constants/index.js";
+import { TALUsers, TIntl } from "../../types/common-types.js";
+import { TAvailableFilters, TFilteredFilterDefinitions } from "../../types/filters-types.js";
+import { TApiClients } from "../change-history-list-connector/change-history-list-connector.js";
+export type TDisabledGroupTitleLabelProps = {
+    group: string;
+    groupTitleMessage: MessageDescriptor;
+};
+export type TOptionsWithDisabledForBasic = TOption & {
+    disabledForBasic?: boolean;
+};
+export declare const optionsGrouping: ({ options, tier, }: {
+    options: TOptionsWithDisabledForBasic[];
+    tier?: TierLevels | null | undefined;
+}) => TOptionsWithDisabledForBasic[] | {
+    label: import("@emotion/react/jsx-runtime").JSX.Element;
+    value: TierLevels;
+    options: TOptionsWithDisabledForBasic[];
+}[];
+export declare const statusOptions: (intl: TIntl) => TOption[];
+type TCreateFilterDefinitionProps = {
+    allowedResourceTypes: TResourceType[];
+    apiClients: TApiClients;
+    availableFilters: TAvailableFilters;
+    canViewBusinessUnits: boolean;
+    canViewCustomers: boolean;
+    canViewDeveloperSettings: boolean;
+    canViewStores: boolean;
+    intl: TIntl;
+    members: TALUsers;
+    tier: TierLevels;
+};
+declare const createFilterDefinitions: import("memoize-one").MemoizedFn<({ allowedResourceTypes, apiClients, availableFilters, canViewBusinessUnits, canViewCustomers, canViewDeveloperSettings, canViewStores, intl, members, tier, }: TCreateFilterDefinitionProps) => TFilteredFilterDefinitions>;
+export default createFilterDefinitions;

package/dist/declarations/src/components/search/filters-container/filter-configurations/filter-configurations.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import { IntlShape } from 'react-intl';
+import type { TFilterConfiguration } from '@commercetools-uikit/filters';
+import type { TAppliedFilterValue } from '@commercetools-uikit/filters/dist/declarations/src/filter-menu';
+import type { ReactElement, ReactNode } from 'react';
+import type { TFilterKey, TFilterOperator, TResourceType } from "../../../../constants/index.js";
+import type { TSearchQuery } from "../../../../hooks/use-search-query-state/types.js";
+export type TOperatorOption = {
+    value: TFilterOperator;
+    label: ReactNode;
+};
+export type TALFilterValue = {
+    operator?: TFilterOperator;
+    appliedFilterValues: TAppliedFilterValue[];
+};
+export type TFilterValueState = Partial<Record<TFilterKey, TALFilterValue>>;
+type TCommonFilterConfigProps = {
+    filterValue: TFilterValueState;
+    setFilterValue: React.Dispatch<React.SetStateAction<TFilterValueState>>;
+    searchQuery: TSearchQuery;
+    onUpdateSearch: (updatedSearchQuery?: Partial<TSearchQuery>) => void;
+    removeFilter: (key: TFilterKey) => void;
+};
+type TCreateFilterConfigurationsProps = {
+    intl: IntlShape;
+    allowedResourceTypes: TResourceType[];
+    commonFilterProps: TCommonFilterConfigProps;
+};
+export type TBaseCreateFilterConfigProps = TCommonFilterConfigProps & {
+    key: TFilterKey;
+    label: string;
+    tooltip?: ReactElement;
+    groupKey?: string;
+};
+export declare const createFilterConfigurations: ({ allowedResourceTypes, intl, commonFilterProps, }: TCreateFilterConfigurationsProps) => TFilterConfiguration[];
+export {};

package/dist/declarations/src/components/search/standard-filter-definitions/index.d.ts

@@ -0,0 +1 @@
+export * from "./standard-filter-definitions.js";

package/dist/declarations/src/components/search/standard-filter-definitions/standard-filter-definitions.d.ts

@@ -0,0 +1,24 @@
+import { TOption } from '@commercetools-frontend/ui-kit';
+import { TierLevels } from "../../../../types/src/generated/change-history.js";
+import { TIntl } from "../../../types/common-types.js";
+import { TFilterTypeToFilterDefinitionMap } from "../../../types/filters-types.js";
+import { TOptionsWithDisabledForBasic } from "../../change-history-list-view/filter-definitions.js";
+export type TCreateStandardFilterMapMeta = {
+    options?: TOptionsWithDisabledForBasic[];
+    isMulti?: boolean;
+    isSearchable?: boolean;
+    resources?: TOption[];
+    tier?: TierLevels;
+};
+export declare function createDateDefinitionsMap(intl: TIntl): TFilterTypeToFilterDefinitionMap;
+export declare function createFilterTypeToDefinitionMap(intl: TIntl, meta: TCreateStandardFilterMapMeta): TFilterTypeToFilterDefinitionMap;
+export declare function createTypeOfChangeDefinitionsMap(intl: TIntl, meta: TCreateStandardFilterMapMeta): TFilterTypeToFilterDefinitionMap;
+export declare function createUserDefinitionsMap(intl: TIntl, meta: TCreateStandardFilterMapMeta): TFilterTypeToFilterDefinitionMap;
+export declare function createToolOptionsDefinitionsMap(intl: TIntl, meta: TCreateStandardFilterMapMeta): TFilterTypeToFilterDefinitionMap;
+export declare function createResourceChangeDefinitionsMap(intl: TIntl, meta: TCreateStandardFilterMapMeta): TFilterTypeToFilterDefinitionMap;
+export declare function createApiClientDefinitionsMap(intl: TIntl, meta: TCreateStandardFilterMapMeta): TFilterTypeToFilterDefinitionMap;
+export declare function createCustomerIdDefinitionsMap(intl: TIntl): TFilterTypeToFilterDefinitionMap;
+export declare function createExcludePlatformChangesDefinitionsMap(intl: TIntl): TFilterTypeToFilterDefinitionMap;
+export declare function createStoresDefinitionsMap(intl: TIntl): TFilterTypeToFilterDefinitionMap;
+export declare function createBusinessUnitDefinitionsMap(intl: TIntl): TFilterTypeToFilterDefinitionMap;
+export declare function createEntityIdDefinitionsMap(intl: TIntl): TFilterTypeToFilterDefinitionMap;

package/dist/declarations/src/components/search/standard-filters/enum-filters/enum-filters.d.ts

@@ -0,0 +1,9 @@
+import { TFilterFieldComponentProps } from "../../../../types/filters-types.js";
+import { TCreateStandardFilterMapMeta } from "../../standard-filter-definitions/index.js";
+export type TEnumFilterValue<T> = {
+    value: T | T[];
+};
+export declare const createEnumFilter: <T extends string>({ options, isMulti, isSearchable, }: TCreateStandardFilterMapMeta) => {
+    ({ error, value, onUpdateFilter }: TFilterFieldComponentProps): import("@emotion/react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/declarations/src/components/search/standard-filters/enum-filters/index.d.ts

@@ -0,0 +1 @@
+export * from "./enum-filters.js";

package/dist/declarations/src/components/search/standard-filters/resource-change-filter/resource-change-filter.d.ts

@@ -0,0 +1,16 @@
+import { TResourceChangeInputName, TResourceType } from "../../../../constants/index.js";
+import { TFilterFieldComponentProps } from "../../../../types/filters-types.js";
+import { TCreateStandardFilterMapMeta } from "../../standard-filter-definitions/index.js";
+export type TResourceChangeFilterValue = {
+    resource: TResourceType | null;
+    change: TResourceChangeInputName | null;
+};
+export declare const isResourceChangeFilterValue: (input: any) => input is TResourceChangeFilterValue;
+export type TResourceChangeFilterProps = TFilterFieldComponentProps & {
+    resources: TCreateStandardFilterMapMeta['resources'];
+};
+declare const ResourceChangeFilter: {
+    ({ resources, ...props }: TResourceChangeFilterProps): import("@emotion/react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default ResourceChangeFilter;

package/dist/declarations/src/components/search/standard-filters/stores-filter/stores-filter.d.ts

@@ -0,0 +1,12 @@
+import { TFilterFieldComponentProps } from "../../../../types/filters-types.js";
+export type TStoresFilterValue = Array<{
+    id: string;
+    key: string;
+    label: string;
+    value: string;
+}>;
+declare const StoresFilter: {
+    (props: TFilterFieldComponentProps): import("@emotion/react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default StoresFilter;

package/dist/declarations/src/components/search/standard-filters/text-filter/index.d.ts

@@ -0,0 +1 @@
+export * from "./text-filter.js";

package/dist/declarations/src/components/search/standard-filters/text-filter/text-filter.d.ts

@@ -0,0 +1,6 @@
+import { TFilterFieldComponentProps } from "../../../../types/filters-types.js";
+export type TTextFilterValue = string;
+export declare const TextFilter: {
+    (props: TFilterFieldComponentProps): import("@emotion/react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/declarations/src/constants/filters.d.ts

@@ -1,17 +1,23 @@
+import { TDateFilterType } from "../hooks/use-search-query-state/types.js";
 import { ValueOf } from "../types/common-types.js";
+export declare const quickFilterToday: TDateFilterType;
+export declare const quickFilterYesterday: TDateFilterType;
+export declare const quickFilterLast7Days: TDateFilterType;
+export declare const quickFilterLast30Days: TDateFilterType;
+export declare const quickFilterCustom: TDateFilterType;
 export declare const FILTER_KEY: {
-    readonly API_CLIENT: "apiClientId";
+    readonly API_CLIENT: "clientId";
     readonly BUSINESS_UNIT: "businessUnit";
-    readonly RESOURCE_CHANGE: "resourceChange";
-    readonly CHANGE_TYPE: "changeType";
+    readonly CHANGES: "changes";
+    readonly CHANGE_TYPE: "type";
+    readonly CREATED_AT: "date";
+    readonly CREATED_BY: "userId";
     readonly CUSTOMER_ID: "customerId";
-    readonly CREATED_AT: "createdAt";
-    readonly RESOURCE_ID: "resourceId";
-    readonly RESOURCE_TYPE: "resource.typeId";
     readonly EXCLUDE_PLATFORM_CHANGES: "excludePlatformInitiatedChanges";
     readonly IS_PLATFORM_CLIENT: "isPlatformClient";
+    readonly RESOURCE_ID: "resourceId";
+    readonly RESOURCE_TYPE: "resourceType";
     readonly STORES: "stores";
-    readonly CREATED_BY: "createdBy.id";
 };
 export type TFilterKey = ValueOf<typeof FILTER_KEY>;
 export declare const FILTER_OPERATOR: {

package/dist/declarations/src/constants/old-filters.d.ts

@@ -26,11 +26,6 @@ export declare const FILTER_TYPES: {
 };
 export type TFilterTypeKeys = keyof typeof FILTER_TYPES;
 export type TFilterType = ValueOf<typeof FILTER_TYPES>;
-export declare const quickFilterToday = "today";
-export declare const quickFilterYesterday = "yesterday";
-export declare const quickFilterLast7Days = "last7Days";
-export declare const quickFilterLast30Days = "last30Days";
-export declare const quickFilterCustom = "custom";
 export declare const TOOL_OPTIONS: {
     readonly MERCHANT_CENTER: "MERCHANT_CENTER";
     readonly IMPEX: "IMPEX";

package/dist/declarations/src/hooks/use-search-query-state/types.d.ts

@@ -0,0 +1,105 @@
+import type { TDataTableProps } from '@commercetools-frontend/ui-kit';
+import type { TALFilterValue } from "../../components/search/filters-container/filter-configurations/filter-configurations.js";
+import type { TFilterKey } from "../../constants/index.js";
+import type { TExcludePlatformChangesFilterValue } from "../../types/filters-types.js";
+import { TAppliedFilterValue } from '@commercetools-uikit/filters/dist/declarations/src/filter-menu';
+import { TResourceChangeFilterValue } from "../../components/search/standard-filters/resource-change-filter/resource-change-filter.js";
+import { TStoresFilterValue } from "../../components/search/standard-filters/stores-filter/stores-filter.js";
+import { TTextFilterValue } from "../../components/search/standard-filters/text-filter/index.js";
+import { FILTER_OPTION_KEYS, FILTER_TYPES, TColumns } from "../../constants/index.js";
+import { TISODateString } from "../../types/common-types.js";
+import { TApiClientFilterValue, TBusinessUnitFilterValue, TChangesFilterValue, TEntityTypeFilterValue, TModifiedByFilterValue, TSourceFilterValue } from "../../types/filters-types.js";
+export type TDateRangeFilterValue = {
+    from: TISODateString;
+    to: TISODateString;
+};
+export type TDateFilterType = 'today' | 'yesterday' | 'last7Days' | 'last30Days' | 'custom';
+export type TDateFilter = {
+    hasHours: boolean;
+    selectedFilterType: TDateFilterType;
+    type: 'range' | 'equalTo' | 'lessThan' | 'moreThan';
+    value?: TDateRangeFilterValue;
+};
+export type TSearchQuerySort = {
+    key: TColumns;
+    order: TDataTableProps['sortDirection'];
+};
+export type TOldFilters = {
+    [FILTER_OPTION_KEYS.API_CLIENT]?: Array<{
+        type: typeof FILTER_TYPES.equalTo;
+        value: TApiClientFilterValue;
+    }>;
+    [FILTER_OPTION_KEYS.BUSINESS_UNIT]?: Array<{
+        type: typeof FILTER_TYPES.equalTo;
+        value: TBusinessUnitFilterValue;
+    }>;
+    [FILTER_OPTION_KEYS.CHANGE]?: Array<{
+        type: typeof FILTER_TYPES.resourceChange;
+        value: TResourceChangeFilterValue;
+    }>;
+    [FILTER_OPTION_KEYS.CHANGE_TYPE]?: Array<{
+        type: typeof FILTER_TYPES.equalTo;
+        value: TChangesFilterValue;
+    }>;
+    [FILTER_OPTION_KEYS.CUSTOMER_ID]?: Array<{
+        type: typeof FILTER_TYPES.equalTo;
+        value: TTextFilterValue;
+    }>;
+    [FILTER_OPTION_KEYS.DATE_RANGE]: Array<TDateFilter>;
+    [FILTER_OPTION_KEYS.ENTITY_ID]?: Array<{
+        type: typeof FILTER_TYPES.equalTo;
+        value: TTextFilterValue;
+    }>;
+    [FILTER_OPTION_KEYS.ENTITY_TYPE]?: Array<{
+        type: typeof FILTER_TYPES.in | typeof FILTER_TYPES.equalTo | typeof FILTER_TYPES.missing | typeof FILTER_TYPES.missingIn;
+        value: TEntityTypeFilterValue;
+    }>;
+    [FILTER_OPTION_KEYS.EXCLUDE_PLATFORM_CHANGES]?: Array<{
+        type: typeof FILTER_TYPES.equalTo;
+        value: TExcludePlatformChangesFilterValue;
+    }>;
+    [FILTER_OPTION_KEYS.SOURCE]?: Array<{
+        type: typeof FILTER_TYPES.in;
+        value: TSourceFilterValue;
+    }>;
+    [FILTER_OPTION_KEYS.STORES]?: Array<{
+        type: typeof FILTER_TYPES.equalTo;
+        value: TStoresFilterValue;
+    }>;
+    [FILTER_OPTION_KEYS.MODIFIED_BY]?: Array<{
+        type: typeof FILTER_TYPES.equalTo;
+        value: TModifiedByFilterValue;
+    }>;
+};
+export type TALFilterValueWithoutLabels = Omit<TALFilterValue, 'appliedFilterValues'> & {
+    appliedFilterValues: Array<Omit<TAppliedFilterValue, 'label'>>;
+};
+export type TSearchQueryFilters = Partial<Record<TFilterKey, TALFilterValueWithoutLabels | TDateFilter>>;
+export type TSearchQuery = {
+    filters: TOldFilters | TSearchQueryFilters;
+    page: number;
+    perPage: number;
+    sorting: TSearchQuerySort;
+    columns: TColumns[];
+    displaySettings: {
+        isCondensed: boolean;
+        isWrappingText: boolean;
+    };
+    searchText?: string;
+};
+export type TStoredSearchQuery = TSearchQuery & {
+    __version?: number;
+};
+export type TLocationState = {
+    search: string;
+};
+export type TUseSearchViewRouterStateSearchProps = {
+    storageSlice: string;
+    defaultSearchQuery: TSearchQuery;
+};
+export type TSetSearchQuery = (nextSearchQuery: TSearchQuery) => void;
+export type TUseSearchViewRouterStateSearch = {
+    searchQuery: TSearchQuery;
+    getSearchQuery: () => TSearchQuery;
+    setSearchQuery: TSetSearchQuery;
+};

package/dist/declarations/src/types/filters-types.d.ts

@@ -0,0 +1,152 @@
+import { type JSX } from 'react';
+import { OptionProps } from 'react-select';
+import type { TDateRangeFilterValue } from "../hooks/use-search-query-state/types.js";
+import { TUser } from "../../types/src/generated/change-history.js";
+import { TChangeType, TResourceTypes } from "../components/_types/change-history.js";
+import { TEnumFilterValue } from "../components/search/standard-filters/enum-filters/index.js";
+import { TResourceChangeFilterValue } from "../components/search/standard-filters/resource-change-filter/resource-change-filter.js";
+import { TStoresFilterValue } from "../components/search/standard-filters/stores-filter/stores-filter.js";
+import { TTextFilterValue } from "../components/search/standard-filters/text-filter/index.js";
+import { FILTER_OPTION_KEYS, TFilterOptionKey, TFilterType, TFilterTypeKeys, TResourceType, TToolOptions } from "../constants/index.js";
+import { TIntl, ValueOf } from "./common-types.js";
+export type TAvailableFilter = {
+    key: TFilterOptionKey;
+    resources?: Array<TResourceType>;
+};
+export type TAvailableFilters = Array<TAvailableFilter>;
+export type TAllFilterDefinitions = {
+    [key in ValueOf<typeof FILTER_OPTION_KEYS>]: TFilterConfig;
+};
+export type TFilteredFilterDefinitions = Partial<TAllFilterDefinitions>;
+export type TFilterConfig = {
+    label: string;
+    filterTypes: TFilterTypeToFilterDefinitionMap;
+    isHidden?: boolean;
+    isSearchable?: boolean;
+    tooltip?: React.ReactNode | undefined;
+    disabledForBasic?: boolean;
+};
+export type TFilterTypeToFilterDefinitionMap = Partial<{
+    [key in TFilterType]: TFilterDefinition;
+}>;
+export type TFilterDefinition = {
+    filterComponent: React.ComponentType<TFilterFieldComponentProps> | ((props: TFilterFieldComponentProps) => JSX.Element);
+    tagComponent: React.ComponentType<TFilterFieldTagsProps> | ((props: TFilterFieldTagsProps) => JSX.Element);
+    label: string;
+    canBeAppliedMultipleTimes?: boolean;
+    isEmptyFilter?: () => boolean;
+    validator?: TValidatorFunction;
+};
+export type TFilterComponentProps = {
+    fieldName: string;
+    fieldFilters?: TFieldFilter;
+    filterConfig: TFilterConfig;
+    onAddFilterToField: (options: TAddFilterOptions) => void;
+    onRemoveFilterFromField: (options: TRemoveFilterOptions) => void;
+    onUpdateFilterForField: (options: TUpdateFilterOptions) => void;
+    onRemoveFilterTagFromField: (options: {
+        index: number;
+        fieldName: string;
+    }) => void;
+    onToggleEditMode: (forceIsToggled?: boolean) => void;
+};
+export type TFilterFieldComponentProps = {
+    value?: TFieldFilterValue;
+    error?: string;
+    onUpdateFilter: (value?: TFieldFilterValue | null) => void;
+};
+export type TFilterFieldTagsProps = {
+    fieldLabel: TFilterConfig['label'];
+    filterTypeLabel: TFilterDefinition['label'];
+    value: TFieldFilter[number]['value'];
+    onRemove: () => void;
+    onClick: () => void;
+};
+export type TDateError = {
+    from?: string;
+    to?: string;
+};
+export type TValidatorFunction = (filter: {
+    type: TFilterTypeKeys;
+    value: TFieldFilterValue;
+}, intl: TIntl) => TDateError | string | null;
+export interface ICustomOptionProps extends OptionProps<any, any> {
+    isDisabledForBasic?: boolean;
+}
+export type TFiltersProps = {
+    filterDefinitions: TFilteredFilterDefinitions;
+    filteredFields: TFilteredFields;
+    filtersListMaxMenuHeight?: number;
+    isEditMode: boolean;
+    hasChangesInFilters?: boolean;
+    isOrderCustomFieldLoading?: boolean;
+    enableCustomFilterStyle?: boolean;
+    onClearFiltersFromField?: Function;
+    onAddField: Function;
+    onUpdateQuickFilterForField?: (options: {
+        fieldName: string;
+        filter: TFilter;
+    }) => void;
+    onAddFilterToField: (options: TAddFilterOptions) => void;
+    onApplyFilters: (options: {
+        removeEmptyFilters: boolean;
+    }) => boolean;
+    onCancelFilterChanges: () => void;
+    onClearAll: () => void;
+    onRemoveFilterFromField: (options: TRemoveFilterOptions) => void;
+    onRemoveFilterTagFromField: (options: {
+        index: number;
+        fieldName: string;
+    }) => void;
+    onToggleEditMode: (forceIsToggled?: boolean) => void;
+    onUpdateFilterForField: (options: TUpdateFilterOptions) => void;
+    showApplyButton?: boolean;
+    showSaveActions?: boolean;
+    showOnClearAll?: boolean;
+    tagDelimiter?: string;
+};
+export type TApiClientFilterValue = TEnumFilterValue<string>;
+export type TBusinessUnitFilterValue = {
+    label: string;
+    value: string;
+};
+export type TChangesFilterValue = TEnumFilterValue<TChangeType>;
+export type TEntityTypeFilterValue = TEnumFilterValue<TResourceTypes>;
+export type TExcludePlatformChangesFilterValue = {
+    value: ['excludeAll'] | null;
+};
+export type TSourceFilterValue = TEnumFilterValue<TToolOptions>;
+export type TModifiedByFilterValue = TEnumFilterValue<TUser['id']>;
+export type TFieldFilterValue = TApiClientFilterValue | TBusinessUnitFilterValue | TResourceChangeFilterValue | TChangesFilterValue | TEntityTypeFilterValue | TSourceFilterValue | TStoresFilterValue | TTextFilterValue | TDateRangeFilterValue | TExcludePlatformChangesFilterValue | null;
+export type TFieldFilter = Array<{
+    type: TFilterTypeKeys;
+    value?: TFieldFilterValue;
+    error?: string;
+}>;
+export type TFilter = TFieldFilter[number];
+export type TFilteredFields = {
+    [key in TFilterOptionKey]?: TFieldFilter;
+};
+type TBaseFilterOptions = {
+    fieldName: string;
+    index: number;
+};
+export type TAddFilterOptions = TBaseFilterOptions & {
+    filter: object;
+};
+export type TRemoveFilterOptions = TBaseFilterOptions;
+export type TUpdateFilterOptions = TBaseFilterOptions & {
+    filter: object;
+};
+export type TAddFilterTypeOptions = {
+    filter: Pick<TFieldFilter[number], 'type' | 'value'>;
+    index: number;
+};
+export type TRemoveFilterTypeOptions = {
+    index: number;
+};
+export type TUpdateFilterTypeOptions = {
+    filter: Pick<TFieldFilter[number], 'type' | 'value'>;
+    index: number;
+};
+export {};