@bynder/compact-view 5.0.2 → 5.1.0

package/auth/loginwindow.d.ts

@@ -0,0 +1,7 @@
+import { Result } from './result.type';
+interface LoginWindowResponse {
+    state: string | null;
+    code: string | null;
+}
+export declare function waitForAuthorizationFromLoginWindow(url: string): Promise<Result<LoginWindowResponse, string>>;
+export {};

package/auth/oauth2.d.ts

@@ -0,0 +1,16 @@
+import { Result } from './result.type';
+export declare const redirectOrigin: string;
+export type AuthPlatform = 'bynder' | 'webdam' | 'invalid';
+export declare function makeAuthorizeRequestUrl(codeChallenge: string, state: string, accountDomain: string): string;
+interface TokenRequest {
+    refreshToken: string;
+    accessToken: string;
+    expiresIn: string;
+}
+export declare function postTokenRequest(code: string, code_verifier: string, accountDomain: string): Promise<Result<TokenRequest, string>>;
+interface RefreshTokenRequest {
+    accessToken: string;
+    expiresIn: number;
+}
+export declare function postRefreshTokenRequest(refreshToken: string, accountDomain: string): Promise<Result<RefreshTokenRequest, string>>;
+export {};

package/auth/result.type.d.ts

@@ -0,0 +1,13 @@
+export type Ok<T> = {
+    tag: 'ok';
+    value: T;
+};
+export interface Err<E> {
+    tag: 'error';
+    error: E;
+}
+export type Result<T, E> = Ok<T> | Err<E>;
+export declare function ok<T>(value: T): Ok<T>;
+export declare function err<E>(error: E): Err<E>;
+export declare function isOk<T, E = unknown>(result: Result<T, E>): result is Ok<T>;
+export declare function isErr<E, T = unknown>(result: Result<T, E>): result is Err<E>;

package/auth/useAuthInformation.d.ts

@@ -0,0 +1,18 @@
+interface SetAuthInformationParameters {
+    getAccessToken: () => string;
+    expiresIn?: number;
+    refreshToken?: string;
+    accountDomain?: string;
+}
+export type AuthStatus = 'authenticated' | 'not-authenticated' | 'refreshing';
+export interface AuthInformationState {
+    getAccessToken?: () => string;
+    accountDomain?: string;
+    status: AuthStatus;
+}
+export declare function useAuthInformation(): [
+    AuthInformationState,
+    (info: SetAuthInformationParameters) => void,
+    () => void
+];
+export {};

package/common/components/CardSkeleton.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface Props {
+    title?: React.ReactNode;
+    rows: number;
+    columns: number;
+}
+export declare function CardSkeleton(props: Props): React.JSX.Element;
+export {};

package/common/components/Checkbox.styles.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+export declare const StyledCheckboxWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $isLoading?: boolean | undefined;
+    $isChecked: boolean;
+    $isFlex?: boolean | undefined;
+}>> & string;
+export declare const ListItem: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, never>> & string;
+export declare const Content: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $isChecked: boolean;
+}>> & string;
+export declare const Label: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;

package/common/components/Chip.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface Props {
+    loading?: boolean;
+    active?: boolean;
+    onClick?: () => void;
+    children: React.ReactNode;
+    ['data-testid']?: string;
+}
+export declare function Chip(props: Props): React.JSX.Element;
+export {};

package/common/components/DocumentIcon.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function DocumentIcon(): React.JSX.Element;

package/common/components/DragSelect.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+export type DragAction = 'select' | 'inverse';
+type Rect = {
+    left: number;
+    top: number;
+    height: number;
+    width: number;
+};
+type Position = {
+    x: number | null;
+    y: number | null;
+};
+type Props = {
+    dragContainer: string;
+    selectionBoxCustomAttr: React.HTMLAttributes<HTMLElement>;
+    onSelect: (selectedIds: string[]) => void;
+    onDeselect: (deselectedIds: string[]) => void;
+    onDragStart?: (action: DragAction) => void;
+    onDragEnd?: (action: DragAction) => void;
+};
+export declare const DragSelect: ({ dragContainer, selectionBoxCustomAttr, onSelect, onDeselect, onDragStart, onDragEnd, }: Props) => React.ReactPortal | null;
+export declare const makeSelectable: ({ id }: {
+    id: string;
+}) => {
+    "data-drag-select-id": string;
+};
+export declare const getSelectionBoxRect: (start: Position, end: Position, rootElement: Element | null) => Rect;
+export {};

