@atlaskit/emoji 65.2.0 → 66.0.0

package/dist/types-ts4.0/components/common/Emoji.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="react" />
+import { EmojiDescription, OnEmojiEvent } from '../../types';
+export interface Props {
+    /**
+     * The emoji to render
+     */
+    emoji: EmojiDescription;
+    /**
+     * Show the emoji as selected
+     */
+    selected?: boolean;
+    /**
+     * Automatically show the emoji as selected based on mouse hover.
+     * CSS, fast, does not require a re-render, but selected state not
+     * externally controlled via props.
+     */
+    selectOnHover?: boolean;
+    /**
+     * Called when an emoji is selected
+     */
+    onSelected?: OnEmojiEvent;
+    /**
+     * Called when the mouse moves over the emoji.
+     */
+    onMouseMove?: OnEmojiEvent;
+    /**
+     * Called when an emoji is deleted
+     */
+    onDelete?: OnEmojiEvent;
+    /**
+     * Callback for if an emoji image fails to load.
+     */
+    onLoadError?: OnEmojiEvent<HTMLImageElement>;
+    /**
+     * Additional css classes, if required.
+     */
+    className?: string;
+    /**
+     * Show a tooltip on mouse hover.
+     */
+    showTooltip?: boolean;
+    /**
+     * Show a delete button on mouse hover
+     * Used only for custom emoji
+     */
+    showDelete?: boolean;
+    /**
+     * Fits emoji to height in pixels, keeping aspect ratio
+     */
+    fitToHeight?: number;
+    shouldBeInteractive?: boolean;
+}
+export declare const SpriteEmoji: (props: Props) => JSX.Element;
+export declare const ImageEmoji: (props: Props) => JSX.Element;
+export declare const Emoji: (props: Props) => JSX.Element;
+export default Emoji;

package/dist/types-ts4.0/components/common/EmojiActions.d.ts

@@ -0,0 +1,31 @@
+import { FC } from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { EmojiDescription, EmojiDescriptionWithVariations, Message, OnToneSelected, OnToneSelectorCancelled, ToneSelection } from '../../types';
+import { OnDeleteEmoji } from '../common/EmojiDeletePreview';
+import { OnUploadEmoji } from '../common/EmojiUploadPicker';
+export interface Props {
+    selectedTone?: ToneSelection;
+    onToneSelected?: OnToneSelected;
+    onToneSelectorCancelled?: OnToneSelectorCancelled;
+    toneEmoji?: EmojiDescriptionWithVariations;
+    uploading: boolean;
+    uploadEnabled: boolean;
+    emojiToDelete?: EmojiDescription;
+    initialUploadName?: string;
+    uploadErrorMessage?: Message;
+    onUploadCancelled: () => void;
+    onUploadEmoji: OnUploadEmoji;
+    onCloseDelete: () => void;
+    onDeleteEmoji: OnDeleteEmoji;
+    onFileChooserClicked?: () => void;
+    onOpenUpload: () => void;
+    query?: string;
+    onChange: any;
+}
+declare type PropsWithWrappedComponentPropsType = Props & WrappedComponentProps;
+declare type EmojiActionsProps = PropsWithWrappedComponentPropsType;
+export declare const EmojiActions: FC<EmojiActionsProps>;
+declare const _default: FC<import("react-intl-next").WithIntlProps<PropsWithWrappedComponentPropsType>> & {
+    WrappedComponent: import("react").ComponentType<PropsWithWrappedComponentPropsType>;
+};
+export default _default;

package/dist/types-ts4.0/components/common/EmojiButton.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { EmojiDescription } from '../../types';
+export interface Props {
+    emoji: EmojiDescription;
+    onSelected?: () => void;
+    selectOnHover?: boolean;
+    ariaLabelText?: string;
+    ariaExpanded?: boolean;
+    shouldHideButton?: boolean;
+}
+export declare const EmojiButton: React.ForwardRefExoticComponent<Props & React.RefAttributes<HTMLButtonElement>>;
+export default EmojiButton;

package/dist/types-ts4.0/components/common/EmojiDeletePreview.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { WrappedComponentProps } from 'react-intl-next';
+import { EmojiDescription } from '../../types';
+export interface OnDeleteEmoji {
+    (emoji: EmojiDescription): Promise<boolean>;
+}
+export interface Props {
+    emoji: EmojiDescription;
+    onDeleteEmoji: OnDeleteEmoji;
+    onCloseDelete: () => void;
+    errorMessage?: string;
+}
+export interface State {
+    loading: boolean;
+    error: boolean;
+}
+declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: import("react").ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.0/components/common/EmojiErrorMessage.d.ts

