@ckeditor/ckeditor-cloud-services-collaboration 0.0.0-internal-20251222.0

package/LICENSE.md

@@ -0,0 +1,30 @@
+Software License Agreement
+==========================
+
+**CKEditor Cloud Services Collaboration low-level API**<br>
+Copyright (c) 2003–2022, [CKSource Holding sp. z o.o.](http://cksource.com) All rights reserved.
+
+CKEditor Cloud Services Collaboration low-level API is licensed under a commercial license and protected by copyright law.
+For more details about available licensing options please contact us at sales@cksource.com.
+
+Sources of Intellectual Property Included in CKEditor Cloud Services Collaboration low-level API
+-----------------------------------------------------
+
+Where not otherwise indicated, all CKEditor Cloud Services Collaboration low-level API content is authored by CKSource engineers and consists of CKSource-owned intellectual property.
+
+The following libraries are included in CKEditor Cloud Services Collaboration low-level API under the [MIT license](https://opensource.org/licenses/MIT):
+
+* Lodash - Copyright (c) JS Foundation and other contributors https://js.foundation/. Based on Underscore.js, copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors http://underscorejs.org/.
+* socket.io-client - Copyright (c) 2014 Guillermo Rauch <guillermo@learnboost.com>.
+* socket.io-parser - Copyright (c) 2014 Guillermo Rauch <guillermo@learnboost.com>.
+* uuid - Copyright (c) 2010–2020 Robert Kieffer and other contributors.
+* url-parse - Copyright (c) 2015 Unshift.io, Arnout Kazemier, the Contributors.
+
+The following libraries are included in CKEditor Cloud Services Collaboration low-level API under the [BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause):
+
+* protobuf.js - Copyright (c) 2016, Daniel Wirtz  All rights reserved.
+
+Trademarks
+----------
+
+**CKEditor** is a trademark of [CKSource Holding sp. z o.o.](http://cksource.com) All other brand and product names are trademarks, registered trademarks, or service marks of their respective holders.

package/README.md

@@ -0,0 +1,21 @@
+# CKEditor Cloud Services Collaboration low-level API
+CKEditor Cloud Services Collaboration low-level API is required by [CKEditor 5 Collaboration features](https://ckeditor.com/collaboration/) to enable real-time collaborative editing within the CKEditor 5.
+
+For more info go to [CKEditor 5 collaboration documentation](https://ckeditor.com/docs/ckeditor5/latest/features/collaboration/real-time-collaboration/real-time-collaboration.html) website.
+
+## Getting support
+CKEditor 5 collaboration features come with outstanding support from a dedicated team of customer care specialists, QA engineers and CKEditor 5 developers. The team will gladly assist you in all aspects from setting up your account to integrating CKEditor 5 collaboration features with your application.
+
+As a licensed CKEditor 5 collaboration features user you can report bugs and request features directly through the CKEditor Ecosystem customer dashboard.
+
+## License
+
+**CKEditor Cloud Services Collaboration low-level API**<br>
+Copyright (c) 2003-2022, [CKSource Holding sp. z o.o.](http://cksource.com) All rights reserved.
+
+CKEditor Cloud Services Collaboration low-level API is licensed under a commercial license and protected by copyright law.
+For more details about available licensing options please contact us at sales@cksource.com.
+
+### Trademarks
+
+**CKEditor** is a trademark of [CKSource Holding sp. z o.o.](http://cksource.com) All other brand and product names are trademarks, registered trademarks or service marks of their respective holders.

package/dist/ckeditorcloudserviceserror.d.ts

@@ -0,0 +1,11 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+import { IPublicError } from './ckeditorcloudservicesservererror';
+export default class CKEditorCloudServicesError extends Error {
+    readonly context?: unknown;
+    readonly code: string | null;
+    readonly data: Record<string, unknown>;
+    constructor(message: string, context?: unknown, code?: string | null, data?: Record<string, unknown>);
+    static fromPublicError(publicError: IPublicError): CKEditorCloudServicesError;
+}

package/dist/ckeditorcloudservicesservererror.d.ts

@@ -0,0 +1,18 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+export interface IPublicError {
+    message: string;
+    traceId?: string;
+    data?: Record<string, unknown>;
+    code?: string;
+    explanation?: string;
+    action?: string;
+}
+export default class CKEditorCloudServicesServerError extends Error {
+    readonly code?: string;
+    readonly traceId?: string;
+    readonly data?: Record<string, unknown>;
+    private constructor();
+    static fromPublicError(publicError: IPublicError): CKEditorCloudServicesServerError;
+}

package/dist/collaborativeeditingservice/collaborativeeditingservice.d.ts

@@ -0,0 +1,131 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+import CollaborativeEditingConnectMessage from './messages/collaborativeeditingconnectmessage';
+import CollaborativeEditingReconnectMessage from './messages/collaborativeeditingreconnectmessage';
+import CollaborativeEditingResponse from './responses/collaborativeeditingresponse';
+import CollaborativeEditingConnectResponse from './responses/collaborativeeditingconnectresponse';
+import { IWebSocketGateway } from './../websocketgateway/websocketgateway';
+import SessionCollection from '../sessions/sessioncollection';
+import GetDocumentDetailsResponse from './responses/getdocumentdetailsresponse';
+export declare const _SERVICE: number;
+export interface IOperationsData {
+    buffers: (Buffer | Uint8Array)[];
+    types: number[];
+}
+declare const CollaborativeEditingService_base: {
+    new (): import("@ckeditor/ckeditor5-utils").Emitter;
+    prototype: import("@ckeditor/ckeditor5-utils").Emitter;
+};
+/**
+ * General purpose CollaborativeEditingService used to synchronize data store values with other collaborative nodes.
+ */
+declare class CollaborativeEditingService extends /* #__PURE__ -- @preserve */ CollaborativeEditingService_base {
+    static _SERVICE: number;
+    private readonly _bundleVersion;
+    private readonly _id;
+    private _isConnected;
+    private _wsGateway?;
+    private _channel?;
+    private _connectedSessions?;
+    /**
+     * Create CollaborativeEditingService instance.
+     *
+     *     const collabWritingService = new CollaborativeEditingService( '0.9.0', 'post-456-text' );
+     *
+     * @throws {TypeError}
+     * Throws when bundleVersion param is not provided.
+     */
+    constructor(bundleVersion: string, serviceId?: string);
+    getId(): string;
+    /**
+     * Indicates that CollaborativeEditingService is connected to CKEditor Cloud Services.
+     */
+    isConnected(): boolean;
+    /**
+     * Connects CollaborativeEditingService to CKEditor Cloud Services.
+     *
+     *     const myDocument = new CollaborativeEditingService( '0.9.0', 'article-1234' );
+     *
+     *     await myDocument.connect( wsGateway );
+     *
+     * @throws {CKEditorCloudServicesError}
+     * Thrown in the case of errors on the backend side.
+     */
+    connect(wsGateway: IWebSocketGateway, data?: {
+        buffers: Buffer[];
+        types: number[];
+    }, lastOperationId?: string): Promise<CollaborativeEditingConnectResponse | void>;
+    /**
+     * Reconnects CollaborativeEditingService to CKEditor Cloud Services.
+     *
+     *     const myDocument = new CollaborativeEditingService( '0.9.0', 'article-1234' );
+     *
+     *     await myDocument.connect( wsGateway );
+     *
+     *     wsGateway.on( 'change:state', ( event, property, value ) => {
+     *     		 if( value === 'disconnected' ) {
+     *     		 	await myDocument.reconnect( wsGateway, 123 );
+     *     		 }
+     *     } );
+     *
+     * @throws {CKEditorCloudServicesError}
+     * Thrown when connection already exists or in the case of errors on the backend side.
+     */
+    reconnect(wsGateway: IWebSocketGateway, lastKnowVersion: number): Promise<CollaborativeEditingConnectResponse>;
+    /**
+     * Disconnects CollaborativeEditingService from CKEditor Cloud Services.
+     *
+     * @throws {CKEditorCloudServicesError}
+     * Thrown in the case of errors on the backend side.
+     */
+    disconnect(): void;
+    /**
+     * Gets document details from CKEditor Cloud Services.
+     *
+     * @throws {CKEditorCloudServicesError}
+     * Thrown in the case of errors on the backend side.
+     */
+    getDocumentDetails(): Promise<GetDocumentDetailsResponse>;
+    /**
+     * Sends update to connected service. This will propagate update to other connected CollaborativeEditingService.
+     * Data update will not be stored on CollaborativeEditingService server instance.
+     *
+     * @throws {CKEditorCloudServicesError}
+     * Throws when baseVersion or data is not provided, data is empty, or in the case of errors on the backend side.
+     *
+     * @throws {ServiceNotConnectedError}
+     * Throws when collaborative editing service is not connected.
+     */
+    sendOperations(data: IOperationsData, baseVersion: number | string, lastOperationId: string): Promise<CollaborativeEditingResponse>;
+    /**
+     * Returns read-only observable collection with EndUsers Sessions for collaborative editing service.
+     *
+     * @throws {CKEditorCloudServicesError}
+     * Thrown in the case of errors on the backend side.
+     */
+    getConnectedSessions(): Promise<SessionCollection>;
+    /**
+     * Returns a Promise that resolves with read-only observable collection with EndUsers Sessions for given id.
+     *
+     *    const sessions = await CollaborativeEditingService.getConnectedSessions( 'my-document-id' );
+     *
+     * @deprecated Use not static version of getConnectedSessions method.
+     *
+     * @throws {CKEditorCloudServicesError}
+     * Throws in the case of errors on the backend side.
+     */
+    static getConnectedSessions(wsGateway: IWebSocketGateway, id: string): Promise<SessionCollection>;
+    _connect(wsGateway: IWebSocketGateway, message: CollaborativeEditingConnectMessage | CollaborativeEditingReconnectMessage): Promise<CollaborativeEditingConnectResponse | void>;
+    /**
+     * Connects given CollaborativeEditingService to channel.
+     */
+    protected _connectToChannel(wsGateway: IWebSocketGateway, channelName: string): void;
+    /**
+     * WebSocketGateway "change:state" events handler.
+     */
+    private _onWsGatewayStateChange;
+}
+export default CollaborativeEditingService;

package/dist/collaborativeeditingservice/descriptors/operationmetadatadescriptor.d.ts

@@ -0,0 +1,21 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+import Descriptor, { IDescriptorBody } from './../../descriptor';
+interface IBaseOperationMetadata {
+    userId: string;
+    type?: string;
+}
+export interface IOperationMetadata extends IBaseOperationMetadata {
+    createdAt?: Date;
+}
+export interface IOperationMetadataJSON extends IBaseOperationMetadata {
+    createdAt?: string;
+}
+export default class OperationMetadataDescriptor extends Descriptor {
+    static readonly DESCRIPTOR_NAME: string;
+    static readonly DESCRIPTOR: IDescriptorBody;
+    static toJSON({ createdAt, ...metadata }: IOperationMetadata): IOperationMetadataJSON;
+    static fromJSON({ createdAt, ...metadata }: IOperationMetadataJSON): IOperationMetadata;
+}
+export {};

package/dist/collaborativeeditingservice/helpers/operationmetadatahelpers.d.ts

@@ -0,0 +1,14 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+import { IOperationMetadata, IOperationMetadataJSON } from '../descriptors/operationmetadatadescriptor';
+export default class OperationMetadataHelpers {
+    /**
+     * Prepares metadata data for all operations. Adds metadata to operations with type 0.
+     */
+    static prepareMetadataForOperations(types: number[], metadata: IOperationMetadataJSON[]): IOperationMetadataJSON[];
+    /**
+     * Removes unnecessary metadata for operations with type 0.
+     */
+    static removeUnnecessaryMetadata(types: number[], metadata: IOperationMetadata[]): IOperationMetadata[];
+}

package/dist/collaborativeeditingservice/messages/collaborativeeditingconnectmessage.d.ts

@@ -0,0 +1,28 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+import Message, { IMessage } from './../../message';
+import { IDescriptorBody } from '../../descriptor';
+export interface ICollaborativeEditingConnectMessage extends IMessage {
+    id: string;
+    bundleVersion: string;
+    buffers: Buffer[];
+    types: number[];
+    lastOperationId?: string;
+}
+export default class CollaborativeEditingConnectMessage extends Message {
+    readonly id: string;
+    readonly buffers: Buffer[];
+    readonly types: number[];
+    readonly bundleVersion: string;
+    readonly lastOperationId: string;
+    static readonly TYPE: string;
+    static readonly READABLE_TYPE_NAME: string;
+    static readonly DESCRIPTOR_NAME: string;
+    static readonly DESCRIPTOR: IDescriptorBody;
+    constructor(id: string, buffers: Buffer[], types: number[], bundleVersion: string, lastOperationId?: string);
+    toJSON(): ICollaborativeEditingConnectMessage;
+    static fromJSON(data: ICollaborativeEditingConnectMessage): CollaborativeEditingConnectMessage;
+}

package/dist/collaborativeeditingservice/messages/collaborativeeditingreconnectmessage.d.ts

@@ -0,0 +1,22 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+import Message, { IMessage } from './../../message';
+import { IDescriptorBody } from '../../descriptor';
+export interface ICollaborativeEditingReconnectMessage extends IMessage {
+    id: string;
+    lastKnowVersion: number;
+    bundleVersion: string;
+}
+export default class CollaborativeEditingReconnectMessage extends Message {
+    readonly id: string;
+    readonly lastKnowVersion: number;
+    readonly bundleVersion: string;
+    static readonly TYPE: string;
+    static readonly READABLE_TYPE_NAME: string;
+    static readonly DESCRIPTOR_NAME: string;
+    static readonly DESCRIPTOR: IDescriptorBody;
+    constructor(id: string, lastKnowVersion: number, bundleVersion: string);
+    toJSON(): ICollaborativeEditingReconnectMessage;
+    static fromJSON(data: ICollaborativeEditingReconnectMessage): CollaborativeEditingReconnectMessage;
+}

package/dist/collaborativeeditingservice/messages/collaborativeeditingupdatemessage.d.ts

@@ -0,0 +1,42 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+import Message, { IMessage } from './../../message';
+import { IDescriptorBody } from '../../descriptor';
+import { IOperationMetadata, IOperationMetadataJSON } from '../descriptors/operationmetadatadescriptor';
+export interface ICollaborativeEditingUpdateMessage extends IMessage {
+    id: string;
+    buffers: Buffer[] | Uint8Array[];
+    types: number[];
+    baseVersion: number;
+    metadata: IOperationMetadataJSON[];
+    lastOperationId?: string;
+}
+interface ICollaborativeEditingUpdateData {
+    buffers: Buffer[] | Uint8Array[];
+    types: number[];
+    baseVersion: number;
+    lastOperationId?: string;
+}
+export default class CollaborativeEditingUpdateMessage extends Message {
+    readonly id: string;
+    readonly buffers: Buffer[] | Uint8Array[];
+    readonly types: number[];
+    readonly baseVersion: number;
+    readonly metadata: IOperationMetadata[];
+    readonly lastOperationId: string;
+    static readonly TYPE: string;
+    static readonly READABLE_TYPE_NAME: string;
+    static readonly DESCRIPTOR_NAME: string;
+    static readonly DESCRIPTOR: IDescriptorBody;
+    constructor(id: string, buffers: Buffer[] | Uint8Array[], types: number[], baseVersion: number, metadata?: IOperationMetadata[], lastOperationId?: string);
+    /**
+     * Returns compressed data of the operations.
+     */
+    get data(): ICollaborativeEditingUpdateData;
+    toJSON(): ICollaborativeEditingUpdateMessage;
+    static fromJSON(data: ICollaborativeEditingUpdateMessage): CollaborativeEditingUpdateMessage;
+}
+export {};

package/dist/collaborativeeditingservice/messages/getdocumentdetailsmessage.d.ts

@@ -0,0 +1,19 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+import Message from '../../message';
+import { IDescriptorBody } from '../../descriptor';
+export interface IGetDocumentDetailsMessage {
+    documentId: string;
+}
+export default class GetDocumentDetailsMessage extends Message {
+    readonly documentId: string;
+    static readonly TYPE: string;
+    static readonly READABLE_TYPE_NAME: string;
+    static readonly DESCRIPTOR_NAME: string;
+    static readonly DESCRIPTOR: IDescriptorBody;
+    constructor(documentId: string);
+    get data(): IGetDocumentDetailsMessage;
+    toJSON(): IGetDocumentDetailsMessage;
+    static fromJSON(data: IGetDocumentDetailsMessage): GetDocumentDetailsMessage;
+}

package/dist/collaborativeeditingservice/responses/collaborativeeditingconnectresponse.d.ts

@@ -0,0 +1,72 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+import Message, { IMessage } from './../../message';
+import { IDescriptorBody } from '../../descriptor';
+import { IOperationMetadata, IOperationMetadataJSON } from '../descriptors/operationmetadatadescriptor';
+export interface ICollaborativeEditingConnectResponse extends IMessage {
+    channel: string;
+    offset: number;
+    version: number;
+    sessionId: string;
+    buffers: Buffer[] | Uint8Array[];
+    types: number[];
+    metadata: IOperationMetadataJSON[];
+    initData: string;
+    isInitialized: boolean;
+    lastOperationId?: string;
+    sessionCreatedAt: string | null;
+}
+interface ICollaborativeEditingConnectResponseParams {
+    channel: string;
+    version: number;
+    sessionId?: string;
+    buffers?: Buffer[] | Uint8Array[];
+    types?: number[];
+    offset?: number;
+    metadata?: IOperationMetadata[];
+    initData?: string | null;
+    lastOperationId?: string;
+    sessionCreatedAt: Date | null;
+}
+interface ICollaborativeEditingConnectResponseData {
+    buffers: Buffer[] | Uint8Array[];
+    types: number[];
+    baseVersion: number;
+    lastOperationId?: string;
+    sessionCreatedAt: Date | null;
+}
+export default class CollaborativeEditingConnectResponse extends Message {
+    readonly channel: string;
+    readonly version: number;
+    readonly buffers: Buffer[] | Uint8Array[];
+    readonly types: number[];
+    readonly offset: number;
+    readonly metadata: IOperationMetadata[];
+    readonly initData: string | null;
+    readonly sessionId: string;
+    readonly lastOperationId: string;
+    readonly sessionCreatedAt: Date | null;
+    static readonly DESCRIPTOR_NAME: string;
+    static readonly DESCRIPTOR: IDescriptorBody;
+    /**
+     * @deprecated - Use CollaborativeEditingConnectResponse.create factory method instead.
+     *
+     * @param channel - Name of channel on which messages will be published.
+     * @param version - Version of the document.
+     * @param buffers - List of operations compressed to the binary format.
+     * @param types - List of compressor identifiers.
+     * @param offset - Number of changes in previous editing sessions.
+     * @param metadata - Metadata of changes.
+     * @param initData - Initialization data of the document.
+     */
+    constructor(channel: string, version: number, buffers?: Buffer[] | Uint8Array[], types?: number[], offset?: number, metadata?: IOperationMetadata[], initData?: string | null, sessionId?: string, lastOperationId?: string, sessionCreatedAt?: Date | null);
+    get data(): ICollaborativeEditingConnectResponseData;
+    get wereChangesApplied(): boolean;
+    toJSON(): ICollaborativeEditingConnectResponse;
+    static create(params: ICollaborativeEditingConnectResponseParams): CollaborativeEditingConnectResponse;
+    static fromJSON(data: ICollaborativeEditingConnectResponse): CollaborativeEditingConnectResponse;
+}
+export {};

package/dist/collaborativeeditingservice/responses/collaborativeeditingresponse.d.ts

@@ -0,0 +1,55 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+import Message, { IMessage } from './../../message';
+import { IDescriptorBody } from '../../descriptor';
+import { IOperationMetadata, IOperationMetadataJSON } from '../descriptors/operationmetadatadescriptor';
+export interface ICollaborativeEditingResponse extends IMessage {
+    version: number;
+    buffers: Buffer[];
+    types: number[];
+    metadata: IOperationMetadataJSON[];
+    lastOperationId: string;
+    lastOperationAcceptedAt: string | null;
+}
+interface ICollaborativeEditingResponseParams {
+    version: number;
+    buffers?: Buffer[];
+    types?: number[];
+    metadata?: IOperationMetadata[];
+    lastOperationId?: string;
+    lastOperationAcceptedAt?: string | null;
+}
+interface ICollaborativeEditingResponseData {
+    buffers: Buffer[];
+    types: number[];
+    baseVersion: number;
+    lastOperationId: string;
+    lastOperationAcceptedAt: Date | null;
+}
+export default class CollaborativeEditingResponse extends Message {
+    readonly version: number;
+    readonly buffers: Buffer[];
+    readonly types: number[];
+    readonly metadata: IOperationMetadata[];
+    readonly lastOperationId: string;
+    readonly lastOperationAcceptedAt: Date | null;
+    static readonly DESCRIPTOR_NAME: string;
+    static readonly DESCRIPTOR: IDescriptorBody;
+    /**
+     * @deprecated - Use CollaborativeEditingResponse.create factory method instead.
+     * @param version - Version of the document.
+     * @param buffers - List of operations compressed to the binary format.
+     * @param types - List of compressor identifiers.
+     * @param metadata - Metadata of changes.
+     */
+    constructor(version: number, buffers?: Buffer[], types?: number[], metadata?: IOperationMetadata[], lastOperationId?: string, lastOperationAcceptedAt?: Date | null);
+    get data(): ICollaborativeEditingResponseData;
+    get wereChangesApplied(): boolean;
+    toJSON(): ICollaborativeEditingResponse;
+    static fromJSON(data: ICollaborativeEditingResponse): CollaborativeEditingResponse;
+    static create(data: ICollaborativeEditingResponseParams): CollaborativeEditingResponse;
+}
+export {};

package/dist/collaborativeeditingservice/responses/getdocumentdetailsresponse.d.ts

@@ -0,0 +1,31 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+import { IDescriptorBody } from '../../descriptor';
+import Message, { IMessage } from './../../message';
+export interface IGetDocumentDetailsResponse extends IMessage {
+    lastDocumentSessionId?: string;
+    lastDocumentSessionOperationId?: string;
+    currentDocumentSessionId?: string;
+    currentDocumentSessionVersion?: number;
+    currentDocumentSessionOperationId?: string;
+}
+export interface ICurrentDocumentSession {
+    lastOperationId?: string;
+    version?: number;
+    id?: string;
+}
+export interface ILastDocumentSession {
+    id?: string;
+    lastOperationId?: string;
+}
+export default class GetDocumentDetailsResponse extends Message {
+    readonly lastDocumentSession?: ILastDocumentSession | undefined;
+    readonly currentDocumentSession?: ICurrentDocumentSession | undefined;
+    static readonly DESCRIPTOR_NAME: string;
+    static readonly DESCRIPTOR: IDescriptorBody;
+    constructor(lastDocumentSession?: ILastDocumentSession | undefined, currentDocumentSession?: ICurrentDocumentSession | undefined);
+    get data(): IGetDocumentDetailsResponse;
+    toJSON(): IGetDocumentDetailsResponse;
+    static fromJSON(data: IGetDocumentDetailsResponse): GetDocumentDetailsResponse;
+}

package/dist/comments-v2/commentsservice.d.ts

@@ -0,0 +1,75 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+import AddCommentResponse from './responses/addcommentresponse';
+import { IWebSocketGateway } from './../websocketgateway/websocketgateway';
+import { IThread } from './descriptors/commentsthreaddescriptor';
+import SessionCollection from '../sessions/sessioncollection';
+import { IComment } from './descriptors/commentdescriptor';
+import AddCommentThreadResponse from './responses/comment-threads/addcommentthreadresponse';
+import ResolveCommentThreadResponse from './responses/comment-threads/resolvecommentthreadresponse';
+export declare const _SERVICE: number;
+export interface IAddCommentThreadParams {
+    commentThreadId: string;
+    context?: Record<string, unknown> | null;
+    comments?: IComment[];
+    resolvedAt?: Date | string | null;
+    createdAt?: Date | string | null;
+    resolvedBy?: string | null;
+    deletedAt?: Date | null | string;
+    attributes?: Record<string, unknown> | null;
+}
+export interface IUpdateCommentThreadParams {
+    commentThreadId: string;
+    context?: Record<string, unknown> | null;
+    attributes?: Record<string, unknown> | null;
+    unlinkedAt?: Date | null | string;
+}
+declare const CommentsService_base: {
+    new (): import("@ckeditor/ckeditor5-utils").Emitter;
+    prototype: import("@ckeditor/ckeditor5-utils").Emitter;
+};
+declare class CommentsService extends /* #__PURE__ -- @preserve */ CommentsService_base {
+    private readonly _documentId;
+    private _isConnected;
+    private _wsGateway?;
+    private _channel?;
+    private _connectedSessions?;
+    private static readonly _SERVICE;
+    constructor(_documentId: string);
+    get isConnected(): boolean;
+    /**
+     * Connects to WebSocketGateway and starts listening on channel.
+     */
+    connect(wsGateway: IWebSocketGateway): Promise<IThread[] | void>;
+    /**
+     * Disconnects CommentsService from CKEditor Cloud Services.
+     */
+    disconnect(): void;
+    addComment(commentThreadId: string, commentId: string, content: string, attributes?: Record<string, unknown>): Promise<AddCommentResponse>;
+    updateComment(commentThreadId: string, commentId: string, content: string, attributes?: Record<string, unknown>): Promise<void>;
+    removeComment(commentThreadId: string, commentId: string): Promise<void>;
+    removeCommentThread(commentThreadId: string): Promise<void>;
+    addCommentThread(addCommentThreadParams: IAddCommentThreadParams): Promise<AddCommentThreadResponse>;
+    resolveCommentThread(commentThreadId: string): Promise<ResolveCommentThreadResponse>;
+    reopenCommentThread(commentThreadId: string): Promise<void>;
+    updateCommentThread(params: IUpdateCommentThreadParams): Promise<void>;
+    getCommentThread(commentThreadId: string, attempt?: number): Promise<IThread>;
+    getDocumentThreads(): Promise<{
+        threads: IThread[];
+    }>;
+    /**
+     * Returns read-only observable collection with EndUsers Sessions for comments service.
+     */
+    getConnectedSessions(): Promise<SessionCollection>;
+    /**
+     * Starts to listen on a given channel.
+     */
+    private _connectToChannel;
+    /**
+     * Processes websocket gateway state changes.
+     */
+    private _onWsGatewayStateChange;
+    private _sendRequest;
+}
+export default CommentsService;

package/dist/comments-v2/descriptors/commentdescriptor.d.ts

@@ -0,0 +1,26 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+import Descriptor, { IDescriptorBody } from './../../descriptor';
+interface ICommonComment {
+    commentId: string;
+    commentThreadId: string;
+    userId: string;
+    content: string;
+    documentId: string;
+}
+export interface ICommentJSON extends ICommonComment {
+    createdAt: string;
+    attributes: string | null;
+}
+export interface IComment extends ICommonComment {
+    createdAt: Date;
+    attributes: Record<string, unknown> | null;
+}
+export default class CommentDescriptor extends Descriptor {
+    static readonly DESCRIPTOR_NAME: string;
+    static readonly DESCRIPTOR: IDescriptorBody;
+    static toJSON(comment: IComment): ICommentJSON;
+    static fromJSON(comment: ICommentJSON): IComment;
+}
+export {};

package/dist/comments-v2/descriptors/commentsthreaddescriptor.d.ts

@@ -0,0 +1,34 @@
+/*
+ Copyright (c), CKSource Holding sp. z o.o. All rights reserved.
+ */
+import Descriptor, { IDescriptorBody } from './../../descriptor';
+import { IComment, ICommentJSON } from './commentdescriptor';
+interface ICommonThread {
+    commentThreadId: string;
+    resolvedBy?: string | null;
+}
+export interface IThreadJSON extends ICommonThread {
+    comments?: ICommentJSON[];
+    attributes?: string | null;
+    createdAt?: string;
+    deletedAt?: string | null;
+    resolvedAt?: string | null;
+    context?: string | null;
+    unlinkedAt?: string | null;
+}
+export interface IThread extends ICommonThread {
+    comments?: IComment[];
+    createdAt?: Date;
+    deletedAt?: Date | null;
+    resolvedAt?: Date | null;
+    attributes?: Record<string, unknown> | null;
+    context?: Record<string, unknown> | null;
+    unlinkedAt?: Date | null;
+}
+export default class CommentsThreadDescriptor extends Descriptor {
+    static readonly DESCRIPTOR_NAME: string;
+    static readonly DESCRIPTOR: IDescriptorBody;
+    static toJSON(thread: IThread): IThreadJSON;
+    static fromJSON(thread: IThreadJSON): IThread;
+}
+export {};