@atlaskit/util-data-test 17.8.2 → 17.8.4

package/dist/types/emoji/src/api/EmojiResource.d.ts

@@ -0,0 +1,139 @@
+import { AbstractResource, OnProviderChange, ServiceConfig } from '@atlaskit/util-service-support';
+import { CategoryId } from '../components/picker/categories';
+import { EmojiDescription, EmojiId, EmojiProvider, EmojiResponse, EmojiSearchResult, EmojiUpload, OptionalEmojiDescription, OptionalEmojiDescriptionWithVariations, OptionalUser, SearchOptions, ToneSelection, UploadingEmojiProvider, User } from '../types';
+import EmojiRepository from './EmojiRepository';
+import SiteEmojiResource from './media/SiteEmojiResource';
+import { OptimisticImageApiLoaderConfig, SingleEmojiApiLoaderConfig } from './EmojiUtils';
+interface GetEmojiProviderOptions {
+    /**
+     * Whether fetch emoji provider at start
+     * @defaultValue true
+     */
+    fetchAtStart?: boolean;
+}
+export type { EmojiProvider, UploadingEmojiProvider } from '../types';
+export interface EmojiResourceConfig {
+    /**
+     * The service configuration for remotely recording emoji selections.
+     * A post will be performed to this URL with the EmojiId as the body.
+     */
+    recordConfig?: ServiceConfig;
+    /**
+     * This defines the different providers. Later providers will override earlier
+     * providers when performing shortName based look up.
+     */
+    providers: ServiceConfig[];
+    /**
+     * Must be set to true to enable upload support in the emoji components.
+     *
+     * Can be used for the restriction of the upload UI based on permissions, or feature flags.
+     *
+     * Note this also requires that other conditions are met (for example, one of the providers
+     * must support upload for the UploadingEmojiResource implementation of UploadingEmojiProvider).
+     */
+    allowUpload?: boolean;
+    /**
+     * Logged user in the Product.
+     */
+    currentUser?: User;
+    /**
+     * This is specifically used for fetching a meta information of a single emoji.
+     * Useful for when rendering a single or a subset of emojis on a page that does not require the
+     * whole provider list to be downloaded.
+     */
+    singleEmojiApi?: SingleEmojiApiLoaderConfig;
+    /**
+     * Renders an image while the provider is being downloaded to reduce the time
+     * the user is being presented with a placeholder
+     */
+    optimisticImageApi?: OptimisticImageApiLoaderConfig;
+}
+export interface OnEmojiProviderChange extends OnProviderChange<EmojiSearchResult, any, void> {
+}
+export interface Retry<T> {
+    (): Promise<T> | T;
+}
+export interface ResolveReject<T> {
+    resolve(result: T): void;
+    reject(reason?: any): void;
+}
+/**
+ * Checks if the emojiProvider can support uploading at a feature level.
+ *
+ * Follow this up with an isUploadSupported() check to see if the provider is actually
+ * configured to support uploads.
+ * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates
+ */
+export declare const supportsUploadFeature: (emojiProvider: EmojiProvider) => emojiProvider is UploadingEmojiProvider;
+export interface LastQuery {
+    query?: string;
+    options?: SearchOptions;
+}
+export declare class EmojiResource extends AbstractResource<string, EmojiSearchResult, any, undefined, SearchOptions> implements EmojiProvider {
+    protected recordConfig?: ServiceConfig;
+    protected emojiRepository?: EmojiRepository;
+    protected lastQuery?: LastQuery;
+    protected activeLoaders: number;
+    protected initialLoaders: number;
+    protected retries: Map<Retry<any>, ResolveReject<any>>;
+    protected siteEmojiResource?: SiteEmojiResource;
+    protected selectedTone: ToneSelection;
+    protected currentUser?: User;
+    protected isInitialised: boolean;
+    protected emojiResponses: EmojiResponse[];
+    emojiProviderConfig: EmojiResourceConfig;
+    constructor(config: EmojiResourceConfig);
+    /**
+     * Get the emoji provider from Emoji Resource
+     * @returns Promise<EmojiProvider>
+     */
+    getEmojiProvider(options?: GetEmojiProviderOptions): Promise<EmojiProvider>;
+    private fetchIndividualProvider;
+    fetchEmojiProvider(force?: boolean): Promise<EmojiRepository | undefined>;
+    fetchByEmojiId(emojiId: EmojiId, optimistic: boolean): Promise<OptionalEmojiDescriptionWithVariations>;
+    private getProviderType;
+    protected initEmojiRepository(emojiResponses: EmojiResponse[]): void;
+    protected initSiteEmojiResource(emojiResponse: EmojiResponse, provider: ServiceConfig): Promise<void>;
+    private performRetries;
+    getOptimisticImageURL: (emojiId: EmojiId) => string | undefined;
+    protected isRepositoryAvailable: <T>(repository?: T | undefined) => repository is T;
+    private isLoaded;
+    private loadStoredTone;
+    protected refreshLastFilter(): void;
+    protected retryIfLoading<T>(retry: Retry<T>, defaultResponse: T): Promise<T>;
+    protected notifyResult(result: EmojiSearchResult): void;
+    /**
+     *  Returns the EmojiDescription with a valid media path that includes query token and client attributes to access the emoji media inline.
+     */
+    getMediaEmojiDescriptionURLWithInlineToken(emoji: EmojiDescription): Promise<EmojiDescription>;
+    loadMediaEmoji(emoji: EmojiDescription, useAlt?: boolean): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    optimisticMediaRendering(emoji: EmojiDescription, useAlt?: boolean): boolean;
+    filter(query?: string, options?: SearchOptions): void;
+    findByShortName(shortName: string): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    findByEmojiId(emojiId: EmojiId): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    findById(id: string): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    findInCategory(categoryId: CategoryId): Promise<EmojiDescription[]>;
+    getAsciiMap(): Promise<Map<string, EmojiDescription>>;
+    getFrequentlyUsed(options?: SearchOptions): Promise<EmojiDescription[]>;
+    /**
+     * Record the selection of an emoji to a remote service if 'recordConfig' has been supplied.
+     * Regardless of the recordConfig, emoji selections will always be recorded on the EmojiRepository
+     * for the purposes of tracking the frequency of use.
+     *
+     * @param emoji The full description of the emoji to record usage for.
+     */
+    recordSelection(emoji: EmojiDescription): Promise<any>;
+    deleteSiteEmoji(emoji: EmojiDescription): Promise<boolean>;
+    getSelectedTone(): ToneSelection;
+    setSelectedTone(tone: ToneSelection): void;
+    calculateDynamicCategories(): Promise<CategoryId[]>;
+    getCurrentUser(): OptionalUser;
+    protected addUnknownEmoji(emoji: EmojiDescription): void;
+}
+export default class UploadingEmojiResource extends EmojiResource implements UploadingEmojiProvider {
+    protected allowUpload: boolean;
+    constructor(config: EmojiResourceConfig);
+    isUploadSupported(): Promise<boolean>;
+    uploadCustomEmoji(upload: EmojiUpload, retry?: boolean): Promise<EmojiDescription>;
+    prepareForUpload(): Promise<void>;
+}