@@ -0,0 +1,10 @@
+import { FC } from 'react';
+import { Message } from '../../types';
+import { SerializedStyles } from '@emotion/core';
+export interface Props {
+    message: Message;
+    tooltip?: boolean;
+    messageStyles: SerializedStyles;
+}
+declare const EmojiErrorMessage: FC<Props>;
+export default EmojiErrorMessage;

package/dist/types-ts4.0/components/common/EmojiImage.d.ts

@@ -0,0 +1,13 @@
+import { FC } from 'react';
+import { EmojiId, EmojiImageRepresentation } from '../../types';
+declare type EmojiImageType = {
+    emojiId: EmojiId;
+    imageUrl: string;
+    showImageBeforeLoad?: boolean;
+    maxSize?: number;
+    representation?: EmojiImageRepresentation;
+    showTooltip?: boolean;
+    onImageLoadError?: () => void;
+};
+export declare const EmojiImage: FC<EmojiImageType>;
+export {};

package/dist/types-ts4.0/components/common/EmojiPlaceholder.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { EmojiImageRepresentation } from '../../types';
+export interface Props {
+    shortName: string;
+    size?: number;
+    showTooltip?: boolean;
+    representation?: EmojiImageRepresentation;
+    loading?: boolean;
+}
+declare const EmojiPlaceholder: (props: Props) => JSX.Element;
+export default EmojiPlaceholder;

package/dist/types-ts4.0/components/common/EmojiPreviewComponent.d.ts

@@ -0,0 +1,7 @@
+import { EmojiDescription } from '../../types';
+import { FC } from 'react';
+declare type Props = {
+    emoji: EmojiDescription;
+};
+export declare const EmojiPreviewComponent: FC<Props>;
+export {};

package/dist/types-ts4.0/components/common/EmojiUploadPicker.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { EmojiUpload, Message } from '../../types';
+export interface OnUploadEmoji {
+    (upload: EmojiUpload, retry: boolean, onSuccessHandler?: () => void): void;
+}
+export interface Props {
+    onUploadEmoji: OnUploadEmoji;
+    onUploadCancelled: () => void;
+    onFileChooserClicked?: () => void;
+    errorMessage?: Message;
+    initialUploadName?: string;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.0/components/common/EmojiUploadPreview.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { WrappedComponentProps } from 'react-intl-next';
+import { Message } from '../../types';
+import { UploadStatus } from './internal-types';
+export interface EmojiUploadPreviewProps {
+    name: string;
+    previewImage: string;
+    uploadStatus?: UploadStatus;
+    errorMessage?: Message;
+    onUploadCancelled: () => void;
+    onAddEmoji: () => void;
+}
+declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<EmojiUploadPreviewProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: import("react").ComponentType<EmojiUploadPreviewProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.0/components/common/FileChooser.d.ts

@@ -0,0 +1,11 @@
+import { FC, ChangeEventHandler } from 'react';
+export interface Props {
+    label: string;
+    ariaDescribedBy?: string;
+    onChange?: ChangeEventHandler<any>;
+    onClick?: () => void;
+    accept?: string;
+    isDisabled?: boolean;
+}
+declare const FileChooser: FC<Props>;
+export default FileChooser;

package/dist/types-ts4.0/components/common/LoadingEmojiComponent.d.ts

@@ -0,0 +1,32 @@
+import { Component, ComponentType } from 'react';
+import { EmojiProvider } from '../../api/EmojiResource';
+export interface Props {
+    /**
+     * Emoji Resource instance
+     */
+    emojiProvider: Promise<EmojiProvider>;
+}
+export interface State {
+    loadedEmojiProvider?: EmojiProvider;
+    asyncLoadedComponent?: ComponentType<any>;
+}
+/**
+ * A base class for components that don't want to start rendering
+ * until the EmojiProvider is resolved.
+ * Notes: super.componentDidMount and super.componentWillUnmount will need to be
+ * called explicitly if they are overridden on the child class.
+ */
+export default abstract class LoadingEmojiComponent<P extends Props, S extends State> extends Component<P, S> {
+    private isUnmounted;
+    constructor(props: P, state: S);
+    componentDidMount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: Readonly<P>): void;
+    componentWillUnmount(): void;
+    private loadEmojiProvider;
+    private loaded;
+    abstract asyncLoadComponent(): void;
+    protected setAsyncState(asyncLoadedComponent: ComponentType<any>): void;
+    renderLoading(): JSX.Element | null;
+    abstract renderLoaded(loadedEmojiProvider: EmojiProvider, asyncLoadedComponent: ComponentType<any>): JSX.Element | null;
+    render(): JSX.Element | null;
+}