package/common/components/HorizontalScroll.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface Props {
+    static?: React.ReactNode;
+    children: React.ReactNode;
+    isActiveFilter?: boolean;
+}
+export declare function HorizontalScroll(props: Props): React.JSX.Element;
+export {};

package/common/components/InfiniteScroll.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface Props {
+    isLoading: boolean;
+    hasNextPage: boolean;
+    loadMore: () => void;
+    children: React.ReactNode;
+}
+export declare function InfiniteScroll(props: Props): React.JSX.Element;
+export {};

package/common/components/LeftArrow.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function LeftArrow(props: Readonly<{
+    isDisabled: boolean;
+    onClick: () => void;
+}>): React.JSX.Element;

package/common/components/Modal.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export declare const useModalContext: () => {
+    onClose: () => void;
+} | null;
+interface Props {
+    children: React.ReactNode;
+    isOpen?: boolean;
+    style?: React.CSSProperties;
+    onClose?: () => void;
+}
+export declare function Modal({ children, isOpen, style, onClose, }: Props): React.JSX.Element | null;
+export {};

package/common/components/NoResults.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface Props {
+    onReset: () => void;
+}
+export declare function NoResults(props: Props): React.JSX.Element;
+export {};

package/common/components/RightArrow.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function RightArrow(props: Readonly<{
+    isDisabled: boolean;
+    onClick: () => void;
+}>): React.JSX.Element;

package/common/components/Skeleton.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface Props {
+    width?: number;
+}
+export declare function Skeleton({ width }: Props): React.JSX.Element;
+export {};

package/common/components/Spinner.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface Props {
+    isRelative?: boolean;
+    isHidden?: boolean;
+    isRefreshingSpinner?: boolean;
+    isNotUsingMargin?: boolean;
+}
+export declare function Spinner(props: Props): React.JSX.Element;
+export {};

package/common/components/Tooltip.d.ts

@@ -0,0 +1,13 @@
+import React, { ReactNode } from 'react';
+type TooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+type TooltipMargin = 'top' | 'bottom' | 'left' | 'right';
+type TooltipMarginAmount = 'spacing1' | 'spacing2' | 'spacing3' | 'spacing4' | 'spacing5';
+interface TooltipProps {
+    text: string;
+    position?: TooltipPosition;
+    margin?: TooltipMargin;
+    marginAmount?: TooltipMarginAmount;
+    children?: ReactNode;
+}
+export declare const Tooltip: ({ text, position, margin, marginAmount, children, }: TooltipProps) => React.JSX.Element;
+export {};

package/common/components/__mocks__/Tooltip.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+declare const Tooltip: ({ text, children }: {
+    text: any;
+    children: any;
+}) => React.JSX.Element;
+export { Tooltip };

package/common/components/__tests__/utils.d.ts

@@ -0,0 +1,34 @@
+export declare const mockConfig: {
+    theme: {
+        colorPrimary: string;
+        colorButtonPrimary: string;
+        colorButtonPrimaryLabel: string;
+        colorButtonPrimaryActive: string;
+        colorButtonPrimaryHover: string;
+        colorButtonPrimaryHoverLabel: string;
+    };
+    assetTypes: import("../../..").assetType[];
+    language: string;
+    onSuccess: import("../../..").OnSuccessCallback;
+    assetFieldSelection?: string | undefined;
+    assetFilter?: import("../../..").assetFilter | undefined;
+    mode?: import("../../..").selectionMode | undefined;
+    hideExternalAccess?: boolean | undefined;
+    __shouldAddOriginal__?: boolean | undefined;
+    hideSwitch?: boolean | undefined;
+    noCache?: boolean | undefined;
+    selectAllOption?: boolean | undefined;
+    selectionMode: import("../../..").selectionMode;
+};
+export declare const regularButtonStyle: {
+    background: string;
+    color: string;
+};
+export declare const hoverButtonStyle: {
+    background: string;
+    color: string;
+};
+export declare const activeButtonStyle: {
+    background: string;
+    color: string;
+};

