@atlaskit/emoji 70.17.9 → 70.17.10

package/dist/types-ts4.5/api/EmojiResource.d.ts

@@ -1,160 +0,0 @@
-import { AbstractResource, type OnProviderChange, type ServiceConfig } from '@atlaskit/util-service-support';
-import type { CategoryId } from '../components/picker/categories';
-import { type EmojiDescription, type EmojiId, type EmojiProvider, type EmojiResponse, type EmojiSearchResult, type EmojiUpload, type OptionalEmojiDescription, type OptionalEmojiDescriptionWithVariations, type OptionalUser, type SearchOptions, type ToneSelection, type UploadingEmojiProvider, type User } from '../types';
-import EmojiRepository from './EmojiRepository';
-import SiteEmojiResource from './media/SiteEmojiResource';
-import type { OptimisticImageApiLoaderConfig, Options, SingleEmojiApiLoaderConfig, EmojiLoadSuccessCallback, EmojiLoadFailCallback } from './EmojiUtils';
-interface GetEmojiProviderOptions {
-    /**
-     * Whether fetch emoji provider at start
-     * @defaultValue true
-     */
-    fetchAtStart?: boolean;
-}
-export type { EmojiProvider, UploadingEmojiProvider } from '../types';
-export interface EmojiResourceConfig {
-    /**
-     * 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;
-    /**
-     * A callback triggered on emoji load failure
-     */
-    onEmojiLoadFail?: EmojiLoadFailCallback;
-    /**
-     * A callback triggered on emoji load success
-     */
-    onEmojiLoadSuccess?: EmojiLoadSuccessCallback;
-    /**
-     * Renders an image while the provider is being downloaded to reduce the time
-     * the user is being presented with a placeholder
-     */
-    optimisticImageApi?: OptimisticImageApiLoaderConfig;
-    /**
-     * Additional configuration:
-     * * On-demand Fetching - Useful for when a product may prefer manually controlling when providers are fetched
-     */
-    options?: Options;
-    /**
-     * This defines the different providers. Later providers will override earlier
-     * providers when performing shortName based look up.
-     */
-    providers: ServiceConfig[];
-    /**
-     * 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 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;
-}
-export interface OnEmojiProviderChange extends OnProviderChange<EmojiSearchResult, any, void> {
-}
-export interface Retry<T> {
-    (): Promise<T> | T;
-}
-export interface ResolveReject<T> {
-    reject(reason?: any): void;
-    resolve(result: T): 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 {
-    options?: SearchOptions;
-    query?: string;
-}
-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 fetchOnDemand: 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>;
-    onlyFetchOnDemand(): boolean;
-    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) => 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>;
-    /**
-     * Synchronously reads the emoji type from the local cache for the given emojiId.
-     * Returns `undefined` when the emoji is not in the cache or no repository is initialised.
-     * This is a pure cache read — no network requests are made.
-     */
-    getCachedEmojiType(emojiId: EmojiId): string | undefined;
-    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, timeout?: number): Promise<EmojiDescription>;
-    prepareForUpload(): Promise<void>;
-}

package/dist/types-ts4.5/api/EmojiUtils.d.ts

@@ -1,29 +0,0 @@
-import { type RequestServiceOptions, type ServiceConfig } from '@atlaskit/util-service-support';
-import { type AltRepresentations, type EmojiDescription, type EmojiDescriptionWithVariations, type EmojiMeta, type EmojiRepresentation, type EmojiResponse, type EmojiServiceDescriptionWithVariations, type EmojiServiceRepresentation, type EmojiServiceResponse, type EmojiId } from '../types';
-export interface EmojiLoaderConfig extends ServiceConfig {
-    getRatio?: () => number;
-}
-export interface Options {
-    onlyFetchOnDemand?: boolean;
-}
-export interface SingleEmojiApiLoaderConfig extends Omit<ServiceConfig, 'url'> {
-    getUrl: (emojiId: EmojiId) => string;
-}
-export interface OptimisticImageApiLoaderConfig extends Omit<ServiceConfig, 'url'> {
-    getUrl: (emojiId: EmojiId) => string;
-}
-export type EmojiLoadSuccessCallback = (emojiId?: string) => void;
-export type EmojiLoadFailCallback = (emojiId?: string, reason?: string) => void;
-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-ts4.5/api/internal/Comparators.d.ts

