@atlaskit/smart-card 22.2.0 → 22.3.0

package/dist/types-ts4.0/state/flexible-ui-context/types.d.ts

@@ -0,0 +1,159 @@
+import { LinkLozenge } from '../../extractors/common/lozenge/types';
+import { LinkPerson } from '@atlaskit/linking-common/extractors';
+import { IconType, MediaType } from '../../constants';
+/**
+ * This provides the data that will be used by Smart Links Flexible UI to populate it's
+ * underlying elements.
+ */
+export declare type FlexibleUiDataContext = {
+    /**
+     * An array containing data used to populate the AuthorGroup element.
+     * @see AvatarGroup
+     */
+    authorGroup?: LinkPerson[];
+    /**
+     * An array containing a @type {LinkPerson} used to populate the CollaboratorGroup element.
+     * @see CollaboratorGroup
+     */
+    collaboratorGroup?: LinkPerson[];
+    /**
+     * Contains the number of comments of the linked resource.
+     * @type number
+     * @see CommentCount
+     */
+    commentCount?: number;
+    /**
+     * Contains the ISO timestamp of when the resource was due.
+     * This value is mapped to JsonLD endTime.
+     * @type string - ISO Timestamp
+     * @see DueOn
+     */
+    dueOn?: string;
+    /**
+     * Contains the number of views of the linked resource.
+     * @type number
+     * @see ViewCount
+     */
+    viewCount?: number;
+    /**
+     * Contains the number of react of the linked resource.
+     * @type number
+     * @see ReactCount
+     */
+    reactCount?: number;
+    /**
+     * Contains the number of votes of the linked resource.
+     * @type number
+     * @see VoteCount
+     */
+    voteCount?: number;
+    /**
+     * Contains the name of the entity that created the resource.
+     * @type string
+     * @see CreatedBy
+     */
+    createdBy?: string;
+    /**
+     * Contains the ISO timestamp of when the resource was created.
+     * @type string - ISO Timestamp
+     * @see CreatedOn
+     */
+    createdOn?: string;
+    /**
+     * Contains the information about the latest commit in the repository
+     */
+    latestCommit?: string;
+    /**
+     * Contains the favicon of the resource.
+     * @type Icon
+     * @see LinkIcon
+     */
+    linkIcon?: Icon;
+    /**
+     * Contains the name of the entity that last modified the resource.
+     * @type string
+     * @see ModifiedBy
+     */
+    modifiedBy?: string;
+    /**
+     * Contains the ISO timestamp of when the resource was last modified.
+     * @type string - ISO Timestamp
+     * @see ModifiedOn
+     */
+    modifiedOn?: string;
+    /**
+     * Contains the preview (typically the thumbnail) of the resource.
+     * @type Media
+     * @see Preview
+     */
+    preview?: Media;
+    /**
+     * Contains the priority icon of the resource.
+     * @type Icon
+     * @see Priority
+     */
+    priority?: Icon;
+    /**
+     * Contains the programming language of the resource.
+     * @type string
+     * @see ProgrammingLanguage
+     */
+    programmingLanguage?: string;
+    /**
+     * Contains the provider icon of the linked resource.
+     * @type Icon
+     * @see Provider
+     */
+    provider?: Icon;
+    /**
+     * Contains the snippet of the resource.
+     * @type string
+     * @see Snippet
+     */
+    snippet?: string;
+    /**
+     * Contains the source branch name of the link typed pull request.
+     * @type string
+     * @see SourceBranch
+     */
+    sourceBranch?: string;
+    /**
+     * Contains the number of subscribers of the linked resource.
+     * @type number
+     * @see SubscriberCount
+     */
+    subscriberCount?: number;
+    /**
+     * Contains the number of subscribers of the linked resource.
+     * @type number
+     * @see SubscriberCount
+     */
+    state?: LinkLozenge;
+    /**
+     * Contains the target branch name of the link typed pull request.
+     * @type string
+     * @see TargetBranch
+     */
+    targetBranch?: string;
+    /**
+     * Contains the Title of the linked resource.
+     * @type string
+     * @see Title
+     */
+    title?: string;
+    /**
+     * Contains the url of the linked resource.
+     * @type string
+     * @see Title
+     */
+    url?: string;
+};
+export declare type Icon = {
+    icon?: IconType;
+    label?: string;
+    url?: string;
+};
+export declare type Media = {
+    type: MediaType;
+    url: string;
+};