package/common/components/dropdown/Dropdown.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+interface Props {
+    className?: string;
+    fadeIn?: boolean;
+    buttonKind?: 'clean' | 'secondary';
+    isSmall?: boolean;
+    direction?: 'Down' | 'Up';
+    title: React.ReactNode;
+    alt?: string;
+    disabled?: boolean;
+    isPaddingContent?: boolean;
+    isMetapropertyDropdown?: boolean;
+    children: (toggle: () => void) => React.ReactNode;
+}
+export declare function Dropdown({ buttonKind, direction, isSmall, fadeIn, isMetapropertyDropdown, ...props }: Props): React.JSX.Element;
+export {};

package/common/components/dropdown/DropdownContent.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+interface DropdownContentProps {
+    onClickOutside: () => void;
+    direction: 'Down' | 'Up';
+    target: React.MutableRefObject<Element | null>;
+    children: React.ReactNode;
+    id: string;
+    isPaddingContent?: boolean;
+    isMetapropertyDropdown?: boolean;
+}
+export declare function DropdownContent(props: DropdownContentProps): React.ReactPortal | null;
+export {};

package/common/components/dropdown/DropdownListItem.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface ListItemProps {
+    className?: string;
+    onClick?: () => void;
+    selected?: boolean;
+    children: React.ReactNode;
+    isFieldSelect?: boolean;
+}
+export declare function DropdownListItem({ selected, ...props }: ListItemProps): React.JSX.Element;
+export {};

package/common/hooks/useClickOutside.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function useClickOutside(targetRefs: React.MutableRefObject<Element | null>[], handler: () => void): void;

package/common/hooks/useDimensions.d.ts

@@ -0,0 +1,9 @@
+export interface Dimensions {
+    width: number;
+    height: number;
+    scrollWidth: number;
+}
+export declare function useDimensions(node: Element | null): {
+    dimensions?: Dimensions;
+    remeasure: (newNode?: Element | null) => void;
+};

package/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const WEBDAM_TRANSFORM_BASE_URL_NAME = "transformBaseURL";
+export declare const BYNDER_TRANSFORM_BASE_URL_NAME = "transformBaseUrl";
+export declare const DATE_METAPROPERTY_TYPE = "date";
+export declare const DATE_METAPROPERTY_LOCALE = "en-GB";
+export declare const DATE_METAPROPERTY_OPTIONS: Intl.DateTimeFormatOptions;
+export declare const MAX_METAPROPERTY_LENGTH = 100;
+export declare const MAX_GET_ASSETS_LIMIT = 280;

package/error-handling/ErrorIcon.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function ErrorIcon(): React.JSX.Element;

package/error-handling/ErrorMessage.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare function ErrorMessage(props: {
+    isReportSent: boolean;
+    onClickSend: () => void;
+    onClickRetry: () => void;
+}): React.JSX.Element;

package/error-handling/Oops.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { BrowserClient } from '@sentry/browser';
+interface Props {
+    error: Error;
+    onRetry: () => void;
+    sentryClient?: BrowserClient;
+}
+export declare function Oops({ error, onRetry, sentryClient }: Props): React.JSX.Element;
+export {};

package/error-handling/ReportModal.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export declare function ReportModal(props: {
+    isOpen: boolean;
+    error: Error;
+    container: Element;
+    onDone: () => void;
+    onCancel: () => void;
+}): React.JSX.Element;

package/error-handling/Shield.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { BrowserClient } from '@sentry/browser';
+interface Props {
+    children: React.ReactNode;
+    sentryClient?: BrowserClient;
+}
+interface State {
+    error: Error | null;
+}
+export declare class Shield extends React.Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    render(): string | number | boolean | React.JSX.Element | Iterable<React.ReactNode> | null | undefined;
+}
+export {};