package/dist/types/emoji/src/api/EmojiUtils.d.ts

@@ -0,0 +1,24 @@
+import { RequestServiceOptions, ServiceConfig } from '@atlaskit/util-service-support';
+import { AltRepresentations, EmojiDescription, EmojiDescriptionWithVariations, EmojiMeta, EmojiRepresentation, EmojiResponse, EmojiServiceDescriptionWithVariations, EmojiServiceRepresentation, EmojiServiceResponse, EmojiId } from '../types';
+export interface EmojiLoaderConfig extends ServiceConfig {
+    getRatio?: () => number;
+}
+export interface SingleEmojiApiLoaderConfig extends Omit<ServiceConfig, 'url'> {
+    getUrl: (emojiId: EmojiId) => string;
+}
+export interface OptimisticImageApiLoaderConfig extends Omit<ServiceConfig, 'url'> {
+    getUrl: (emojiId: EmojiId) => string;
+}
+export declare const emojiRequest: (provider: EmojiLoaderConfig, options?: RequestServiceOptions) => Promise<EmojiServiceResponse>;
+export declare const getPixelRatio: () => number;
+export declare const getAltRepresentation: (reps: AltRepresentations) => EmojiServiceRepresentation;
+export declare const isMediaApiUrl: (url: string, meta?: EmojiMeta) => boolean;
+export declare const denormaliseServiceRepresentation: (representation: EmojiServiceRepresentation, meta?: EmojiMeta) => EmojiRepresentation;
+export declare const denormaliseServiceAltRepresentation: (altReps?: AltRepresentations, meta?: EmojiMeta) => EmojiRepresentation;
+export declare const denormaliseSkinEmoji: (emoji: EmojiServiceDescriptionWithVariations, meta?: EmojiMeta) => EmojiDescriptionWithVariations[];
+/**
+ * Denormalised an emoji response (emojis + sprite references) into an array of
+ * emoji with local sprite definitions.
+ */
+export declare const denormaliseEmojiServiceResponse: (emojiData: EmojiServiceResponse) => EmojiResponse;
+export declare const shouldUseAltRepresentation: (emoji: EmojiDescription, fitToHeight?: number) => boolean;

