@atlaskit/collab-provider 8.8.0 → 8.8.1

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

@@ -0,0 +1,443 @@
+export declare enum INTERNAL_ERROR_CODE {
+    TOKEN_PERMISSION_ERROR = "TOKEN_PERMISSION_ERROR",
+    RECONNECTION_NETWORK_ISSUE = "RECONNECTION_NETWORK_ISSUE",
+    CONNECTION_ERROR = "CONNECTION_ERROR",
+    RECONNECTION_ERROR = "RECONNECTION_ERROR",
+    DOCUMENT_NOT_FOUND = "DOCUMENT_NOT_FOUND",
+    CATCHUP_FAILED = "CATCHUP_FAILED",
+    DOCUMENT_RESTORE_ERROR = "DOCUMENT_RESTORE_ERROR",
+    ADD_STEPS_ERROR = "ADD_STEPS_ERROR"
+}
+export declare enum NCS_ERROR_CODE {
+    HEAD_VERSION_UPDATE_FAILED = "HEAD_VERSION_UPDATE_FAILED",
+    VERSION_NUMBER_ALREADY_EXISTS = "VERSION_NUMBER_ALREADY_EXISTS",
+    INSUFFICIENT_EDITING_PERMISSION = "INSUFFICIENT_EDITING_PERMISSION",
+    FORBIDDEN_USER_TOKEN = "FORBIDDEN_USER_TOKEN",
+    DOCUMENT_NOT_FOUND = "DOCUMENT_NOT_FOUND",
+    INIT_DATA_LOAD_FAILED = "INIT_DATA_LOAD_FAILED",
+    ERROR_MAPPING_ERROR = "ERROR_MAPPING_ERROR",
+    NAMESPACE_INVALID = "NAMESPACE_INVALID",
+    NAMESPACE_NOT_FOUND = "NAMESPACE_NOT_FOUND",
+    TENANT_INSTANCE_MAINTENANCE = "TENANT_INSTANCE_MAINTENANCE",
+    LOCKED_DOCUMENT = "LOCKED_DOCUMENT",
+    EMPTY_BROADCAST = "EMPTY_BROADCAST",
+    DYNAMO_ERROR = "DYNAMO_ERROR",
+    INVALID_ACTIVATION_ID = "INVALID_ACTIVATION_ID",
+    INVALID_DOCUMENT_ARI = "INVALID_DOCUMENT_ARI",
+    INVALID_CLOUD_ID = "INVALID_CLOUD_ID"
+}
+declare type HeadVersionUpdateFailedError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.HEAD_VERSION_UPDATE_FAILED;
+        meta: {
+            currentVersion: any;
+            incomingVersion: number;
+        };
+        status: number;
+    };
+};
+declare type VersionAlreadyPresentInDynamoError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.VERSION_NUMBER_ALREADY_EXISTS;
+        meta: string;
+        status: number;
+    };
+};
+declare type InsufficientEditingPermissionError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.INSUFFICIENT_EDITING_PERMISSION;
+        meta: {
+            description: string;
+            reason?: string;
+        };
+        status: number;
+    };
+};
+declare type ForbiddenUserTokenError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.FORBIDDEN_USER_TOKEN;
+        meta: string;
+        status: number;
+    };
+};
+declare type NCSDocumentNotFoundError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.DOCUMENT_NOT_FOUND;
+        status: number;
+    };
+};
+declare type FailedToLoadInitDataError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.INIT_DATA_LOAD_FAILED;
+        status: number;
+    };
+};
+declare type ErrorMappingError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.ERROR_MAPPING_ERROR;
+        status: number;
+    };
+};
+declare type InvalidNamespaceDefinedError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.NAMESPACE_INVALID;
+        meta: string;
+        status: number;
+    };
+};
+declare type SocketNamespaceNotFoundError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.NAMESPACE_NOT_FOUND;
+        meta: string;
+        status: number;
+    };
+};
+declare type TenantInstanceMaintenanceError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.TENANT_INSTANCE_MAINTENANCE;
+        meta: {
+            description: string;
+            reason: string;
+        };
+        status: number;
+    };
+};
+declare type NamespaceLockedError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.LOCKED_DOCUMENT;
+        meta: string;
+        status: number;
+    };
+};
+declare type EmptyBroadcastError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.EMPTY_BROADCAST;
+        meta: string;
+        status: number;
+    };
+};
+declare type DynamoError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.DYNAMO_ERROR;
+        meta: string;
+        status: number;
+    };
+};
+declare type InvalidActivationIdError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.INVALID_ACTIVATION_ID;
+        meta: string;
+        status: number;
+    };
+};
+declare type InvalidDocumentAriError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.INVALID_DOCUMENT_ARI;
+        meta: string;
+        status: number;
+    };
+};
+declare type InvalidCloudIdError = {
+    message: string;
+    data: {
+        code: NCS_ERROR_CODE.INVALID_CLOUD_ID;
+        meta: string;
+        status: number;
+    };
+};
+declare type NCSErrors = HeadVersionUpdateFailedError | VersionAlreadyPresentInDynamoError | InsufficientEditingPermissionError | ForbiddenUserTokenError | NCSDocumentNotFoundError | FailedToLoadInitDataError | ErrorMappingError | InvalidNamespaceDefinedError | SocketNamespaceNotFoundError | TenantInstanceMaintenanceError | NamespaceLockedError | EmptyBroadcastError | DynamoError | InvalidActivationIdError | InvalidDocumentAriError | InvalidCloudIdError;
+declare type DocumentRecoveryError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.DOCUMENT_RESTORE_ERROR;
+        status: number;
+    };
+};
+declare type AddStepsError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.ADD_STEPS_ERROR;
+        status: number;
+    };
+};
+export declare type CatchUpFailedError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.CATCHUP_FAILED;
+        status: number;
+    };
+};
+export declare type TokenPermissionError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.TOKEN_PERMISSION_ERROR;
+        status: number;
+        meta: {
+            originalError?: unknown;
+            reason?: string;
+        };
+    };
+};
+export declare type ReconnectionError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.RECONNECTION_ERROR;
+        status: number;
+    };
+};
+export declare type ConnectionError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.CONNECTION_ERROR;
+    };
+};
+export declare type ReconnectionNetworkError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.RECONNECTION_NETWORK_ISSUE;
+    };
+};
+export declare type DocumentNotFoundError = {
+    message: string;
+    data: {
+        code: INTERNAL_ERROR_CODE.DOCUMENT_NOT_FOUND;
+        status: number;
+    };
+};
+/**
+ * A union of all possible internal errors, that are mapped to another error if being emitted to the editor.
+ */
+export declare type InternalError = NCSErrors | DocumentRecoveryError | AddStepsError | CatchUpFailedError | TokenPermissionError | ReconnectionError | ConnectionError | ReconnectionNetworkError | DocumentNotFoundError;
+export declare enum PROVIDER_ERROR_CODE {
+    NO_PERMISSION_ERROR = "NO_PERMISSION_ERROR",
+    INVALID_USER_TOKEN = "INVALID_USER_TOKEN",
+    DOCUMENT_NOT_FOUND = "DOCUMENT_NOT_FOUND",
+    LOCKED = "LOCKED",
+    FAIL_TO_SAVE = "FAIL_TO_SAVE",
+    DOCUMENT_RESTORE_ERROR = "DOCUMENT_RESTORE_ERROR",
+    INITIALISATION_ERROR = "INITIALISATION_ERROR",
+    NETWORK_ISSUE = "NETWORK_ISSUE",
+    INVALID_PROVIDER_CONFIGURATION = "INVALID_PROVIDER_CONFIGURATION",
+    INTERNAL_SERVICE_ERROR = "INTERNAL_SERVICE_ERROR"
+}
+/**
+ * This occurs when the provided user token is considered invalid for the given document ARI.
+ * It happens during initialisation of the provider.
+ * It could mean the document has been deleted (hence not found).
+ * @message Message returned to editor, i.e User does not have permissions to access this document or document is not found
+ * @recoverable It is recoverable, as we will try to refresh the token.
+ */
+declare type InsufficientEditingPermission = {
+    code: PROVIDER_ERROR_CODE.NO_PERMISSION_ERROR;
+    message: string;
+    recoverable: boolean;
+    reason?: string;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * Similiar to InsufficientEditingPermission, but the user token is invalid because it has expired or been revoked.
+ * It may also be an invalid token format.
+ * This error is given to the provider by NCS.
+ * @message Message returned to editor, i.e. The user token was invalid
+ * @recoverable It is recoverable, as we will try to refresh the token.
+ */
+declare type InvalidUserToken = {
+    code: PROVIDER_ERROR_CODE.INVALID_USER_TOKEN;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * Document not found error, thrown when the provider is unable to find a document with the given ARI and user token.
+ * It occurs during fetchCatchup, a function that fetches the latest document state during catchup.
+ * We need to recieve a 404 from the document service to throw this error.
+ * @message Message returned to editor, i.e. The requested document is not found
+ * @recoverable It is recoverable, as the provider can try again later.
+ */
+declare type DocumentNotFound = {
+    code: PROVIDER_ERROR_CODE.DOCUMENT_NOT_FOUND;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * This error is thrown when the document is locked by another user.
+ * The error is passed to us by NCS.
+ * @message Message returned to editor, i.e. The document is currently not available, please try again later
+ * @recoverable It is recoverable, as the provider can try again later.
+ */
+declare type Locked = {
+    code: PROVIDER_ERROR_CODE.LOCKED;
+    message: string;
+    recoverable: boolean;
+    status?: number;
+};
+/**
+ * This error is thrown when the provider is unable to save the document.
+ * This can happen when the connection to dynamoDB is lost, or when we do not have sufficient permissions (DYNAMO ERROR).
+ * This error is given to us by NCS.
+ * @message Message returned to editor, i.e. Collab service is not able to save changes
+ * @recoverable It is not recoverable, as we don't want the user to continue editing a document that is not being saved.
+ */
+declare type FailToSave = {
+    code: PROVIDER_ERROR_CODE.FAIL_TO_SAVE;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * This error is thrown when the provider is unable to restore the document.
+ * It occurs during onRestore, a function that restores the document to a previous version and reapplies unconfirmed steps.
+ * onRestore is called when page recovery has emitted an 'init' event on a page client is currently connected to.
+ * It could mean we failed to update the page metadata, or we failed to reapply unconfirmed steps.
+ * @message Message returned to editor, i.e. Collab service unable to restore document
+ * @recoverable It is not recoverable, as the provider has no further options after this.
+ * The user will need to refresh the page to try again.
+ */
+declare type DocumentNotRestore = {
+    code: PROVIDER_ERROR_CODE.DOCUMENT_RESTORE_ERROR;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * The initial document couldn't be loaded from the collab service.
+ * This error is given to us by NCS.
+ * It could indicate either a network issue, or an internal service error in NCS.
+ * @message Message returned to editor, i.e. The initial document couldn't be loaded from the collab service
+ * @recoverable It is not recoverable, as the provider cannot do anything to fix it.
+ * The user will need to refresh the page to try again.
+ */
+declare type InitialisationError = {
+    code: PROVIDER_ERROR_CODE.INITIALISATION_ERROR;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * Couldn't reconnect to the collab service (NCS) due to network issues.
+ * NCS could be down, or the user could be offline. It's also possible the url is incorrect, or the user is behind a proxy blocking the connection.
+ * Fired upon a reconnection attempt error (from Socket.IO Manager)
+ * @message Message returned to editor, i.e. Couldn't reconnect to the collab service due to network issues
+ * @recoverable It is recoverable, as the provider will try to reconnect.
+ */
+declare type NetworkIssue = {
+    code: PROVIDER_ERROR_CODE.NETWORK_ISSUE;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * This error is thrown when the provider has an invalid configuration.
+ * It could happen due to these errors from NCS:
+ *  NAMESPACE_INVALID
+    INVALID_ACTIVATION_ID
+    INVALID_DOCUMENT_ARI
+    INVALID_CLOUD_ID
+ * @message Message returned to editor, i.e. Invalid provider configuration
+ * @recoverable It is not recoverable, as the provider cannot do anything to fix it.
+ * The service using the provider will need to fix the configuration.
+ */
+declare type InvalidProviderConfiguration = {
+    code: PROVIDER_ERROR_CODE.INVALID_PROVIDER_CONFIGURATION;
+    message: string;
+    recoverable: boolean;
+    reason: string;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * This error is thrown when the provider encounters an internal service error, not otherwise accounted for.
+ * @message Message returned to editor, i.e. Collab Provider experienced an unrecoverable error
+ * @recoverable It is not recoverable, as the provider cannot do anything to fix it.
+ */
+declare type InternalServiceError = {
+    code: PROVIDER_ERROR_CODE.INTERNAL_SERVICE_ERROR;
+    message: string;
+    recoverable: boolean;
+    reason: string;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * A union of all possible provider errors that can be emitted back to the editor.
+ */
+export declare type ProviderError = InsufficientEditingPermission | InvalidUserToken | DocumentNotFound | Locked | FailToSave | DocumentNotRestore | InitialisationError | NetworkIssue | InvalidProviderConfiguration | InternalServiceError;
+declare class CustomError extends Error {
+    constructor(message: string, error?: unknown);
+    toJSON(): {
+        name: string;
+        message: string;
+    };
+}
+export declare class NotConnectedError extends CustomError {
+    name: string;
+}
+export declare class NotInitializedError extends CustomError {
+    name: string;
+}
+export declare class ProviderInitialisationError extends CustomError {
+    name: string;
+}
+export declare class SendTransactionError extends CustomError {
+    name: string;
+}
+export declare class DestroyError extends CustomError {
+    name: string;
+}
+export declare class SetTitleError extends CustomError {
+    name: string;
+}
+export declare class SetEditorWidthError extends CustomError {
+    name: string;
+}
+export declare class SetMetadataError extends CustomError {
+    name: string;
+}
+export declare class GetCurrentStateError extends CustomError {
+    name: string;
+}
+export declare class GetFinalAcknowledgedStateError extends CustomError {
+    name: string;
+}
+export {};

package/dist/types-ts4.0/feature-flags/__test__/index.unit.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types-ts4.0/feature-flags/index.d.ts

@@ -0,0 +1,9 @@
+import { NCSFeatureFlags, RequiredNCSFeatureFlags, SupportedProduct } from './types';
+/**
+ * Takes a record of {NCS Feature Flag Names → boolean} and a supported product name.
+ * Returns the corresponding product’s Launch Darkly Keys for each of the flags set as true in the input record.
+ * */
+export declare const getProductSpecificFeatureFlags: (flags: RequiredNCSFeatureFlags, product: SupportedProduct) => Array<string>;
+export declare function getCollabProviderFeatureFlag<T = boolean>(flagName: keyof NCSFeatureFlags, featureFlags?: {
+    [key: string]: boolean;
+}): T;

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

@@ -0,0 +1,13 @@
+export interface NCSFeatureFlags {
+    testFF?: boolean;
+}
+export interface WithNCSFeatureFlags {
+    featureFlags?: NCSFeatureFlags;
+}
+export declare type RequiredNCSFeatureFlags = Record<keyof Required<NCSFeatureFlags>, boolean>;
+export declare type NCSFeatureFlagsMap = Record<keyof Required<NCSFeatureFlags>, string>;
+export declare const supportedProducts: readonly [
+    "confluence"
+];
+export declare type SupportedProduct = (typeof supportedProducts)[number];
+export declare type ProductKeys = Record<SupportedProduct, NCSFeatureFlagsMap>;

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

@@ -0,0 +1,183 @@
+import type { ProviderError } from '../errors/error-types';
+export declare enum EVENT_ACTION {
+    CONNECTION = "connection",
+    CATCHUP = "catchup",
+    DOCUMENT_INIT = "documentInit",
+    ADD_STEPS = "addSteps",
+    UPDATE_PARTICIPANTS = "updateParticipants",
+    COMMIT_UNCONFIRMED_STEPS = "commitUnconfirmedSteps",
+    REINITIALISE_DOCUMENT = "reinitialiseDocument",
+    ERROR = "error",
+    PUBLISH_PAGE = "publishPage",
+    GET_CURRENT_STATE = "getCurrentState",
+    INVALIDATE_TOKEN = "invalidateToken"
+}
+export declare enum EVENT_STATUS {
+    SUCCESS = "SUCCESS",
+    FAILURE = "FAILURE"
+}
+export declare enum ADD_STEPS_TYPE {
+    ACCEPTED = "ACCEPTED",
+    REJECTED = "REJECTED",
+    ERROR = "ERROR"
+}
+export declare type ErrorAnalyticsEvent = {
+    eventAction: EVENT_ACTION.ERROR;
+    attributes: {
+        errorMessage: string;
+        errorName?: string;
+        documentAri?: string;
+        mappedError?: ProviderError;
+    };
+    nonPrivacySafeAttributes: {
+        error: unknown;
+    };
+};
+declare type InvalidateTokenAnalyticsEvent = {
+    eventAction: EVENT_ACTION.INVALIDATE_TOKEN;
+    attributes: {
+        eventStatus: EVENT_STATUS.SUCCESS;
+        reason?: string;
+        usedCachedToken?: boolean;
+    };
+};
+declare type AddStepsSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.ADD_STEPS;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        type: ADD_STEPS_TYPE.ACCEPTED;
+        latency?: number;
+        stepType?: {
+            [key: string]: number;
+        };
+    };
+};
+declare type AddStepsFailureAnalyticsEvent = {
+    eventAction: EVENT_ACTION.ADD_STEPS;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.FAILURE;
+        type: ADD_STEPS_TYPE.REJECTED | ADD_STEPS_TYPE.ERROR;
+        latency?: number;
+    };
+};
+declare type ReInitDocFailAnalyticsEvent = {
+    eventAction: EVENT_ACTION.REINITIALISE_DOCUMENT;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.FAILURE;
+        numUnconfirmedSteps: number;
+    };
+};
+declare type ReInitDocSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.REINITIALISE_DOCUMENT;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        numUnconfirmedSteps: number;
+    };
+};
+declare type ConnectionSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.CONNECTION;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        latency?: number;
+    };
+};
+declare type ConnectionFailureAnalyticsEvent = {
+    eventAction: EVENT_ACTION.CONNECTION;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.FAILURE;
+        latency?: number;
+    };
+};
+declare type CatchUpSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.CATCHUP;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        latency?: number;
+    };
+};
+declare type CatchUpFailureAnalyticsEvent = {
+    eventAction: EVENT_ACTION.CATCHUP;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.FAILURE;
+        latency?: number;
+    };
+};
+declare type DocumentInitSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.DOCUMENT_INIT;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        latency?: number;
+        resetReason?: string;
+    };
+};
+declare type UpdateParticipantsSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.UPDATE_PARTICIPANTS;
+    attributes: {
+        documentAri?: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        participants: number;
+    };
+};
+declare type CommitUnconfirmedStepsSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.COMMIT_UNCONFIRMED_STEPS;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        latency?: number;
+        numUnconfirmedSteps?: number;
+    };
+};
+declare type CommitUnconfirmedStepsFailureAnalyticsEvent = {
+    eventAction: EVENT_ACTION.COMMIT_UNCONFIRMED_STEPS;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.FAILURE;
+        latency?: number;
+        numUnconfirmedSteps?: number;
+    };
+};
+declare type PublishPageSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.PUBLISH_PAGE;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        latency?: number;
+    };
+};
+declare type PublishPageFailureAnalyticsEvent = {
+    eventAction: EVENT_ACTION.PUBLISH_PAGE;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.FAILURE;
+        latency?: number;
+    };
+};
+declare type GetCurrentStateSuccessAnalyticsEvent = {
+    eventAction: EVENT_ACTION.GET_CURRENT_STATE;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.SUCCESS;
+        latency?: number;
+    };
+};
+declare type GetCurrentStateFailureAnalyticsEvent = {
+    eventAction: EVENT_ACTION.GET_CURRENT_STATE;
+    attributes: {
+        documentAri: string;
+        eventStatus: EVENT_STATUS.FAILURE;
+        latency?: number;
+    };
+};
+export declare type ActionAnalyticsEvent = AddStepsSuccessAnalyticsEvent | AddStepsFailureAnalyticsEvent | ReInitDocFailAnalyticsEvent | ReInitDocSuccessAnalyticsEvent | ConnectionSuccessAnalyticsEvent | ConnectionFailureAnalyticsEvent | CatchUpSuccessAnalyticsEvent | CatchUpFailureAnalyticsEvent | DocumentInitSuccessAnalyticsEvent | UpdateParticipantsSuccessAnalyticsEvent | CommitUnconfirmedStepsSuccessAnalyticsEvent | CommitUnconfirmedStepsFailureAnalyticsEvent | PublishPageSuccessAnalyticsEvent | PublishPageFailureAnalyticsEvent | GetCurrentStateSuccessAnalyticsEvent | GetCurrentStateFailureAnalyticsEvent | InvalidateTokenAnalyticsEvent;
+export declare const ACK_MAX_TRY = 30;
+export declare const CONFLUENCE = "confluence";
+export {};

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

