@atlaskit/util-data-test 17.8.2 → 17.8.4

package/dist/types-ts4.5/mention/src/types.d.ts

@@ -0,0 +1,168 @@
+import { SyntheticEvent } from 'react';
+import { ServiceConfig } from '@atlaskit/util-service-support/types';
+export interface MentionNameResolver {
+    lookupName(id: string): Promise<MentionNameDetails> | MentionNameDetails;
+    cacheName(id: string, name: string): void;
+}
+export type MentionStats = {
+    [key: string]: any;
+};
+export interface ResultCallback<T> {
+    (result: T, query?: string, stats?: MentionStats): void;
+}
+export interface ErrorCallback {
+    (error: Error, query?: string): void;
+}
+export interface InfoCallback {
+    (info: string): void;
+}
+export interface AnalyticsCallback {
+    (event: string, actionSubject: string, action: string, attributes?: {
+        [key: string]: any;
+    }): void;
+}
+export interface MentionResourceConfig extends ServiceConfig {
+    containerId?: string;
+    productId?: string;
+    shouldHighlightMention?: (mention: MentionDescription) => boolean;
+    inviteExperimentCohort?: InviteExperimentCohort;
+    mentionNameResolver?: MentionNameResolver;
+    shouldEnableInvite?: boolean;
+    onInviteItemClick?: (flow: InviteFlow) => void;
+    userRole?: UserRole;
+    productName?: string;
+    debounceTime?: number;
+}
+export interface ResourceProvider<Result> {
+    /**
+     * Subscribe to ResourceProvider results
+     *
+     * @param {string} key subscriber key used to unsubscribe
+     * @param {ResultCallback<Result>} callback This callback only receives latest results
+     * @param {ErrorCallback} errCallback This callback will errors
+     * @param {InfoCallback} infoCallback This callback will info
+     * @param {ResultCallback<Result>} allResultsCallback This callback will receive all results
+     */
+    subscribe(key: string, callback?: ResultCallback<Result>, errCallback?: ErrorCallback, infoCallback?: InfoCallback, allResultsCallback?: ResultCallback<Result>, analyticsCallback?: AnalyticsCallback): void;
+    /**
+     * Unsubscribe to this resource provider results
+     * @param {string} key key used when subscribing
+     */
+    unsubscribe(key: string): void;
+}
+export type MentionContextIdentifier = {
+    containerId?: string;
+    objectId?: string;
+    childObjectId?: string;
+    sessionId?: string;
+};
+export interface MentionProvider extends ResourceProvider<MentionDescription[]>, InviteFromMentionProvider {
+    filter(query?: string, contextIdentifier?: MentionContextIdentifier): void;
+    recordMentionSelection(mention: MentionDescription, contextIdentifier?: MentionContextIdentifier): void;
+    shouldHighlightMention(mention: MentionDescription): boolean;
+    isFiltering(query: string): boolean;
+}
+export interface HighlightDetail {
+    start: number;
+    end: number;
+}
+export interface Highlight {
+    name: HighlightDetail[];
+    mentionName: HighlightDetail[];
+    nickname: HighlightDetail[];
+}
+export interface Presence {
+    time?: string;
+    status?: string;
+}
+export type LozengeColor = 'default' | 'success' | 'removed' | 'inprogress' | 'new' | 'moved';
+export interface LozengeProps {
+    text: React.ReactNode;
+    appearance?: LozengeColor;
+}
+export interface MentionDescription {
+    id: string;
+    avatarUrl?: string;
+    name?: string;
+    mentionName?: string;
+    nickname?: string;
+    highlight?: Highlight;
+    lozenge?: string | LozengeProps;
+    presence?: Presence;
+    accessLevel?: string;
+    inContext?: boolean;
+    userType?: string;
+    context?: MentionDescContext;
+    source?: string;
+}
+export interface MentionDescContext {
+    members: TeamMember[];
+    includesYou: boolean;
+    memberCount: number;
+    teamLink: string;
+}
+export interface MentionsResult {
+    mentions: MentionDescription[];
+    query: string;
+}
+export interface TeamMember {
+    id: string;
+    name: string;
+}
+export interface Team {
+    id: string;
+    smallAvatarImageUrl: string;
+    displayName: string;
+    members: TeamMember[];
+    includesYou: boolean;
+    memberCount: number;
+    highlight?: Highlight;
+}
+export type MentionEventHandler = (mentionId: string, text: string, event?: SyntheticEvent<HTMLSpanElement>) => void;
+export interface OnMentionEvent {
+    (mention: MentionDescription, event?: SyntheticEvent<any>): void;
+}
+export declare enum MentionType {
+    SELF = 0,
+    RESTRICTED = 1,
+    DEFAULT = 2
+}
+export declare enum UserAccessLevel {
+    NONE = 0,
+    SITE = 1,
+    APPLICATION = 2,
+    CONTAINER = 3
+}
+export declare enum UserType {
+    DEFAULT = 0,
+    SPECIAL = 1,
+    APP = 2,
+    TEAM = 3,
+    SYSTEM = 4
+}
+export declare enum MentionNameStatus {
+    UNKNOWN = 0,
+    SERVICE_ERROR = 1,
+    OK = 2
+}
+export interface MentionNameDetails {
+    id: string;
+    name?: string;
+    status: MentionNameStatus;
+}
+export declare function isRestricted(accessLevel?: string): boolean;
+export declare function isSpecialMention(mention: MentionDescription): boolean;
+export declare function isAppMention(mention: MentionDescription): boolean | "" | undefined;
+export declare function isTeamMention(mention: MentionDescription): boolean | "" | undefined;
+export declare function isSpecialMentionText(mentionText: string): boolean | "";
+export declare const isPromise: <T>(p: any) => p is Promise<T>;
+export type InviteFlow = 'mention' | 'assign';
+export type UserRole = 'admin' | 'trusted' | 'basic';
+export type InviteExperimentCohort = 'variation' | 'control' | 'not-enrolled';
+export interface InviteFromMentionProvider {
+    productName?: string;
+    shouldEnableInvite?: boolean;
+    inviteExperimentCohort?: InviteExperimentCohort;
+    onInviteItemClick?(flow: InviteFlow): void;
+    userRole?: UserRole;
+}