package/dist/types/emoji/src/api/internal/Comparators.d.ts

@@ -0,0 +1,109 @@
+import { EmojiDescription } from '../../types';
+/**
+ * Create the default sort comparator to be used for the user queries against emoji
+ *
+ * @param query the query used in the search to be sorted. Any colons will be stripped from the query and it will be
+ * converted to lowercase.
+ * @param orderedIds the id of emoji ordered by how frequently they are used
+ */
+export declare function createSearchEmojiComparator(query?: string, orderedIds?: Array<string>): EmojiComparator;
+export declare function createUsageOnlyEmojiComparator(orderedIds: Array<string>): EmojiComparator;
+/**
+ * Returns a number representing the result of comparing e1 and e2.
+ * Compatible with Array.sort, which is to say -
+ *   - less than 0 if e1 should come first
+ *   - 0 if they are equal; e1 and e2 will be unchanged in position relative to each other
+ *   - greater than 0 if e2 should come first.
+ */
+export interface EmojiComparator {
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+}
+/**
+ * A combinator comparator that applies an ordered chained of sub-comparators. The first comparator that
+ * returns a non-zero value stops the chain and causes that value to be returned. If a comparator returns a
+ * zero then the next one in the chain is tried.
+ *
+ * If no comparators in the chain return a non-zero value then zero will be returned.
+ */
+export declare class ChainedEmojiComparator implements EmojiComparator {
+    private chain;
+    constructor(...comparators: EmojiComparator[]);
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+}
+/**
+ * Orders two emoji such that if one of them has an ascii representation that exactly matches the query then it will
+ * be ordered first.
+ */
+export declare class AsciiMatchComparator implements EmojiComparator {
+    private query;
+    constructor(query: string);
+    compare(e1: EmojiDescription, e2: EmojiDescription): 0 | 1 | -1;
+}
+/**
+ * Orders two emoji such that the one who's shortname matches the query exactly comes first. If there are matching
+ * shortnames then the type of emoji is taken into account with SITE emoji coming first.
+ */
+export declare class ExactShortNameMatchComparator implements EmojiComparator {
+    private colonQuery;
+    private typeComparator;
+    constructor(query: string);
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+}
+/**
+ * Orders two emoji based on their type, with the types being STANDARD, ATLASSIAN and SITE (in that order).
+ * If the comparator is configured to 'reverse' then the order will be SITE, ATLASSIAN, STANDARD.
+ *
+ * Regardless of the reverse setting, an unknown type will always come last.
+ */
+export declare class EmojiTypeComparator implements EmojiComparator {
+    private typeToNumber;
+    constructor(reverse?: boolean);
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+    private emojiTypeToOrdinal;
+}
+/**
+ * Order two emoji such as the one which is more frequently used comes first. If neither have any usage
+ * information then leave their order unchanged.
+ */
+export declare class UsageFrequencyComparator implements EmojiComparator {
+    private positionLookup;
+    constructor(orderedIds: Array<string>);
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+    /**
+     * Get the ordinal representing the position of this emoji.
+     *
+     * @param id the id of the emoji
+     */
+    private getPositionInOrder;
+}
+type KeysOfType<T, TProp> = {
+    [P in keyof T]: T[P] extends TProp | undefined ? P : never;
+}[keyof T];
+/**
+ * A comparator that will sort higher an emoji which matches the query string earliest in the indicated
+ * property.
+ */
+export declare class QueryStringPositionMatchComparator implements EmojiComparator {
+    private readonly propertyName;
+    private query;
+    /**
+     * @param query the query to match
+     * @param propertyToCompare the property of EmojiDescription to check for query within
+     */
+    constructor(query: string, propertyToCompare: KeysOfType<EmojiDescription, string>);
+    private getScore;
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+}
+export declare class OrderComparator implements EmojiComparator {
+    private static INSTANCE;
+    private constructor();
+    static get Instance(): OrderComparator;
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+}
+export declare class AlphabeticalShortnameComparator implements EmojiComparator {
+    private static INSTANCE;
+    private constructor();
+    static get Instance(): AlphabeticalShortnameComparator;
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+}
+export {};