package/dist/types-ts4.0/components/common/Popup.d.ts

@@ -0,0 +1,12 @@
+import { ReactElement, FC } from 'react';
+import { RelativePosition } from '../../types';
+export interface Props {
+    target: string | Element;
+    relativePosition?: RelativePosition;
+    offsetX?: number;
+    offsetY?: number;
+    zIndex?: string | number;
+    children: ReactElement<any>;
+}
+declare const Popup: FC<Props>;
+export default Popup;

package/dist/types-ts4.0/components/common/RecordSelectionDefault.d.ts

@@ -0,0 +1,12 @@
+import { EmojiInsertionAnalytic } from '../../util/analytics';
+import { OnEmojiEvent } from '../../types';
+import { EmojiProvider } from '../../api/EmojiResource';
+/**
+ * A function that will wrap any configured Emoji 'onSelection' function to ensure recordSelection is always
+ * called.
+ *
+ * @param provider the EmojiProvider which will be called on each emoji selection
+ * @param onSelect the onSelect function that is explicitly configured on the Emoji component.
+ * @param fireAnalytics a function used to fire analytics events.
+ */
+export declare const createRecordSelectionDefault: <T>(provider: EmojiProvider, onSelect?: OnEmojiEvent<T> | undefined, fireAnalytics?: ((producer: EmojiInsertionAnalytic) => void) | undefined) => OnEmojiEvent<T>;

package/dist/types-ts4.0/components/common/ResourcedEmoji.d.ts

@@ -0,0 +1,18 @@
+import React, { FC } from 'react';
+import { ComponentClass } from 'react';
+import LoadingEmojiComponent, { Props as LoadingProps, State as LoadingState } from './LoadingEmojiComponent';
+import EmojiProvider from '../../api/EmojiResource';
+import { Props as ComponentProps, BaseResourcedEmojiProps } from './ResourcedEmojiComponent';
+export interface Props extends BaseResourcedEmojiProps, LoadingProps {
+}
+export default class ResourcedEmoji extends LoadingEmojiComponent<Props, LoadingState> {
+    static AsyncLoadedComponent: FC<ComponentProps>;
+    state: {
+        asyncLoadedComponent: React.FC<ComponentProps>;
+    };
+    constructor(props: Props);
+    componentWillUnmount(): void;
+    asyncLoadComponent(): void;
+    renderLoading(): JSX.Element;
+    renderLoaded(loadedEmojiProvider: EmojiProvider, ResourcedEmojiComponent: ComponentClass<ComponentProps>): JSX.Element;
+}

package/dist/types-ts4.0/components/common/ResourcedEmojiComponent.d.ts

@@ -0,0 +1,48 @@
+import { FC } from 'react';
+import { EmojiResource } from '../../api/EmojiResource';
+import { EmojiId } from '../../types';
+export interface BaseResourcedEmojiProps {
+    /**
+     * Emoji to display
+     */
+    emojiId: EmojiId;
+    /**
+     * Allows to show the tooltip.
+     * Defaults to `false`.
+     */
+    showTooltip?: boolean;
+    /**
+     * Scales the emoji proportionally to provided hight.
+     * Defaults to `undefined`.
+     */
+    fitToHeight?: number;
+    /**
+     * Optimistic will call the fetch interface first and not wait for the entire emoji collection
+     * to be available before rendering. This is useful for views or pages that show a select set of
+     * emojis.
+     * Defaults to `false`.
+     */
+    optimistic?: boolean;
+    /**
+     * Custom Fallback allows a custom element or string to be rendered if an emoji fails to be fetched or found.
+     * By default it takes the fallback or shortName inside emojiId, but if this prop is set it override the internal
+     * fallbacks
+     * customFallback<Element | string> else emojiId.fallback else emojiId.shortName.
+     * Defaults to `undefined`.
+     */
+    customFallback?: JSX.Element | string;
+    /**
+     * Will attempt to render a highly condensed version of the emoji with an image url before showing the meta version.
+     * All that is required for optimistic images to render is an emojiId, imageUrl and sizing props.
+     * Defaults to `undefined`.
+     */
+    optimisticImageURL?: string;
+}
+export interface Props extends BaseResourcedEmojiProps {
+    /**
+     * EmojiResource instance that handles fetching of emoji data.
+     */
+    emojiProvider: EmojiResource;
+}
+export declare const ResourcedEmojiComponent: FC<Props>;
+export default ResourcedEmojiComponent;