@@ -0,0 +1,5 @@
+import type { ProductInformation } from '../types';
+export declare const createLogger: (prefix: string, color?: string) => (msg: string, data?: any) => void;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare const getProduct: (productInfo?: ProductInformation | undefined) => string;
+export declare const getSubProduct: (productInfo?: ProductInformation | undefined) => string;

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

@@ -0,0 +1,4 @@
+export { Provider } from './provider';
+export type { CollabConnectedPayload, CollabDisconnectedPayload, CollabErrorPayload, CollabInitPayload, CollabDataPayload, CollabTelepointerPayload, CollabPresencePayload, CollabMetadataPayload, CollabLocalStepsPayload, CollabEvents, CollabSendableSelection, CollabEditProvider, Socket, } from './types';
+export type { ProviderError } from './errors/error-types';
+export { PROVIDER_ERROR_CODE } from './errors/error-types';

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

@@ -0,0 +1,25 @@
+import type { Metadata, CollabEvents } from '../types';
+export declare class MetadataService {
+    private providerEmitCallback;
+    private broadcastMetadata;
+    private metadata;
+    constructor(providerEmitCallback: (evt: keyof CollabEvents, data: any) => void, broadcastMetadata: (metadata: Metadata) => void);
+    getMetaData: () => Metadata;
+    getTitle: () => string;
+    /**
+     * Called when a metadata is changed externally from other clients/backend.
+     */
+    onMetadataChanged: (metadata?: Metadata | undefined) => void;
+    setTitle(title: string, broadcast?: boolean): void;
+    setEditorWidth(editorWidth: string, broadcast?: boolean): void;
+    /**
+     * Updates the local metadata and broadcasts the metadata to other clients/backend.
+     * @param metadata
+     */
+    setMetadata: (metadata: Metadata) => void;
+    /**
+     * Emits a change in document's metadata
+     * @param metadata
+     */
+    updateMetadata: (metadata: Metadata | undefined) => void;
+}