package/dist/types/emoji/src/api/internal/UsageFrequencyTracker.d.ts

@@ -0,0 +1,46 @@
+import { EmojiDescription } from '../../types';
+import DuplicateLimitedQueue from '../../util/DuplicateLimitedQueue';
+/**
+ * Keeps track of the last 150 emoji usages, although limiting the maximum count for a single emoji to 25 to
+ * ensure we don't end up with only a single emoji being recorded. Usage is persisted to local storage for
+ * consistency between 'sessions'.
+ *
+ * Skin tone variations for an emoji will be 'collapsed' so they are tracked as their base emoji. Gender
+ * variations are not collapsed in this way and will be tracked per gender. This decision reflects the UI of
+ * the EmojiPicker component.
+ */
+export declare class UsageFrequencyTracker {
+    private static readonly queueOptions;
+    protected queue: DuplicateLimitedQueue<string>;
+    private gateway;
+    constructor(useStorageIfPossible?: boolean);
+    /**
+     * Record the fact that the supplied emoji was used. You should note that usage is updated asynchronously so you can not
+     * count on getOrder() reflecting this usage immediately.
+     *
+     * @param emoji the emoji who's usage is to be recorded. If the emoji has no id then no usage will be recorded
+     */
+    recordUsage(emoji: EmojiDescription): void;
+    /**
+     * Returns an array of emoji id (without skin tone variations) sorted by most used to least used. If there
+     * are no usages then an empty array will be returned.
+     */
+    getOrder(): Array<string>;
+    /**
+     * Exposed for testing only. Clear any recorded usage.
+     */
+    clear(): void;
+}
+export declare class Gateway {
+    private maximumPermitted;
+    private count;
+    constructor(maximumPermitted: number);
+    /**
+     * Run the supplied function if the count of already submitted work allows it. Drop the work
+     * if it's not allowed to run.
+     *
+     * Will return true if the function has been submitted or false if it was not submitted.
+     */
+    submit(f: () => void): boolean;
+    private completed;
+}

package/dist/types/emoji/src/api/media/MediaEmojiCache.d.ts

@@ -0,0 +1,53 @@
+import { EmojiDescription, OptionalEmojiDescription } from '../../types';
+import MediaImageLoader from './MediaImageLoader';
+import TokenManager from './TokenManager';
+export interface EmojiCacheStrategy {
+    loadEmoji(emoji: EmojiDescription, useAlt?: boolean): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    optimisticRendering(): boolean;
+}
+/**
+ * For browsers that support caching for resources
+ * regardless of originally supplied headers (basically everything but Firefox).
+ */
+export declare class BrowserCacheStrategy implements EmojiCacheStrategy {
+    private cachedImageUrls;
+    private mediaImageLoader;
+    constructor(mediaImageLoader: MediaImageLoader);
+    loadEmoji(emoji: EmojiDescription, useAlt?: boolean): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    optimisticRendering(): boolean;
+    static supported(mediaPath: string, mediaImageLoader: MediaImageLoader): Promise<boolean>;
+}
+/**
+ * For browsers that do no cache images without equivalent headers (e.g. Firefox).
+ *
+ * Images are cached in memory in a LRU cache. Images considered too large,
+ * are not cached, but retrieved each time.
+ *
+ * Images are still cached by the browser, but loading in asynchronous with
+ * small delay noticable to the end user.
+ */
+export declare class MemoryCacheStrategy implements EmojiCacheStrategy {
+    private dataURLCache;
+    private mediaImageLoader;
+    constructor(mediaImageLoader: MediaImageLoader);
+    loadEmoji(emoji: EmojiDescription, useAlt?: boolean): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    optimisticRendering(): boolean;
+}
+/**
+ * Provides a cache for Media Emoji.
+ *
+ * Emoji are returned immediately if cached and ready to use by the browser.
+ *
+ * Otherwise, they are loaded and returned via a promise.
+ */
+export default class MediaEmojiCache {
+    protected cache?: EmojiCacheStrategy;
+    protected waitingInitUrls: string[];
+    private cacheLoading;
+    private mediaImageLoader;
+    constructor(tokenManager: TokenManager);
+    loadEmoji(emoji: EmojiDescription, useAlt?: boolean): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    optimisticRendering(url: string): boolean | Promise<boolean>;
+    protected getCache(url: string): EmojiCacheStrategy | Promise<EmojiCacheStrategy>;
+    private initCache;
+}

package/dist/types/emoji/src/api/media/MediaImageLoader.d.ts