package/dist/types-ts4.0/components/common/RetryableButton.d.ts

@@ -0,0 +1,10 @@
+import { FC } from 'react';
+export interface Props {
+    label: string;
+    appearance: string;
+    error: boolean;
+    onSubmit: () => void;
+    loading: boolean;
+}
+declare const RetryableButton: FC<Props>;
+export default RetryableButton;

package/dist/types-ts4.0/components/common/Scrollable.d.ts

@@ -0,0 +1,19 @@
+import { MouseEventHandler, PureComponent, ReactNode, UIEvent } from 'react';
+export interface OnScroll {
+    (element: Element, event: UIEvent<any>): void;
+}
+export interface Props {
+    className?: string;
+    maxHeight?: string;
+    children?: ReactNode;
+    onScroll?: OnScroll;
+    onMouseLeave?: MouseEventHandler<any>;
+}
+export default class Scrollable extends PureComponent<Props, {}> {
+    private scrollableDiv;
+    reveal: (child: HTMLElement, forceToTop?: boolean | undefined) => void;
+    scrollToBottom: () => void;
+    private handleScroll;
+    private handleRef;
+    render(): JSX.Element;
+}

package/dist/types-ts4.0/components/common/ToneSelector.d.ts

@@ -0,0 +1,12 @@
+import React, { FC } from 'react';
+import { EmojiDescriptionWithVariations, OnToneSelected } from '../../types';
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+export interface Props {
+    emoji: EmojiDescriptionWithVariations;
+    onToneSelected: OnToneSelected;
+    previewEmojiId?: string;
+}
+declare type PropsWithAnalyticsEventsPropsType = Props & WithAnalyticsEventsProps;
+export declare const ToneSelectorInternal: FC<PropsWithAnalyticsEventsPropsType>;
+declare const ToneSelector: React.ForwardRefExoticComponent<Omit<React.PropsWithChildren<PropsWithAnalyticsEventsPropsType>, keyof WithAnalyticsEventsProps> & React.RefAttributes<any>>;
+export default ToneSelector;

package/dist/types-ts4.0/components/common/UfoErrorBoundary.d.ts

@@ -0,0 +1,8 @@
+import React, { ErrorInfo } from 'react';
+import { UFOExperience } from '@atlaskit/ufo';
+export declare class UfoErrorBoundary extends React.Component<{
+    experiences: UFOExperience[];
+}> {
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): React.ReactNode;
+}

package/dist/types-ts4.0/components/common/UploadEmoji.d.ts

@@ -0,0 +1,5 @@
+import { MessageDescriptor } from 'react-intl-next';
+import { EmojiProvider } from '../../api/EmojiResource';
+import { EmojiDescription, EmojiUpload } from '../../types';
+import { AnalyticsEventPayload } from '@atlaskit/analytics-next';
+export declare const uploadEmoji: (upload: EmojiUpload, emojiProvider: EmojiProvider, errorSetter: (message: MessageDescriptor | undefined) => void, onSuccess: (emojiDescription: EmojiDescription) => void, fireAnalytics: (event: AnalyticsEventPayload) => void, retry: boolean) => void;

package/dist/types-ts4.0/components/common/internal-types.d.ts

@@ -0,0 +1,11 @@
+import { EmojiProvider } from '../../api/EmojiResource';
+export interface EmojiContext {
+    emoji: {
+        emojiProvider: EmojiProvider;
+    };
+}
+export declare enum UploadStatus {
+    Waiting = 0,
+    Uploading = 1,
+    Error = 2
+}

package/dist/types-ts4.0/components/common/setSkinToneAriaLabelText.d.ts

@@ -0,0 +1 @@
+export declare const setSkinToneAriaLabelText: (tone?: string | undefined) => string | undefined;

package/dist/types-ts4.0/components/common/styles.d.ts