package/dist/types-ts4.0/state/helpers.d.ts

@@ -0,0 +1,16 @@
+import { JsonLd } from 'json-ld-types';
+import { CardType, CardStore } from '@atlaskit/linking-common';
+import { DestinationProduct, DestinationSubproduct } from '../utils/analytics/types';
+export declare const getByDefinitionId: (definitionId: string | undefined, store: CardStore) => string[];
+export declare const getClickUrl: (url: string, jsonLd?: JsonLd.Response<JsonLd.Data.BaseData> | undefined) => string;
+export declare const getDefinitionId: (details?: JsonLd.Response<JsonLd.Data.BaseData> | undefined) => string | undefined;
+export declare const getExtensionKey: (details?: JsonLd.Response<JsonLd.Data.BaseData> | undefined) => string | undefined;
+export declare const getResourceType: (details?: JsonLd.Response<JsonLd.Data.BaseData> | undefined) => string | undefined;
+export declare const getProduct: (details?: JsonLd.Response<JsonLd.Data.BaseData> | undefined) => DestinationProduct | string | undefined;
+export declare const getSubproduct: (details?: JsonLd.Response<JsonLd.Data.BaseData> | undefined) => DestinationSubproduct | string | undefined;
+export declare const getServices: (details?: JsonLd.Response<JsonLd.Data.BaseData> | undefined) => JsonLd.Primitives.AuthService[];
+export declare const hasResolved: (details?: JsonLd.Response<JsonLd.Data.BaseData> | undefined) => boolean | undefined;
+export declare const isAccessible: ({ meta: { access } }: JsonLd.Response) => boolean;
+export declare const isVisible: ({ meta: { visibility } }: JsonLd.Response) => boolean;
+export declare const getStatus: ({ meta }: JsonLd.Response) => CardType;
+export declare const isFinalState: (status: CardType) => boolean;

package/dist/types-ts4.0/state/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { usePrefetch } from './usePrefetch';
+export { useSmartLink } from './useSmartLink';

package/dist/types-ts4.0/state/hooks/usePrefetch.d.ts

@@ -0,0 +1 @@
+export declare function usePrefetch(url: string): () => Promise<void>;

package/dist/types-ts4.0/state/hooks/useSmartLink.d.ts