@@ -0,0 +1,21 @@
+import TokenManager from './TokenManager';
+export type DataURL = string;
+export interface MediaImageLoaderOptions {
+    concurrentDownloadLimit: number;
+}
+export default class MediaImageLoader {
+    private tokenManager;
+    private mediaImageQueue;
+    private activeProcessing;
+    private concurrentDownloadLimit;
+    private pendingRequests;
+    constructor(tokenManager: TokenManager, options?: MediaImageLoaderOptions);
+    loadMediaImage(url: string): Promise<DataURL>;
+    getQueueSize(): number;
+    getActiveDownloads(): number;
+    private processFromQueue;
+    private completedItem;
+    private delay;
+    private requestMediaEmoji;
+    private readBlob;
+}

package/dist/types/emoji/src/api/media/SiteEmojiResource.d.ts

@@ -0,0 +1,46 @@
+import { ServiceConfig } from '@atlaskit/util-service-support';
+import { EmojiDescription, EmojiId, EmojiServiceDescription, EmojiUpload, MediaApiToken, OptionalEmojiDescription } from '../../types';
+import TokenManager from './TokenManager';
+export interface EmojiUploadResponse {
+    emojis: EmojiServiceDescription[];
+}
+export interface EmojiProgress {
+    readonly percent: number;
+}
+export interface EmojiProgessCallback {
+    (progress: EmojiProgress): void;
+}
+export declare const mediaProportionOfProgress: number;
+export default class SiteEmojiResource {
+    private siteServiceConfig;
+    private mediaApiToken;
+    private mediaEmojiCache;
+    protected tokenManager: TokenManager;
+    constructor(siteServiceConfig: ServiceConfig, mediaApiToken: MediaApiToken);
+    /**
+     * Will generate an emoji media path that is inclusive of client and token within the query parameter
+     */
+    generateTokenisedMediaURL(emoji: EmojiDescription): Promise<string>;
+    /**
+     * Will load media emoji, returning a new EmojiDescription if, for example,
+     * the URL has changed.
+     */
+    loadMediaEmoji(emoji: EmojiDescription, useAlt?: boolean): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    optimisticRendering(emoji: EmojiDescription, useAlt?: boolean): boolean | Promise<boolean>;
+    uploadEmoji(upload: EmojiUpload, retry?: boolean, progressCallback?: EmojiProgessCallback): Promise<EmojiDescription>;
+    /**
+     * Check if the MediaEmojiResource has been able to initialise an uploadToken. Retrieving an upload token
+     * is asynchronous so the Promise will need to resolve before the state is known. If the token retrieval
+     * completes with failure then the Promise will resolve to false.
+     */
+    hasUploadToken(): Promise<boolean>;
+    prepareForUpload(): void;
+    findEmoji(emojiId: EmojiId): Promise<OptionalEmojiDescription>;
+    /**
+     * Calls to site-scoped EmojiResource to delete emoji
+     * @param emoji media emoji to delete
+     * @returns Promise.resolve() if success and Promise.reject() for failure
+     */
+    deleteEmoji(emoji: EmojiDescription): Promise<boolean>;
+    private postToEmojiService;
+}

package/dist/types/emoji/src/api/media/TokenManager.d.ts

@@ -0,0 +1,13 @@
+import { MediaApiToken } from '../../types';
+import { ServiceConfig } from '@atlaskit/util-service-support';
+export declare const EXPIRES_AT_LATENCY_IN_SECONDS = 30;
+export type TokenType = 'read' | 'upload';
+export default class TokenManager {
+    private siteServiceConfig;
+    private tokens;
+    constructor(siteServiceConfig: ServiceConfig);
+    isValidToken(mediaApiToken: MediaApiToken): boolean;
+    fetchNewToken(type: TokenType): Promise<MediaApiToken>;
+    addToken(type: TokenType, mediaApiToken: MediaApiToken): void;
+    getToken(type: TokenType, forceRefresh?: boolean): Promise<MediaApiToken>;
+}

package/dist/types/emoji/src/components/i18n.d.ts

@@ -0,0 +1,227 @@
+export declare const messages: {
+    deleteEmojiTooltip: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    deleteEmojiTooltipForScreenreader: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    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;
+    };
+    emojiSelectSkinToneListAriaLabelText: {
+        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;
+    };
+    searchResultsStatus: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    searchResultsStatusSeeAll: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    categoriesSelectorLabel: {
+        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;
+    };
+    emojiPickerTitle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiPickerListPanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiPickerGrid: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiButtonRoleDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    error: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};