@@ -0,0 +1,49 @@
+export declare const commonSelectedStyles = "emoji-common-selected";
+export declare const selectOnHoverStyles = "emoji-common-select-on-hover";
+export declare const emojiSprite = "emoji-common-emoji-sprite";
+export declare const emojiNodeStyles = "emoji-common-node";
+export declare const emojiImage = "emoji-common-emoji-image";
+export declare const emojiDeleteButton = "emoji-common-deleteButton";
+export declare const emojiMainStyle = "emoji-common-main-styles";
+export declare const deleteButton: import("@emotion/utils").SerializedStyles;
+export declare const emojiToneSelectorContainer: import("@emotion/utils").SerializedStyles;
+export declare const emojiStyles: import("@emotion/utils").SerializedStyles;
+export declare const emojiContainer: import("@emotion/utils").SerializedStyles;
+export declare const placeholder = "emoji-common-placeholder";
+export declare const placeholderContainer: import("@emotion/utils").SerializedStyles;
+export declare const placeholderContainerAnimated: import("@emotion/utils").SerializedStyles;
+export declare const emojiButton: import("@emotion/utils").SerializedStyles;
+export declare const hiddenToneButton: import("@emotion/utils").SerializedStyles;
+export declare const emojiPickerAddEmoji = "emoji-picker-add-emoji";
+export declare const previewText: import("@emotion/utils").SerializedStyles;
+export declare const emojiName: import("@emotion/utils").SerializedStyles;
+export declare const emojiShortName: import("@emotion/utils").SerializedStyles;
+export declare const preview: import("@emotion/utils").SerializedStyles;
+export declare const previewImg: import("@emotion/utils").SerializedStyles;
+export declare const emojiScrollable: import("@emotion/utils").SerializedStyles;
+export declare const emojiUpload: import("@emotion/utils").SerializedStyles;
+export declare const uploadChooseFileMessage: import("@emotion/utils").SerializedStyles;
+export declare const emojiUploadBottom: import("@emotion/utils").SerializedStyles;
+export declare const uploadChooseFileRow: import("@emotion/utils").SerializedStyles;
+export declare const uploadChooseFileEmojiName: import("@emotion/utils").SerializedStyles;
+export declare const uploadChooseFileBrowse: import("@emotion/utils").SerializedStyles;
+export declare const uploadPreviewFooter: import("@emotion/utils").SerializedStyles;
+export declare const uploadPreview: import("@emotion/utils").SerializedStyles;
+export declare const uploadPreviewText: import("@emotion/utils").SerializedStyles;
+export declare const bigEmojiPreview: import("@emotion/utils").SerializedStyles;
+export declare const uploadAddRow: import("@emotion/utils").SerializedStyles;
+export declare const addCustomEmoji: import("@emotion/utils").SerializedStyles;
+export declare const submitDelete = "emoji-submit-delete";
+export declare const deletePreview: import("@emotion/utils").SerializedStyles;
+export declare const deleteText: import("@emotion/utils").SerializedStyles;
+export declare const previewButtonGroup: import("@emotion/utils").SerializedStyles;
+export declare const deleteFooter: import("@emotion/utils").SerializedStyles;
+export declare const emojiDeleteErrorMessage: import("@emotion/utils").SerializedStyles;
+export declare const emojiChooseFileErrorMessage: import("@emotion/utils").SerializedStyles;
+export declare const emojiPreviewErrorMessage: import("@emotion/utils").SerializedStyles;
+export declare const addCustomEmojiButton: import("@emotion/utils").SerializedStyles;
+export declare const uploadRetryButton: import("@emotion/utils").SerializedStyles;
+export declare const uploadEmojiButton: import("@emotion/utils").SerializedStyles;
+export declare const cancelButton: import("@emotion/utils").SerializedStyles;
+export declare const buttonSpinner: import("@emotion/utils").SerializedStyles;
+export declare const emojiActionsWrapper: import("@emotion/utils").SerializedStyles;

package/dist/types-ts4.0/components/hooks.d.ts

@@ -0,0 +1 @@
+export declare function useDidMount(): boolean;

package/dist/types-ts4.0/components/i18n.d.ts

@@ -0,0 +1,172 @@
+export declare const messages: {
+    deleteEmojiTitle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    deleteEmojiDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    deleteEmojiLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    addCustomEmojiLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiPlaceholder: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiNameAriaLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiChooseFileTitle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiChooseFileScreenReaderDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiSelectSkinToneButtonAriaLabelText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiImageRequirements: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiPreviewTitle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiPreview: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    addEmojiLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    retryLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    cancelLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    searchPlaceholder: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    searchLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    categoriesSearchResults: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    frequentCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    peopleCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    natureCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    foodsCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    activityCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    placesCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    objectsCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    symbolsCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    flagsCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    productivityCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    userUploadsCustomCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    allUploadsCustomCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    deleteEmojiFailed: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiInvalidImage: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiUploadFailed: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiImageTooBig: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};