package/error-handling/__tests__/utils.d.ts

@@ -0,0 +1,56 @@
+export declare function renderShield(options: any, sentryClient?: any): {
+    rerender: (rerenderOptions: any) => any;
+    container: HTMLElement;
+    baseElement: HTMLElement;
+    debug: (baseElement?: Element | DocumentFragment | (Element | DocumentFragment)[] | undefined, maxLength?: number | undefined, options?: import("pretty-format").PrettyFormatOptions | undefined) => void;
+    unmount: () => void;
+    asFragment: () => DocumentFragment;
+    getByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement;
+    getAllByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement[];
+    queryByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement | null;
+    queryAllByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement[];
+    findByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement;
+    getAllByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement[];
+    queryByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement | null;
+    queryAllByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement[];
+    findByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined) => HTMLElement;
+    getAllByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined) => HTMLElement[];
+    queryByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined) => HTMLElement | null;
+    queryAllByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined) => HTMLElement[];
+    findByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+};

package/filter/AssetFilter.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function AssetFilter(): React.JSX.Element | null;

package/filter/AssetFilterContext.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+import { AssetType } from '../views/asset/asset.type';
+import { MetapropertyOptionType as MetapropertyOption } from './filters/metaproperty/MetapropertyOption';
+import { AssetFilterJson } from '@src/filter/assetFilter.type';
+import { AutcompleteResponseOption, SmartfilterOption, selectedSmartfilterOptionsType, AssetCountType } from '@src/api/rest/types';
+export interface Filter {
+    assetTypes: AssetType[];
+    metaproperties: MetapropertyOption[];
+    metapropertyIds?: string[];
+    tags: string[];
+    isLimited?: boolean;
+    isDropdownActive?: boolean;
+    selectedSmartfilterOptions?: selectedSmartfilterOptionsType;
+    existingFilters?: Record<string, Record<string, number>> | null;
+}
+interface Actions {
+    addAssetType: (assetType: AssetType) => void;
+    removeAssetType: (assetType: AssetType) => void;
+    addMetaproperty: (metaproperty: MetapropertyOption) => void;
+    removeMetaproperty: (metaproperty: MetapropertyOption) => void;
+    setPredefinedMetaproperties: (metaproperties: Record<string, MetapropertyOption>) => void;
+    addTag: (tag: string) => void;
+    removeTag: (tag: string) => void;
+    clear: () => void;
+    setDropdownState: (active: boolean) => void;
+    selectSmartfilterOption: (metapropertyName: string, option: SmartfilterOption | AutcompleteResponseOption, isMultifilter?: boolean) => void;
+    removeSmartfilterOption: (metapropertyName: string, optionId: string) => void;
+    setActiveFiltersState: (count: AssetCountType) => void;
+}
+type MetapropertyMapType = Record<string, MetapropertyOption>;
+export declare const AssetFilterContext: React.Context<(Filter & Actions) | null>;
+export declare function AssetFilterProvider({ children, hideLimitedUse, predefinedFilter, }: {
+    children: React.ReactNode;
+    hideLimitedUse?: boolean;
+    predefinedFilter?: AssetFilterJson;
+}): React.JSX.Element;
+export declare function keepPredefinedMetapropertiesInMap(metapropertyMap: MetapropertyMapType, predefinedMetaproperties: string[]): {};
+export declare function useAssetFilter(): Filter & Actions;
+export {};

package/filter/__tests__/utils.d.ts

@@ -0,0 +1,13 @@
+export declare function renderAssetFilter({ options, predefinedFilters, assetIds, withExtension, }: {
+    options?: any;
+    predefinedFilters?: any;
+    assetIds?: string[];
+    withExtension?: boolean;
+}): void;
+export declare const customAssetFilterRender: (ui: any, { predefinedFilter, providedProps, assetIds, withExtension, ...renderOptions }: {
+    [x: string]: any;
+    predefinedFilter: any;
+    providedProps: any;
+    assetIds?: never[] | undefined;
+    withExtension?: boolean | undefined;
+}) => void;