@@ -0,0 +1,50 @@
+import { AnalyticsHandler } from '../../utils/types';
+export declare function useSmartLink(id: string, url: string, dispatchAnalytics: AnalyticsHandler): {
+    state: import("@atlaskit/linking-common").CardState;
+    actions: {
+        register: () => Promise<void>;
+        reload: () => void;
+        authorize: (appearance: import("@atlaskit/linking-common").CardAppearance) => void;
+        invoke: (opts: import("../../model/invoke-opts").InvokeClientOpts | import("../../model/invoke-opts").InvokeServerOpts, appearance: import("../../view/Card/types").CardInnerAppearance) => Promise<void | import("json-ld-types").JsonLd.Response<import("json-ld-types").JsonLd.Data.BaseData>>;
+        loadMetadata: () => Promise<void> | undefined;
+    };
+    config: (import("@atlaskit/link-provider").CardProviderCacheOpts & import("@atlaskit/link-provider").CardAuthFlowOpts) | undefined;
+    analytics: {
+        ui: {
+            authEvent: ({ display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiAuthEventProps) => void;
+            authAlternateAccountEvent: ({ display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiAuthAlternateAccountEventProps) => void;
+            buttonClickedEvent: (data: Partial<import("../../utils/types").AnalyticsPayload> & {
+                actionSubjectId: string;
+            }) => void;
+            cardClickedEvent: ({ id, display, status, definitionId, extensionKey, isModifierKeyPressed, location, destinationProduct, destinationSubproduct, actionSubjectId, }: import("../../utils/analytics/types").UiCardClickedEventProps) => void;
+            actionClickedEvent: ({ id, actionType, display, invokeType, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiActionClickedEventProps) => void;
+            hoverCardOpenLinkClickedEvent: ({ previewDisplay, definitionId, extensionKey, destinationProduct, destinationSubproduct, location, previewInvokeMethod, }: import("../../utils/analytics/types").UiHoverCardOpenLinkClickedEventProps) => void;
+            closedAuthEvent: ({ display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiClosedAuthEventProps) => void;
+            modalClosedEvent: (data: Partial<import("../../utils/types").AnalyticsPayload> & {
+                actionSubjectId: string;
+            }) => void;
+            renderSuccessEvent: ({ display, status, id, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiRenderSuccessEventProps) => void;
+            renderFailedEvent: ({ display, id, error, errorInfo, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiRenderFailedEventProps) => void;
+            hoverCardViewedEvent: ({ previewDisplay, previewInvokeMethod, id, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiHoverCardViewedEventProps) => void;
+            hoverCardDismissedEvent: ({ id, previewDisplay, hoverTime, previewInvokeMethod, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiHoverCardDismissedEventProps) => void;
+        };
+        operational: {
+            invokeSucceededEvent: ({ id, actionType, display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").InvokeSucceededEventProps) => void;
+            invokeFailedEvent: ({ id, actionType, display, reason, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").InvokeFailedEventProps) => void;
+            connectSucceededEvent: ({ id, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").ConnectSucceededEventProps) => void;
+            connectFailedEvent: ({ id, reason, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").ConnectFailedEventProps) => void;
+            instrument: ({ id, status, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, error, }: import("../../utils/analytics/types").InstrumentEventProps) => void;
+        };
+        track: {
+            appAccountConnected: ({ extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").CommonEventProps) => void;
+        };
+        screen: {
+            authPopupEvent: ({ extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").CommonEventProps) => void;
+            modalViewedEvent: (data: Partial<import("../../utils/types").AnalyticsPayload> & {
+                name: "embedPreviewModal";
+            }) => void;
+        };
+    };
+    renderers: import("@atlaskit/link-provider").CardProviderRenderers | undefined;
+    error: Error | null;
+};

package/dist/types-ts4.0/state/hooks-external/useSmartLinkActions.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="react" />
+import { JsonLd } from 'json-ld-types';
+import type { AnalyticsHandler, AnalyticsOrigin } from '../../utils/types';
+import type { CardInnerAppearance } from '../../view/Card/types';
+export interface LinkAction {
+    /**
+     * Unique ID for the action.
+     * @example `delete-action`
+     */
+    id: string;
+    /**
+     * Text to render for the action.
+     * @description Use this in tooltips and UI.
+     * @example `Delete`.
+     */
+    text: React.ReactNode;
+    /**
+     * Promise to invoke on triggering this action.
+     * @example Clicking on `Delete` leading to deletion of content.
+     */
+    invoke: () => Promise<any>;
+}
+export interface UseSmartLinkActionsOpts {
+    /**
+     * Smart Link URL for which actions will be invoked.
+     * @example https://start.atlassian.com
+     */
+    url: string;
+    /**
+     * Appearance under which these actions will be invoked.
+     * @example `block` for card views.
+     */
+    appearance: CardInnerAppearance;
+    /**
+     * Callback for sending analytics events.
+     * @description Accepts an analytics payload and fires it to a system.
+     */
+    analyticsHandler: AnalyticsHandler;
+    /**
+     * Platform on which actions are being invoked.
+     * @default 'web'
+     */
+    platform?: JsonLd.Primitives.Platforms;
+    /**
+     * Smart link origin that the action being invoked from.
+     */
+    origin?: AnalyticsOrigin;
+}
+export declare function useSmartLinkActions({ url, appearance, analyticsHandler, platform, origin, }: UseSmartLinkActionsOpts): LinkAction[];

package/dist/types-ts4.0/state/hooks-external/useSmartLinkReload.d.ts

@@ -0,0 +1,19 @@
+import type { AnalyticsHandler } from '../../utils/types';
+export interface UseSmartLinkReloadOpts {
+    /**
+     * Smart Link URL for which the reload will be invoked.
+     * @example https://start.atlassian.com
+     */
+    url: string;
+    /**
+     * Callback for sending analytics events.
+     * @description Accepts an analytics payload and fires it to a system.
+     */
+    analyticsHandler: AnalyticsHandler;
+}
+/**
+ * Exposes a programmatic way to reload the data being used to render a Smart Link.
+ * @param
+ * @returns
+ */
+export declare function useSmartLinkReload({ url, analyticsHandler, }: UseSmartLinkReloadOpts): () => void;

package/dist/types-ts4.0/state/index.d.ts

@@ -0,0 +1,5 @@
+export { SmartCardContext, SmartCardProvider, useSmartLinkContext, } from '@atlaskit/link-provider';
+export type { CardContext, ProviderProps } from '@atlaskit/link-provider';
+export type { CardType } from '@atlaskit/linking-common';
+export { useSmartLink, usePrefetch } from './hooks';
+export { useSmartLinkAnalytics } from './analytics';

package/dist/types-ts4.0/state/reducers/types.d.ts

@@ -0,0 +1,4 @@
+import { Reducer } from 'react';
+import { CardAction, CardActionType } from '@atlaskit/linking-common';
+export declare type CardReducerMap<StateType, ActionType> = Record<CardActionType, CardReducer<StateType, ActionType>>;
+export declare type CardReducer<StateType, ActionType> = Reducer<StateType, CardAction<ActionType>>;

package/dist/types-ts4.0/state/renderers/index.d.ts

@@ -0,0 +1,2 @@
+import { CardContext } from '@atlaskit/link-provider';
+export declare const useSmartLinkRenderers: () => CardContext['renderers'] | undefined;

package/dist/types-ts4.0/state/store/index.d.ts

@@ -0,0 +1,3 @@
+import { CardState } from '@atlaskit/linking-common';
+export type { CardType } from '@atlaskit/linking-common';
+export declare function useSmartCardState(url: string): CardState;

package/dist/types-ts4.0/state/types.d.ts

@@ -0,0 +1 @@
+export type { CardStore, CardState } from '@atlaskit/linking-common';

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

@@ -0,0 +1,20 @@
+import { JsonLd } from 'json-ld-types';
+import { RequestAccessMessageKey } from './messages';
+export type { CardContext } from '@atlaskit/link-provider';
+import { AccessContext } from './view/types';
+import { ActionProps } from './view/BlockCard/components/Action';
+export declare type ResolveResponse = JsonLd.Response;
+export type { ProviderProps, CardType } from './state';
+export type { CardProps, CardAppearance, CardPlatform, } from './view/Card/types';
+export interface RequestAccessContextProps extends AccessContext {
+    action?: ActionProps;
+    callToActionMessageKey?: RequestAccessMessageKey;
+    descriptiveMessageKey?: RequestAccessMessageKey;
+}
+export declare type InlinePreloaderStyle = 'on-left-with-skeleton' | 'on-right-without-skeleton';
+export declare type LozengeColor = 'default' | 'success' | 'removed' | 'inprogress' | 'new' | 'moved';
+export interface LozengeProps {
+    text: string;
+    appearance?: LozengeColor;
+    isBold?: boolean;
+}

package/dist/types-ts4.0/utils/analytics/__mocks__/analytics.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/types-ts4.0/utils/analytics/analytics.d.ts

@@ -0,0 +1,32 @@
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { AnalyticsPayload } from '../types';
+import { CardInnerAppearance } from '../../view/Card/types';
+import { ConnectFailedEventProps, ConnectSucceededEventProps, InvokeFailedEventProps, InvokeSucceededEventProps, ResolvedEventProps, ScreenAuthPopupEventProps, TrackAppAccountConnectedProps, UiActionClickedEventProps, UiAuthAlternateAccountEventProps, UiAuthEventProps, UiCardClickedEventProps, UiClosedAuthEventProps, UiHoverCardDismissedEventProps, UiHoverCardOpenLinkClickedEventProps, UiHoverCardViewedEventProps, UiRenderFailedEventProps, UiRenderSuccessEventProps, UnresolvedEventProps } from './types';
+export declare const ANALYTICS_CHANNEL = "media";
+export declare const context: {
+    componentName: string;
+    packageName: any;
+    packageVersion: any;
+};
+export declare class SmartLinkEvents {
+    insertSmartLink(url: string, type: CardInnerAppearance, createAnalyticsEvent?: CreateUIAnalyticsEvent): void;
+}
+export declare const fireSmartLinkEvent: (payload: AnalyticsPayload, createAnalyticsEvent?: CreateUIAnalyticsEvent | undefined) => void;
+export declare const resolvedEvent: (props: ResolvedEventProps) => AnalyticsPayload;
+export declare const unresolvedEvent: ({ id, definitionId, extensionKey, resourceType, destinationSubproduct, destinationProduct, error, status, location, }: UnresolvedEventProps) => AnalyticsPayload;
+export declare const invokeSucceededEvent: ({ id, actionType, display, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: InvokeSucceededEventProps) => AnalyticsPayload;
+export declare const invokeFailedEvent: ({ id, actionType, display, reason, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: InvokeFailedEventProps) => AnalyticsPayload;
+export declare const connectSucceededEvent: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, }: ConnectSucceededEventProps) => AnalyticsPayload;
+export declare const connectFailedEvent: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, reason, }: ConnectFailedEventProps) => AnalyticsPayload;
+export declare const trackAppAccountConnected: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, }: TrackAppAccountConnectedProps) => AnalyticsPayload;
+export declare const uiAuthEvent: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, display, }: UiAuthEventProps) => AnalyticsPayload;
+export declare const uiAuthAlternateAccountEvent: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, display, }: UiAuthAlternateAccountEventProps) => AnalyticsPayload;
+export declare const uiCardClickedEvent: ({ id, display, status, definitionId, extensionKey, isModifierKeyPressed, location, destinationProduct, destinationSubproduct, actionSubjectId, }: UiCardClickedEventProps) => AnalyticsPayload;
+export declare const uiActionClickedEvent: ({ id, actionType, extensionKey, display, definitionId, destinationProduct, destinationSubproduct, location, }: UiActionClickedEventProps) => AnalyticsPayload;
+export declare const uiClosedAuthEvent: ({ display, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: UiClosedAuthEventProps) => AnalyticsPayload;
+export declare const screenAuthPopupEvent: ({ extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: ScreenAuthPopupEventProps) => AnalyticsPayload;
+export declare const uiRenderSuccessEvent: ({ display, status, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: UiRenderSuccessEventProps) => AnalyticsPayload;
+export declare const uiRenderFailedEvent: ({ display, error, errorInfo, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: UiRenderFailedEventProps) => AnalyticsPayload;
+export declare const uiHoverCardViewedEvent: ({ id, previewDisplay, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, previewInvokeMethod, }: UiHoverCardViewedEventProps) => AnalyticsPayload;
+export declare const uiHoverCardDismissedEvent: ({ id, previewDisplay, hoverTime, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, previewInvokeMethod, }: UiHoverCardDismissedEventProps) => AnalyticsPayload;
+export declare const uiHoverCardOpenLinkClickedEvent: ({ id, previewDisplay, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, previewInvokeMethod, }: UiHoverCardOpenLinkClickedEventProps) => AnalyticsPayload;

package/dist/types-ts4.0/utils/analytics/index.d.ts

@@ -0,0 +1,4 @@
+import { AnalyticsPayload } from '../types';
+import { InstrumentEventProps } from './types';
+export { ANALYTICS_CHANNEL, context, fireSmartLinkEvent, resolvedEvent, unresolvedEvent, invokeSucceededEvent, invokeFailedEvent, connectSucceededEvent, connectFailedEvent, trackAppAccountConnected, uiAuthEvent, uiAuthAlternateAccountEvent, uiCardClickedEvent, uiActionClickedEvent, uiClosedAuthEvent, screenAuthPopupEvent, uiRenderSuccessEvent, uiRenderFailedEvent, uiHoverCardViewedEvent, uiHoverCardDismissedEvent, uiHoverCardOpenLinkClickedEvent, } from './analytics';
+export declare const instrumentEvent: ({ id, status, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, error, }: InstrumentEventProps) => AnalyticsPayload | undefined;

package/dist/types-ts4.0/utils/analytics/types.d.ts

@@ -0,0 +1,93 @@
+import { APIError, CardType } from '@atlaskit/linking-common';
+import { PreviewDisplay, PreviewInvokeMethod } from '../../view/HoverCard/types';
+import { ErrorInfo } from 'react';
+import { CardInnerAppearance } from '../../view/Card/types';
+import { InvokeType } from '../../model/invoke-opts';
+export declare type DestinationProduct = 'jira' | 'confluence' | 'bitbucket' | 'trello';
+export declare type DestinationSubproduct = 'core' | 'software' | 'servicedesk';
+export interface CommonEventProps {
+    id?: string;
+    definitionId?: string;
+    extensionKey?: string;
+    resourceType?: string;
+    destinationSubproduct?: DestinationSubproduct | string;
+    destinationProduct?: DestinationProduct | string;
+    location?: string;
+}
+export declare type ResolvedEventProps = CommonEventProps & {
+    id: string;
+};
+export declare type UnresolvedEventProps = CommonEventProps & {
+    id: string;
+    status: string;
+    error?: APIError;
+};
+export declare type InvokeSucceededEventProps = CommonEventProps & {
+    id: string;
+    actionType: string;
+    display: CardInnerAppearance;
+};
+export declare type InvokeFailedEventProps = CommonEventProps & {
+    id: string;
+    actionType: string;
+    display: CardInnerAppearance;
+    reason: string;
+};
+export declare type ConnectSucceededEventProps = CommonEventProps & {
+    id?: string;
+};
+export declare type ConnectFailedEventProps = CommonEventProps & {
+    id?: string;
+    reason?: string;
+};
+export declare type TrackAppAccountConnectedProps = CommonEventProps;
+export declare type UiAuthEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+};
+export declare type UiAuthAlternateAccountEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+};
+export declare type UiCardClickedEventProps = CommonEventProps & {
+    id: string;
+    display: CardInnerAppearance;
+    status: CardType;
+    isModifierKeyPressed?: boolean;
+    actionSubjectId?: string;
+};
+export declare type UiActionClickedEventProps = CommonEventProps & {
+    id: string;
+    display: CardInnerAppearance;
+    actionType: string;
+    invokeType?: InvokeType;
+};
+export declare type ScreenAuthPopupEventProps = CommonEventProps;
+export declare type UiClosedAuthEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+};
+export declare type UiRenderSuccessEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+    status: CardType;
+};
+export declare type UiRenderFailedEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+    error: Error;
+    errorInfo: ErrorInfo;
+};
+export declare type UiHoverCardViewedEventProps = CommonEventProps & {
+    previewDisplay: PreviewDisplay;
+    previewInvokeMethod?: PreviewInvokeMethod;
+};
+export declare type UiHoverCardDismissedEventProps = CommonEventProps & {
+    previewDisplay: PreviewDisplay;
+    hoverTime: number;
+    previewInvokeMethod?: PreviewInvokeMethod;
+};
+export declare type UiHoverCardOpenLinkClickedEventProps = CommonEventProps & {
+    previewDisplay: PreviewDisplay;
+    previewInvokeMethod?: PreviewInvokeMethod;
+};
+export declare type InstrumentEventProps = CommonEventProps & {
+    error?: APIError;
+    status: CardType;
+    id: string;
+};

package/dist/types-ts4.0/utils/flexible.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare const isFlexibleUiCard: (children?: React.ReactNode) => boolean;
+export declare const isFlexibleUiBlock: (node: React.ReactNode) => boolean;
+export declare const isFlexibleUiElement: (node: React.ReactNode) => boolean;
+export declare const isFlexibleUiTitleBlock: (node: React.ReactNode) => boolean;

package/dist/types-ts4.0/utils/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { CardProps } from '../view/Card';
+export declare const isCardWithData: (props: CardProps) => boolean;
+export declare const isSpecialEvent: (evt: React.MouseEvent | React.KeyboardEvent) => boolean;
+export declare const isIframe: () => boolean;
+export declare const isSpecialKey: (event: React.MouseEvent | React.KeyboardEvent) => boolean;
+export declare const isSpecialClick: (event: React.MouseEvent) => boolean;
+export declare const getIconForFileType: (fileMimeType: string) => React.ReactNode | undefined;
+export declare const getLabelForFileType: (fileMimeType: string) => React.ReactNode | undefined;
+export declare const getIframeSandboxAttribute: (isTrusted: boolean) => "allow-downloads allow-forms allow-popups allow-popups-to-escape-sandbox allow-presentation allow-same-origin allow-scripts" | undefined;
+export declare const handleOnClick: (handler: Function) => (e: React.BaseSyntheticEvent) => void;
+export declare const isIntersectionObserverSupported: () => boolean;

package/dist/types-ts4.0/utils/jsonld.d.ts

@@ -0,0 +1,3 @@
+import { JsonLd } from 'json-ld-types';
+export declare const getEmptyJsonLd: () => JsonLd.Data.BaseData;
+export declare const getUnauthorizedJsonLd: () => JsonLd.Response;

package/dist/types-ts4.0/utils/mocks.d.ts

@@ -0,0 +1,74 @@
+import { JsonLd } from 'json-ld-types';
+export declare const mockContext: {
+    readonly '@vocab': "https://www.w3.org/ns/activitystreams#";
+    readonly atlassian: "https://schema.atlassian.com/ns/vocabulary#";
+    readonly schema: "http://schema.org/";
+};
+export declare const mocks: {
+    success: JsonLd.Response<JsonLd.Data.BaseData>;
+    notFound: JsonLd.Response<JsonLd.Data.BaseData>;
+    forbidden: JsonLd.Response<JsonLd.Data.BaseData>;
+    unauthorized: JsonLd.Response<JsonLd.Data.BaseData>;
+    actionSuccess: {
+        meta: {
+            visibility: string;
+            access: string;
+            auth: never[];
+            definitionId: string;
+        };
+        data: {
+            status: string;
+        };
+    };
+    analytics: {
+        status: string;
+        details: {
+            meta: {
+                definitionId: string;
+                key: string;
+                resourceType: string;
+                subproduct: string;
+                product: string;
+            };
+        };
+    };
+};
+export declare const fakeResponse: () => Promise<JsonLd.Response<JsonLd.Data.BaseData>>;
+export declare const fakeFactory: any;
+export declare const waitFor: (time?: number) => Promise<unknown>;
+export declare const mockAnalytics: {
+    ui: {
+        authEvent: ({ display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiAuthEventProps) => void;
+        authAlternateAccountEvent: ({ display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiAuthAlternateAccountEventProps) => void;
+        buttonClickedEvent: (data: Partial<import("./types").AnalyticsPayload> & {
+            actionSubjectId: string;
+        }) => void;
+        cardClickedEvent: ({ id, display, status, definitionId, extensionKey, isModifierKeyPressed, location, destinationProduct, destinationSubproduct, actionSubjectId, }: import("./analytics/types").UiCardClickedEventProps) => void;
+        actionClickedEvent: ({ id, actionType, display, invokeType, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiActionClickedEventProps) => void;
+        hoverCardOpenLinkClickedEvent: ({ previewDisplay, definitionId, extensionKey, destinationProduct, destinationSubproduct, location, previewInvokeMethod, }: import("./analytics/types").UiHoverCardOpenLinkClickedEventProps) => void;
+        closedAuthEvent: ({ display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiClosedAuthEventProps) => void;
+        modalClosedEvent: (data: Partial<import("./types").AnalyticsPayload> & {
+            actionSubjectId: string;
+        }) => void;
+        renderSuccessEvent: ({ display, status, id, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiRenderSuccessEventProps) => void;
+        renderFailedEvent: ({ display, id, error, errorInfo, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiRenderFailedEventProps) => void;
+        hoverCardViewedEvent: ({ previewDisplay, previewInvokeMethod, id, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiHoverCardViewedEventProps) => void;
+        hoverCardDismissedEvent: ({ id, previewDisplay, hoverTime, previewInvokeMethod, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").UiHoverCardDismissedEventProps) => void;
+    };
+    operational: {
+        invokeSucceededEvent: ({ id, actionType, display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").InvokeSucceededEventProps) => void;
+        invokeFailedEvent: ({ id, actionType, display, reason, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").InvokeFailedEventProps) => void;
+        connectSucceededEvent: ({ id, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").ConnectSucceededEventProps) => void;
+        connectFailedEvent: ({ id, reason, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").ConnectFailedEventProps) => void;
+        instrument: ({ id, status, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, error, }: import("./analytics/types").InstrumentEventProps) => void;
+    };
+    track: {
+        appAccountConnected: ({ extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").CommonEventProps) => void;
+    };
+    screen: {
+        authPopupEvent: ({ extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("./analytics/types").CommonEventProps) => void;
+        modalViewedEvent: (data: Partial<import("./types").AnalyticsPayload> & {
+            name: "embedPreviewModal";
+        }) => void;
+    };
+};

package/dist/types-ts4.0/utils/performance.d.ts

@@ -0,0 +1,8 @@
+import { CardType } from '@atlaskit/linking-common';
+export declare const getMarkName: (id: string, status: CardType) => string;
+export declare const getMeasureName: (id: string, status: CardType) => string;
+export declare const clearMarks: (id: string) => void;
+export declare const clearMeasures: (id: string) => void;
+export declare const getMeasure: (id: string, status: CardType) => PerformanceEntry | undefined;
+export declare const mark: (id: string, status: CardType) => void;
+export declare const create: (id: string, status: CardType) => void;

package/dist/types-ts4.0/utils/test-utils.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { ProviderProps } from '../state';
+export declare const renderHook: (callback: Function) => JSX.Element;
+export declare const renderSmartLinkHook: (callback: Function, providerProps?: Partial<ProviderProps> | undefined) => JSX.Element;

package/dist/types-ts4.0/utils/token.d.ts

@@ -0,0 +1,16 @@
+export declare const tokens: {
+    actionIcon: "var(--ds-icon)";
+    background: "var(--ds-surface-raised)";
+    badgeIcon: "var(--ds-icon-subtle)";
+    badgeText: "var(--ds-text-subtlest)";
+    blackLink: "var(--ds-text-subtle)";
+    blackLinkPressed: "var(--ds-text)";
+    blueLink: "var(--ds-link)";
+    blueLinkPressed: "var(--ds-link-pressed)";
+    elevation: "var(--ds-shadow-raised)";
+    errorMessage: "var(--ds-text-disabled)";
+    errorMessageHover: "var(--ds-text-subtle)";
+    focus: "var(--ds-border-focused)";
+    snippet: "var(--ds-text)";
+    text: "var(--ds-text-subtlest)";
+};

package/dist/types-ts4.0/utils/types.d.ts

@@ -0,0 +1,14 @@
+import { GasPayload } from '@atlaskit/analytics-gas-types';
+import { CardInnerAppearance } from '../view/Card/types';
+export declare type AnalyticsAction = 'resolved' | 'unresolved' | 'connectSucceeded' | 'connectFailed' | 'connected' | 'clicked' | 'closed' | 'renderFailed' | 'renderWithStatus' | 'renderSuccess' | 'inserted' | 'viewed' | 'dismissed' | 'created';
+export declare type AnalyticsActionSubject = 'smartLink' | 'smartLinkAction' | 'applicationAccount' | 'button' | 'consentModal' | 'hoverCard' | 'modal' | 'embedPreviewModal';
+export declare type AnalyticsName = 'embedPreviewModal';
+export declare type AnalyticsOrigin = 'smartLinkCard' | 'smartLinkEmbed' | 'smartLinkInline' | 'smartLinkPreviewHoverCard';
+export declare type AnalyticsPayload = GasPayload & {
+    action?: AnalyticsAction;
+    actionSubject: AnalyticsActionSubject;
+    attributes: GasPayload['attributes'] & {
+        display?: CardInnerAppearance;
+    };
+};
+export declare type AnalyticsHandler = (event: AnalyticsPayload) => void;