@@ -1,109 +0,0 @@
-import type { 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-ts4.5/api/internal/UsageFrequencyTracker.d.ts

@@ -1,46 +0,0 @@
-import type { 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-ts4.5/api/media/MediaEmojiCache.d.ts

@@ -1,53 +0,0 @@
-import type { EmojiDescription, OptionalEmojiDescription } from '../../types';
-import MediaImageLoader from './MediaImageLoader';
-import type 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-ts4.5/api/media/MediaImageLoader.d.ts

@@ -1,21 +0,0 @@
-import type 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-ts4.5/api/media/SiteEmojiResource.d.ts

@@ -1,51 +0,0 @@
-import { type ServiceConfig } from '@atlaskit/util-service-support';
-import type { EmojiDescription, EmojiId, EmojiRepresentation, 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;
-}
-type TokenisedEmojiRepresentation = {
-    altRepresentation?: EmojiRepresentation;
-    representation?: EmojiRepresentation;
-};
-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 for media representation and altRepresentation
-     */
-    generateTokenisedMediaURLS(representation: EmojiRepresentation, altRepresentation?: EmojiRepresentation): Promise<TokenisedEmojiRepresentation>;
-    /**
-     * 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;
-}
-export {};

package/dist/types-ts4.5/api/media/TokenManager.d.ts

@@ -1,13 +0,0 @@
-import type { MediaApiToken } from '../../types';
-import { type 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-ts4.5/components/common/AddEmoji.d.ts

@@ -1,11 +0,0 @@
-import { type WrappedComponentProps } from 'react-intl';
-export declare const emojiActionsTestId = "emoji-actions";
-export declare const uploadEmojiTestId = "upload-emoji";
-type Props = {
-    onOpenUpload: () => void;
-    uploadEnabled: boolean;
-};
-type PropsWithWrappedComponentPropsType = Props & WrappedComponentProps;
-type AddOwnEmojiProps = PropsWithWrappedComponentPropsType;
-export declare const AddOwnEmoji: (props: AddOwnEmojiProps) => JSX.Element;
-export {};

package/dist/types-ts4.5/components/common/CachingEmoji.d.ts

@@ -1,21 +0,0 @@
-import React from 'react';
-import { type EmojiDescription } from '../../types';
-import { type Props as EmojiProps } from './Emoji';
-export interface State {
-    cachedEmoji?: EmojiDescription;
-    invalidImage?: boolean;
-}
-export interface CachingEmojiProps extends EmojiProps {
-    placeholderSize?: number;
-}
-/**
- * Renders an emoji from a cached image, if required.
- */
-export declare const CachingEmoji: (props: React.PropsWithChildren<CachingEmojiProps>) => React.JSX.Element;
-/**
- * Rendering a media emoji image from a cache for media emoji, with different
- * rendering paths depending on caching strategy.
- */
-export declare const CachingMediaEmoji: (props: React.PropsWithChildren<CachingEmojiProps>) => React.JSX.Element;
-declare const _default_1: React.MemoExoticComponent<(props: React.PropsWithChildren<CachingEmojiProps>) => React.JSX.Element>;
-export default _default_1;

package/dist/types-ts4.5/components/common/DeletableEmojiTooltipContent.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-import type { EmojiDescription } from '../../types';
-export declare const DeletableEmojiTooltipContent: () => React.JSX.Element;
-export declare const DeletableEmojiTooltipContentForScreenReader: ({ emoji, }: {
-    emoji: EmojiDescription;
-}) => React.JSX.Element;

package/dist/types-ts4.5/components/common/DeleteButton.d.ts

@@ -1,7 +0,0 @@
-import { type ButtonProps } from '@atlaskit/button/standard-button';
-/**
- * Test id for wrapper Emoji delete button
- */
-export declare const RENDER_EMOJI_DELETE_BUTTON_TESTID = "render-emoji-delete-button";
-declare const DeleteButton: (props: ButtonProps) => JSX.Element;
-export default DeleteButton;

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

@@ -1,96 +0,0 @@
-/**
- * @jsxRuntime classic
- * @jsx jsx
- */
-import React from 'react';
-import { type EmojiDescription, type OnEmojiEvent } from '../../types';
-export interface Props extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'onMouseMove' | 'onFocus'> {
-    /**
-     * Auto Width takes the constraint of height and enables native scaling based on the emojis image.
-     * This is primarily used when rendering emojis for SSR as the component does not know the width and height
-     * at the time of the render. It overrides the emoji representations width with 'auto' on the images width attribute
-     *
-     * Used only for image based emojis
-     */
-    autoWidth?: boolean;
-    /**
-     * Additional css classes, if required.
-     */
-    className?: string;
-    /**
-     * Disables lazy load on images
-     */
-    disableLazyLoad?: boolean;
-    /**
-     * This should only be set when the emoji is being used in the Editor.
-     * Currently when set -- this prevents any aria labels being added.
-     * This is acceptable in Editor -- as it uses another technique to announce the emoji nodes.
-     */
-    editorEmoji?: true;
-    /**
-     * The emoji to render
-     */
-    emoji: EmojiDescription;
-    /**
-     * Fits emoji to height in pixels, keeping aspect ratio
-     */
-    fitToHeight?: number;
-    /**
-     * Called when an emoji is deleted
-     */
-    onDelete?: OnEmojiEvent;
-    /**
-     * Called when the mouse moves over the emoji.
-     */
-    onFocus?: OnEmojiEvent;
-    /**
-     * Callback for if an emoji image fails to load.
-     */
-    onLoadError?: OnEmojiEvent<HTMLImageElement>;
-    /**
-     * Callback for if an emoji image succesfully loads.
-     */
-    onLoadSuccess?: (emoji: EmojiDescription) => void;
-    /**
-     * Called when the mouse moves over the emoji.
-     */
-    onMouseMove?: OnEmojiEvent;
-    /**
-     * Called when an emoji is selected
-     */
-    onSelected?: OnEmojiEvent;
-    /**
-     * 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;
-    /**
-     * Indicates whether emoji is an interactive element (tab index and role) or just a view
-     */
-    shouldBeInteractive?: boolean;
-    /**
-     * Show a delete button on mouse hover
-     * Used only for custom emoji
-     */
-    showDelete?: boolean;
-    /**
-     * Show a tooltip on mouse hover.
-     */
-    showTooltip?: boolean;
-}
-export declare const SpriteEmoji: (props: Props) => JSX.Element;
-export declare const UnicodeEmoji: (props: Props) => JSX.Element;
-export declare const ImageEmoji: (props: Props) => JSX.Element;
-interface EmojiNodeWrapperProps extends Props {
-    type: 'sprite' | 'image' | 'unicode';
-}
-export declare const EmojiNodeWrapper: React.ForwardRefExoticComponent<EmojiNodeWrapperProps & {
-    children?: React.ReactNode | undefined;
-} & React.RefAttributes<HTMLSpanElement>>;
-export declare const Emoji: (props: Props) => JSX.Element;
-export default Emoji;