package/filter/active-filters/ActiveFilter.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare function ActiveFilter(props: {
+    onClick?: () => void;
+    title: string;
+    icon?: React.ReactNode;
+}): React.JSX.Element;

package/filter/active-filters/ActiveFilters.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function ActiveFilters(): React.JSX.Element;

package/filter/assetFilter.type.d.ts

@@ -0,0 +1,10 @@
+import { AssetType } from '../views/asset/asset.type';
+export interface AssetFilterJson {
+    predefinedAssetType?: AssetType[];
+    collectionId?: string;
+    predefinedMetapropertiesOptions?: Record<string, Record<string, string>>;
+    searchTerm?: string;
+    predefinedTagNames?: string[];
+    isLimitedUse?: boolean;
+    showToolbar?: boolean;
+}

package/filter/filters/advanced/Advanced.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+interface Count {
+    audio: number;
+    document: number;
+    image: number;
+    video: number;
+    archive: number;
+}
+interface AdvancedProps {
+    isLoading: boolean;
+    count: Count;
+}
+export declare function Advanced(props: AdvancedProps): React.JSX.Element | null;
+export {};

package/filter/filters/advanced/AssetTypeItem.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { AssetType } from '../../../views/asset/asset.type';
+export declare function AssetTypeItem(props: {
+    type: AssetType;
+    count: number;
+    isLoading: boolean;
+}): React.JSX.Element;

package/filter/filters/metaproperty/Metaproperty.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { MetapropertyType } from './MetapropertyFilterContent';
+import { SmartfilterType } from './SmartFilterContent';
+interface Props {
+    metapropertyFilters: Array<MetapropertyType | SmartfilterType>;
+    isLoading: boolean;
+}
+export declare function Metaproperty(props: Props): React.JSX.Element;
+export {};

package/filter/filters/metaproperty/MetapropertyFilterContent.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { MetapropertyOptionType } from './MetapropertyOption';
+export interface MetapropertyType {
+    __typename: 'Metaproperty';
+    id: string;
+    label: string;
+    zIndex: number;
+    options: MetapropertyOptionType[];
+    showInGridView: boolean;
+    showInListView: boolean;
+}
+interface MetapropertyProps {
+    metaproperty: MetapropertyType;
+    selectedOptionIds: string[];
+    isLoading: boolean;
+    onAddOption: (metapropertyOption: MetapropertyOptionType) => void;
+    onRemoveOption: (metapropertyOption: MetapropertyOptionType) => void;
+}
+export declare function MetaPropertyFilterContent(props: MetapropertyProps): React.JSX.Element;
+export interface Tag {
+    id: string;
+    name: string;
+    assetCount: number;
+}
+export {};

package/filter/filters/metaproperty/MetapropertyOption.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+export interface MetapropertyOptionType {
+    id: string;
+    label: string;
+    assetCount: number;
+}
+interface MetapropertyOptionProps {
+    metapropertyOption: MetapropertyOptionType;
+    selectedOptionIds?: string[];
+    isLoading?: boolean;
+    onAddOption: () => void;
+    onRemoveOption: () => void;
+}
+export declare function MetapropertyOptionComponent(props: MetapropertyOptionProps): React.JSX.Element;
+export {};

package/filter/filters/metaproperty/SmartFilterContent.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { MetapropertyType } from './MetapropertyFilterContent';
+import { MetapropertyOptionType } from './MetapropertyOption';
+export interface SmartfilterType {
+    __typename: 'Smartfilter';
+    id: string;
+    label: string;
+    metaproperties: MetapropertyType[];
+    icon?: string;
+    zIndex: number;
+}
+interface SmartfilterProps {
+    smartfilter: SmartfilterType;
+    selectedOptionIds: string[];
+    isLoading: boolean;
+    onAddOption: (metapropertyOption: MetapropertyOptionType) => void;
+    onRemoveOption: (metapropertyOption: MetapropertyOptionType) => void;
+}
+export declare function SmartFilterContent(props: SmartfilterProps): React.JSX.Element;
+export {};