package/dist/types-ts4.5/mention/src/util/analytics.d.ts

@@ -0,0 +1,30 @@
+import { UIAnalyticsEvent, WithAnalyticsEventsProps, CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { GasPayload } from '@atlaskit/analytics-gas-types';
+export declare const SLI_EVENT_TYPE = "sli";
+export declare const SMART_EVENT_TYPE = "smart";
+export declare enum SliNames {
+    SEARCH = "searchUser",
+    SEARCH_TEAM = "searchTeam",
+    INITIAL_STATE = "initialState",
+    SELECT = "select",
+    SELECT_TEAM = "selectTeam"
+}
+export declare enum ComponentNames {
+    TYPEAHEAD = "mentionTypeahead",
+    MENTION = "mention"
+}
+export declare enum Actions {
+    VIEWED = "viewed",
+    CLICKED = "clicked",
+    CLOSED = "closed",
+    SUCCEEDED = "succeeded",
+    FAILED = "failed"
+}
+export declare const fireAnalyticsMentionTypeaheadEvent: (props: WithAnalyticsEventsProps) => (action: string, duration: number, userIds?: string[], query?: string) => void;
+export declare const fireAnalyticsMentionEvent: (createEvent: CreateUIAnalyticsEvent) => (actionSubject: string, action: string, text: string, id: string, accessLevel?: string) => UIAnalyticsEvent;
+export declare const fireSliAnalyticsEvent: (props: WithAnalyticsEventsProps) => (actionSubject: string, action: string) => void;
+export declare const buildSliPayload: (actionSubject: string, action: string, attributes?: {
+    [key: string]: any;
+} | undefined) => GasPayload;
+export declare const fireAnalyticsMentionHydrationEvent: (props: WithAnalyticsEventsProps) => (action: string, userId: string, fromCache: boolean, duration: number) => void;
+export declare const fireAnalytics: (firePrivateAnalyticsEvent?: Function) => (eventName: string, text: string, accessLevel?: string) => void;

package/dist/types-ts4.5/mention/src/util/i18n.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { MessageDescriptor } from 'react-intl-next';
+export type Formatter = (props: {
+    values?: {
+        [k: string]: string;
+    };
+    children?(props: string): React.ReactElement;
+}) => React.ReactElement | null;
+type FormatterFactory = (messageDescriptor: MessageDescriptor) => Formatter;
+export declare const propFormatter: FormatterFactory;
+export declare const UnknownUserError: Formatter;
+export declare const NoAccessWarning: Formatter;
+export declare const NoAccessLabel: Formatter;
+export declare const DefaultHeadline: Formatter;
+export declare const DefaultAdvisedAction: Formatter;
+export declare const LoginAgain: Formatter;
+export declare const DifferentText: Formatter;
+/**
+ * Tries to get the most specific messages bundle for a given locale.
+ *
+ * Strategy:
+ * 1. Try to find messages with the exact string (i.e. 'fr_FR')
+ * 2. If that doesn't work, try to find messages for the country locale (i.e. 'fr')
+ * 3. If that doesn't work, return english messages as a fallback.
+ *
+ * @param locale string specifying the locale like 'en_GB', or 'fr'.
+ */
+export declare const getMessagesForLocale: (locale: string) => Promise<Record<string, string>>;
+export {};

package/dist/types-ts4.5/mention/src/util/id.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (prefix?: string) => string;
+export default _default;

package/dist/types-ts4.5/mention/src/util/index.d.ts

@@ -0,0 +1 @@
+export declare const padArray: (arr: any[], size: number, value: any) => any[];

package/dist/types-ts4.5/mention/src/util/mouse.d.ts

@@ -0,0 +1,8 @@
+import { MouseEvent } from 'react';
+export interface Position {
+    x: number;
+    y: number;
+}
+export declare function mouseLocation(event: MouseEvent<any>): Position;
+export declare function actualMouseMove(oldPosition: Position | undefined, newPosition: Position): boolean;
+export declare function leftClick(event: MouseEvent<any>): boolean;

package/dist/types-ts4.5/task-decision/src/analytics/index.d.ts

@@ -0,0 +1,2 @@
+export declare const fabricElementsChannel = "fabric-elements";
+export declare const createAndFireEventInElementsChannel: (payload: import("@atlaskit/analytics-next").AnalyticsEventPayload) => (createAnalyticsEvent: import("@atlaskit/analytics-next").CreateUIAnalyticsEvent) => import("@atlaskit/analytics-next").UIAnalyticsEvent;

package/dist/types-ts4.5/task-decision/src/api/TaskDecisionResource.d.ts

@@ -0,0 +1,67 @@
+import { BaseItem, ServiceTaskState, DecisionState, Handler, ObjectKey, PubSubClient, RecentUpdateContext, RecentUpdatesId, RecentUpdatesListener, ServiceTask, TaskDecisionProvider, TaskDecisionResourceConfig, TaskState, ServiceItem } from '../types';
+export declare const ACTION_CREATED_FPS_EVENT = "avi:task-decision-service:created:action";
+export declare const ACTION_EDITED_FPS_EVENT = "avi:task-decision-service:edited:action";
+export declare const ACTION_DELETED_FPS_EVENT = "avi:task-decision-service:deleted:action";
+export declare const ACTION_ARCHIVED_FPS_EVENT = "avi:task-decision-service:archived:action";
+export declare const ACTION_STATE_CHANGED_FPS_EVENT = "avi:task-decision-service:stateChanged:action";
+export declare const DECISION_CREATED_FPS_EVENT = "avi:task-decision-service:created:decision";
+export declare const DECISION_EDITED_FPS_EVENT = "avi:task-decision-service:edited:decision";
+export declare const DECISION_DELETED_FPS_EVENT = "avi:task-decision-service:deleted:decision";
+export declare const DECISION_ARCHIVED_FPS_EVENT = "avi:task-decision-service:archived:decision";
+export declare const DECISION_STATE_CHANGED_FPS_EVENT = "avi:task-decision-service:stateChanged:decision";
+export declare const ACTION_DECISION_FPS_EVENTS = "avi:task-decision-service:*:*";
+export declare class RecentUpdates {
+    private idsByContainer;
+    private listenersById;
+    private pubSubClient?;
+    constructor(pubSubClient?: PubSubClient);
+    subscribe(objectAri: string, recentUpdatesListener: RecentUpdatesListener): void;
+    unsubscribe(unsubscribeId: RecentUpdatesId): void;
+    notify(recentUpdateContext: RecentUpdateContext): void;
+    onPubSubEvent: (_event: string, payload: ServiceItem) => void;
+    destroy(): void;
+    private subscribeToPubSubEvents;
+    private unsubscribeFromPubSubEvents;
+}
+export declare class ItemStateManager {
+    private debouncedTaskStateQuery;
+    private debouncedTaskToggle;
+    private serviceConfig;
+    private subscribers;
+    private trackedObjectKeys;
+    private cachedItems;
+    private batchedKeys;
+    constructor(serviceConfig: TaskDecisionResourceConfig);
+    destroy(): void;
+    toggleTask(objectKey: ObjectKey, state: TaskState): Promise<TaskState>;
+    refreshAllTasks(): void;
+    subscribe(objectKey: ObjectKey, handler: Handler, item?: BaseItem<TaskState | DecisionState>): void;
+    unsubscribe(objectKey: ObjectKey, handler: Handler): void;
+    getTaskState(keys: ObjectKey[]): Promise<ServiceTaskState[]>;
+    notifyUpdated(objectKey: ObjectKey, state: TaskState | DecisionState): void;
+    onTaskUpdatedEvent: (_event: string, payload: ServiceTask) => void;
+    onReconnect: () => void;
+    private updateCache;
+    private getCached;
+    private subscribeToPubSubEvents;
+    private unsubscribeFromPubSubEvents;
+    private queueAllItems;
+    private queueItem;
+    private dequeueItem;
+    private scheduleGetTaskState;
+}
+export default class TaskDecisionResource implements TaskDecisionProvider {
+    private recentUpdates;
+    private itemStateManager;
+    constructor(serviceConfig: TaskDecisionResourceConfig);
+    unsubscribeRecentUpdates(id: RecentUpdatesId): void;
+    notifyRecentUpdates(recentUpdateContext: RecentUpdateContext): void;
+    toggleTask(objectKey: ObjectKey, state: TaskState): Promise<TaskState>;
+    subscribe(objectKey: ObjectKey, handler: Handler, item?: BaseItem<TaskState | DecisionState>): void;
+    unsubscribe(objectKey: ObjectKey, handler: Handler): void;
+    /**
+     * Usually only needed for testing to ensure no outstanding requests
+     * are sent to a server (typically mocked).
+     */
+    destroy(): void;
+}

package/dist/types-ts4.5/task-decision/src/api/TaskDecisionUtils.d.ts

@@ -0,0 +1,4 @@
+import { ServiceTask, Task, ServiceTaskState, BaseItem, TaskState } from '../types';
+export declare const convertServiceTaskToTask: (serviceTask: ServiceTask) => Task;
+export declare const convertServiceTaskStateToBaseItem: (serviceTaskInfo: ServiceTaskState) => BaseItem<TaskState>;
+export declare const findIndex: (array: any[], predicate: (item: any) => boolean) => number;

package/dist/types-ts4.5/task-decision/src/components/DecisionItem.d.ts

@@ -0,0 +1,15 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { Appearance, ContentRef } from '../types';
+export interface Props {
+    children?: any;
+    contentRef?: ContentRef;
+    placeholder?: string;
+    showPlaceholder?: boolean;
+    appearance?: Appearance;
+    dataAttributes?: {
+        [key: string]: string | number;
+    };
+}
+declare const DecisionItem: ({ appearance, children, contentRef, placeholder, showPlaceholder, dataAttributes, }: Props) => jsx.JSX.Element;
+export default DecisionItem;

package/dist/types-ts4.5/task-decision/src/components/DecisionList.d.ts

@@ -0,0 +1,9 @@
+/** @jsx jsx */
+import { PureComponent, ReactNode } from 'react';
+import { jsx } from '@emotion/react';
+export interface Props {
+    children?: ReactNode;
+}
+export default class DecisionList extends PureComponent<Props, {}> {
+    render(): jsx.JSX.Element | null;
+}

package/dist/types-ts4.5/task-decision/src/components/Item.d.ts

@@ -0,0 +1,25 @@
+/** @jsx jsx */
+import { PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+import { Appearance, ContentRef, TaskType, DecisionType } from '../types';
+import type { Theme } from '@atlaskit/theme/types';
+export interface Props {
+    icon: JSX.Element;
+    itemType: TaskType | DecisionType;
+    children?: any;
+    appearance?: Appearance;
+    contentRef?: ContentRef;
+    placeholder?: string;
+    showPlaceholder?: boolean;
+    dataAttributes?: {
+        [key: string]: string | number;
+    };
+    checkBoxId?: string;
+    theme: Theme;
+}
+export default class Item extends PureComponent<Props, {}> {
+    static defaultProps: Partial<Props>;
+    private renderPlaceholder;
+    renderMessageAppearance(): jsx.JSX.Element | null;
+    render(): jsx.JSX.Element | null;
+}

package/dist/types-ts4.5/task-decision/src/components/ResourcedTaskItem.d.ts

@@ -0,0 +1,35 @@
+import { PureComponent } from 'react';
+import { Appearance, ContentRef, TaskDecisionProvider } from '../types';
+export interface Props {
+    taskId: string;
+    isDone?: boolean;
+    isRenderer?: boolean;
+    onChange?: (taskId: string, isChecked: boolean) => void;
+    contentRef?: ContentRef;
+    children?: any;
+    taskDecisionProvider?: Promise<TaskDecisionProvider>;
+    objectAri?: string;
+    showPlaceholder?: boolean;
+    placeholder?: string;
+    appearance?: Appearance;
+    disabled?: boolean;
+    dataAttributes?: {
+        [key: string]: string | number;
+    };
+}
+export interface State {
+    isDone?: boolean;
+}
+export default class ResourcedTaskItem extends PureComponent<Props, State> {
+    static defaultProps: Partial<Props>;
+    private mounted;
+    constructor(props: Props);
+    componentDidMount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    componentWillUnmount(): void;
+    private subscribe;
+    private unsubscribe;
+    private onUpdate;
+    private handleOnChange;
+    render(): JSX.Element;
+}

package/dist/types-ts4.5/task-decision/src/components/TaskItem.d.ts

@@ -0,0 +1,21 @@
+/** @jsx jsx */
+import React from 'react';
+import { Appearance, ContentRef } from '../types';
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+export interface Props {
+    taskId: string;
+    isDone?: boolean;
+    isRenderer?: boolean;
+    onChange?: (taskId: string, isChecked: boolean) => void;
+    contentRef?: ContentRef;
+    children?: any;
+    placeholder?: string;
+    showPlaceholder?: boolean;
+    appearance?: Appearance;
+    disabled?: boolean;
+    dataAttributes?: {
+        [key: string]: string | number;
+    };
+}
+declare const _default: React.ForwardRefExoticComponent<Omit<Props & WithAnalyticsEventsProps, keyof WithAnalyticsEventsProps> & React.RefAttributes<any>>;
+export default _default;

package/dist/types-ts4.5/task-decision/src/components/TaskList.d.ts

@@ -0,0 +1,9 @@
+import { PureComponent, ReactNode } from 'react';
+import { jsx } from '@emotion/react';
+export interface Props {
+    listId?: string;
+    children?: ReactNode;
+}
+export default class TaskList extends PureComponent<Props, {}> {
+    render(): jsx.JSX.Element | null;
+}

package/dist/types-ts4.5/task-decision/src/components/styles.d.ts

@@ -0,0 +1,13 @@
+import type { Theme } from '@atlaskit/theme/types';
+export declare const listStyles: import("@emotion/react").SerializedStyles;
+export declare const taskListStyles: import("@emotion/react").SerializedStyles;
+export declare const contentStyles: import("@emotion/react").SerializedStyles;
+export declare const taskStyles: import("@emotion/react").SerializedStyles;
+export declare const decisionStyles: (theme: Theme) => import("@emotion/react").SerializedStyles;
+export declare const placeholderStyles: (offset: number) => import("@emotion/react").SerializedStyles;
+/**
+ * References packages/design-system/checkbox/src/checkbox.tsx
+ * To be used until mobile editor does not require legacy themed() API anymore,
+ * which will allow migration to use @atlaskit/checkbox instead
+ */
+export declare const checkboxStyles: (isRenderer: boolean | undefined) => (theme: Theme) => import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/task-decision/src/components/theme.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Styles taken from packages/design-system/checkbox/src/internal/theme.tsx
+ * To be used until mobile editor does not require legacy themed() API anymore
+ */
+declare const checkboxTheme: {
+    light: {
+        borderColor: {
+            rest: "var(--ds-border-input)";
+            hovered: "var(--ds-border-input)";
+            disabled: "var(--ds-background-disabled)";
+            checked: "var(--ds-background-selected-bold)";
+            active: "var(--ds-border)";
+            focused: "var(--ds-border-focused)";
+            hoveredAndChecked: "var(--ds-background-selected-bold-hovered)";
+        };
+        boxColor: {
+            rest: "var(--ds-background-input)";
+            hovered: "var(--ds-background-input-hovered)";
+            disabled: "var(--ds-background-disabled)";
+            active: "var(--ds-background-input-pressed)";
+            hoveredAndChecked: "var(--ds-background-selected-bold-hovered)";
+            checked: "var(--ds-background-selected-bold)";
+        };
+        tickColor: {
+            disabledAndChecked: "var(--ds-icon-disabled)";
+            activeAndChecked: "var(--ds-icon-inverse)";
+            checked: "var(--ds-icon-inverse)";
+        };
+    };
+    /**
+     * Fallback colours for dark mode taken from
+     * packages/design-system/tokens/src/artifacts/themes/atlassian-dark.tsx
+     * To be used to keep mobile / web checkbox dark mode consistent
+     * until mobile editor does not require legacy themed() API anymore
+     */
+    dark: {
+        borderColor: {
+            rest: "var(--ds-border-input)";
+            hovered: "var(--ds-border-input)";
+            disabled: "var(--ds-background-disabled)";
+            checked: "var(--ds-background-selected-bold)";
+            active: "var(--ds-border)";
+            focused: "var(--ds-border-focused)";
+            hoveredAndChecked: "var(--ds-background-selected-bold-hovered)";
+        };
+        boxColor: {
+            rest: "var(--ds-background-input)";
+            hovered: "var(--ds-background-input-hovered)";
+            disabled: "var(--ds-background-disabled)";
+            active: "var(--ds-background-input-pressed)";
+            hoveredAndChecked: "var(--ds-background-selected-bold-hovered)";
+            checked: "var(--ds-background-selected-bold)";
+        };
+        tickColor: {
+            disabledAndChecked: "var(--ds-icon-disabled)";
+            activeAndChecked: "var(--ds-icon-inverse)";
+            checked: "var(--ds-icon-inverse)";
+        };
+    };
+};
+export default checkboxTheme;

package/dist/types-ts4.5/task-decision/src/index.d.ts

@@ -0,0 +1,9 @@
+import DecisionItem from './components/DecisionItem';
+import DecisionList from './components/DecisionList';
+import ResourcedTaskItem from './components/ResourcedTaskItem';
+import TaskDecisionResource from './api/TaskDecisionResource';
+import TaskItem from './components/TaskItem';
+import TaskList from './components/TaskList';
+export { PubSubSpecialEventType } from './types';
+export type { Appearance, ARI, AVI, BaseItem, ContentRef, Cursor, Decision, DecisionState, DecisionStatus, DecisionType, Handler, Item, Meta, ObjectKey, OnUpdate, PubSubClient, PubSubOnEvent, RecentUpdateContext, RecentUpdatesId, RecentUpdatesListener, RenderDocument, RendererContext, ServiceDecision, ServiceDecisionResponse, ServiceItem, ServiceTask, ServiceTaskState, Task, TaskDecisionProvider, TaskDecisionResourceConfig, TaskState, TaskType, UserId, } from './types';
+export { DecisionItem, DecisionList, ResourcedTaskItem, TaskDecisionResource, TaskItem, TaskList, };

package/dist/types-ts4.5/task-decision/src/type-helpers.d.ts

@@ -0,0 +1,6 @@
+import { BaseItem, Decision, Item, ObjectKey, ServiceDecision, ServiceTask, Task, TaskState } from './types';
+export declare const isDecision: (item: Item) => item is Decision;
+export declare const isTask: (item: Item) => item is Task;
+export declare const toObjectKey: (item: Item | ServiceDecision | ServiceTask | BaseItem<any>) => ObjectKey;
+export declare const objectKeyToString: (objectKey: ObjectKey) => string;
+export declare const toggleTaskState: (state: TaskState) => TaskState;