interface RequestBoundsAction extends RequestAction {
    /**
     * The kind of the action.
     */
    kind = 'requestBounds';

    /**
     * The model elements to consider to compute the new bounds.
     */
    newRoot: GModelRootSchema;
}

interface ComputedBoundsAction extends ResponseAction {
    /**
     * The kind of the action.
     */
    kind = 'computedBounds';

    /**
     * The new bounds of the model elements.
     */
    bounds: ElementAndBounds[];

    /*
     * The revision number.
     */
    revision?: number;

    /**
     * The new alignment of the model elements.
     */
    alignments?: ElementAndAlignment[];

    /**
     * The route of the model elements.
     */
    routes?: ElementAndRoutingPoints[];
}

interface LayoutOperation extends Operation {
    /**
     * The kind of the action.
     */
    kind = 'layout';

    /**
     * The identifiers of the elements that should be layouted, will default to the root element if not defined.
     */
    elementIds?: string[];
}

interface SetEditModeAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'setEditMode';

    /**
     * The new edit mode of the diagram.
     */
    editMode: string;
}

interface CenterAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'center';

    /**
     * The identifier of the elements on which the viewport should be centered.
     */
    elementIds: string[];

    /**
     * Indicate if the modification of the viewport should be realized with or without support of animations.
     */
    animate: boolean = true;

    /**
     * Indicates whether the zoom level should be kept.
     */
    retainZoom: boolean = false;
}

interface FitToScreenAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'fit';

    /**
     * The identifier of the elements to fit on screen.
     */
    elementIds: string[];

    /**
     * The padding that should be visible on the viewport.
     */
    padding?: number;

    /**
     * The max zoom level authorized.
     */
    maxZoom?: number;

    /**
     * Indicate if the action should be performed with animation support or not.
     */
    animate: boolean = true;
}

interface StatusAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'status';

    /**
     * The severity of the status.
     */
    severity: SeverityLeel;

    /**
     * The message describing the status.
     */
    message: string;

    /**
     * Timeout after which a displayed status disappears.
     */
    timeout?: number;
}

interface MessageAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'message';

    /**
     * The severity of the message.
     */
    severity: SeverityLevel;

    /**
     * The message text.
     */
    message: string;

    /**
     * Further details on the message.
     */
    details: string;
}

/**
 * The possible server status severity levels.
 */
type SeverityLevel = 'NONE' | 'INFO' | 'WARNING' | 'ERROR' | 'FATAL' | 'OK';

export interface StartProgressAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'startProgress';

    /**
     * An ID that can be used in subsequent `updateProgress` and `endProgress` events to make them refer to the same progress reporting.
     */
    progressId: string;

    /**
     * Short title of the progress reporting. Shown in the UI to describe the long running process.
     */
    title: string;

    /**
     * Optional additional progress message. Shown in the UI to describe the long running process.
     */
    message?: string;

    /**
     * Progress percentage to display (value range: 0 to 100). If omitted no percentage is shown.
     */
    percentage?: number;
}

export interface UpdateProgressAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'updateProgress';

    /**
     * The ID of the progress reporting to update.
     */
    progressId: string;

    /**
     * The message to show in the progress reporting.
     */
    message?: string;

    /**
     * The percentage (value range: 0 to 100) to show in the progress reporting.
     */
    percentage?: number;
}

export interface EndProgressAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'endProgress';

    /**
     * The ID of the progress reporting to update.
     */
    progressId: string;

    /**
     * The message to show in the progress reporting.
     */
    message?: string;
}

interface SelectAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'elementSelected';

    /**
     * The identifier of the elements to mark as selected.
     */
    selectedElementsIDs: string[];

    /**
     * The identifier of the elements to mark as not selected.
     */
    deselectedElementsIDs: string[];
    /**
     * Whether all currently selected elements should be deselected.
     */
    deselectAll?: boolean;
}

interface SelectAllAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'allSelected';

    /**
     * If `select` is true, all elements are selected, otherwise they are deselected.
     */
    select: boolean;
}

interface RequestPopupModelAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'requestPopupModel';

    /**
     * The identifier of the elements for which a popup is requested.
     */
    elementId: string;

    /**
     * The bounds.
     */
    bounds: Bounds;
}

interface SetPopupModelAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'setPopupModel';

    /**
     * The model elements composing the popup to display.
     */
    newRoot: GModelRootSchema;
}

interface Marker {
    /**
     * Short label describing this marker message, e.g., short validation message
     */
    readonly label: string;

    /**
     * Full description of this marker, e.g., full validation message
     */
    readonly description: string;

    /**
     * Id of the model element this marker refers to
     */
    readonly elementId: string;

    /**
     * Marker kind, e.g., info, warning, error or custom kind
     */
    readonly kind: string;
}

interface RequestMarkersAction extends RequestAction {
    /**
     * The kind of the action.
     */
    kind = 'requestMarkers';

    /**
     * The elements for which markers are requested, may be just the root element.
     */
    elementsIDs: string[];

    /**
     * The reason for this request, e.g. a `batch` validation or a `live` validation.
     */
    reason?: string;
}

interface SetMarkersAction extends ResponseAction {
    /**
     * The kind of the action.
     */
    kind = 'setMarkers';

    /**
     * The list of markers to be set in the diagram editor.
     */
    markers: Marker[];

    /**
     * The reason for this response, e.g. a `batch` validation or a `live` validation.
     */
    reason?: string;
}

interface DeleteMarkersAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'deleteMarkers';

    /**
     * The list of markers that should be deleted.
     */
    markers: Marker[];
}

interface NavigationTarget {
    /**
     * URI to identify the object we want to navigate to.
     */
    uri: string;

    /**
     * Optional label to display to the user.
     */
    label?: string;

    /**
     * Domain-specific arguments that may be interpreted directly or resolved further.
     */
    args?: Args;
}

interface RequestNavigationTargetsAction extends RequestAction<SetNavigationTargetsAction> {
    /**
     * The kind of the action.
     */
    kind = 'requestNavigationTargets';

    /**
     * Identifier of the type of navigation targets we want to retrieve, e.g., 'documentation', 'implementation', etc.
     */
    targetTypeId: string;

    /**
     * The current editor context.
     */
    editorContext: EditorContext;
}

interface SetNavigationTargetsAction extends ResponseAction {
    /**
     * The kind of the action.
     */
    kind = 'setNavigationTargets';

    /**
     * A list of navigation targets.
     */
    targets: NavigationTarget[];

    /**
     * Custom arguments that may be interpreted by the client.
     */
    args?: Args;
}

interface NavigateToTargetAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'navigateToTarget';

    /**
     * The target to which we navigate.
     */
    target: NavigationTarget;
}

interface ResolveNavigationTargetAction extends RequestAction<SetResolvedNavigationTargetAction> {
    /**
     * The kind of the action.
     */
    kind = 'resolveNavigationTarget';

    /**
     * The navigation target to resolve.
     */
    navigationTarget: NavigationTarget;
}

interface SetResolvedNavigationTargetAction extends ResponseAction {
    /**
     * The kind of the action.
     */
    kind = 'setResolvedNavigationTarget';

    /**
     * The element ids of the resolved navigation target.
     */
    elementIds: string[];

    /**
     * Custom arguments that may be interpreted by the client.
     */
    args?: Args;
}

interface NavigateToExternalTargetAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'navigateToExternalTarget';

    /**
     * The target to which we navigate.
     */
    target: NavigationTarget;
}

interface TypeHint {
    /**
     * The identifier of an element.
     */
    readonly elementTypeId: string;

    /**
     * Specifies whether the element can be relocated.
     */
    readonly repositionable: boolean;

    /**
     * Specifies whether the element can be deleted
     */
    readonly deletable: boolean;
}

interface ShapeTypeHint extends TypeHint {
    /**
     * Specifies whether the element can be resized.
     */
    readonly resizable: boolean;

    /**
     * Specifies whether the element can be moved to another parent
     */
    readonly reparentable: boolean;

    /**
     * The types of elements that can be contained by this element (if any)
     */
    readonly containableElementTypeIds?: string[];
}

interface EdgeTypeHint extends TypeHint {
    /**
     * Specifies whether the routing points of the edge can be changed
     * i.e. edited by the user.
     */
    readonly routable: boolean;

    /**
     * Allowed source element types for this edge type
     * If not defined unknown element can be used as source element for this edge.
     */
    readonly sourceElementTypeIds?: string[];

    /**
     * Allowed targe element types for this edge type
     * If not defined unknown element can be used as target element for this edge.
     */
    readonly targetElementTypeIds?: string[];

    /**
     * Indicates whether this type hint is dynamic or not. Dynamic edge type hints
     * require an additional runtime check before creating an edge, when checking
     * source and target element types is not sufficient.
     */
    readonly dynamic?: boolean;
}

interface RequestTypeHintsAction extends RequestAction<SetTypeHintsAction> {
    /**
     * The kind of the action.
     */
    kind = 'requestTypeHints';
}

interface SetTypeHintsAction extends ResponseAction {
    /**
     * The kind of the action.
     */
    kind = 'setTypeHints';

    /**
     * The hints for shape types.
     */
    shapeHints: ShapeTypeHint[];

    /**
     * The hints for edge types.
     */
    edgeHints: EdgeTypeHint[];
}

interface RequestCheckEdgeAction extends RequestAction<CheckEdgeResultAction> {
    kind: 'requestCheckEdge';

    /**
     * The element type of the edge being created.
     */
    edgeType: string;

    /**
     * The ID of the edge source element.
     */
    sourceElementId: string;

    /**
     * The ID of the edge target element to check.
     */
    targetElementId?: string;
}

interface CheckEdgeResultAction extends ResponseAction {
    kind: 'checkEdgeTargetResult';

    /**
     * true if the selected element is a valid target for this edge,
     * false otherwise.
     */
    isValid: boolean;
    /**
     * The element type of the edge that has been checked.
     */
    edgeType: string;

    /**
     * The ID of the source element of the edge that has been checked.
     */
    sourceElementId: string;
    /**
     * The ID of the target element of the edge that has been checked.
     */
    targetElementId?: string;
}

interface CreateNodeOperation extends CreateOperation {
    /**
     * The kind of the action.
     */
    kind = 'createNode';

    /*
     * The location at which the operation shall be executed.
     */
    location?: Point;

    /*
     * The container in which the operation shall be executed.
     */
    containerId?: string;
}

interface CreateEdgeOperation extends CreateOperation {
    /**
     * The kind of the action.
     */
    kind = 'createEdge';

    /*
     * The source element.
     */
    sourceElementId: string;

    /*
     * The target element.
     */
    targetElementId: string;
}

interface DeleteElementOperation extends Operation {
    /**
     * The kind of the action.
     */
    kind = 'deleteElement';

    /**
     * The elements to be deleted.
     */
    elementIds: string[];
}

interface ChangeBoundsOperation extends Operation {
    /**
     * The kind of the action.
     */
    kind = 'changeBounds';

    /**
     * The new bounds of the respective elements.
     */
    newBounds: ElementAndBounds[];
}

interface ChangeContainerOperation implements Operation {
    /**
     * The kind of the action.
     */
    kind = 'changeContainer';

    /**
     * The element to be changed.
     */
    elementId: string;

    /**
     * The element container of the changeContainer operation.
     */
    targetContainerId: string;

    /**
     * The graphical location.
     */
    location?: string;
}

interface ReconnectEdgeOperation extends Operation {
    /**
     * The kind of the action.
     */
    kind = 'reconnectEdge';

    /**
     * The edge element that should be reconnected.
     */
    edgeElementId: string;

    /**
     * The (new) source element of the edge.
     */
    sourceElementId: string;

    /**
     * The (new) target element of the edge.
     */
    targetElementId: string;

    /*
     * Additional arguments for custom behavior.
     */
    args?: Args;
}

interface ChangeRoutingPointsOperation extends Operation {
    /**
     * The kind of the action.
     */
    kind = 'changeRoutingPoints';

    /**
     * The routing points of the edge (may be empty).
     */
    newRoutingPoints: ElementAndRoutingPoints[];
}

interface ValidationStatus {
    /**
     * The severity of the validation returned by the server.
     */
    readonly severity: ValidationStatus.Severity;

    /**
     * The validation status message which may be rendered in the view.
     */
    readonly message?: string;

    /**
     * A potential error that encodes more details.
     */
    readonly error?: ResponseError;
}

interface ResponseError {
    /**
     * Code identifying the error kind.
     */
    readonly code: number;

    /**
     * Error message.
     */
    readonly message: string;

    /**
     * Additional custom data, e.g., a serialized stacktrace.
     */
    readonly data: Object;
}

namespace ValidationStatus {
    enum Severity {
        FATAL,
        ERROR,
        WARNING,
        INFO,
        OK,
        NONE
    }
}

interface RequestEditValidationAction extends RequestAction<SetEditValidationResultAction> {
    /**
     * The kind of the action.
     */
    kind = 'requestEditValidation';

    /**
     * Context in which the text is validated, e.g., 'label-edit'.
     */
    contextId: string;

    /**
     * Model element that is being edited.
     */
    modelElementId: string;

    /**
     * Text that should be considered for the model element.
     */
    text: string;
}

interface SetEditValidationResultAction extends ResponseAction {
    /**
     * The kind of the action.
     */
    kind = 'setEditValidationResult';

    /**
     * Validation status.
     */
    status: ValidationStatus;

    /*
     * Additional arguments for custom behavior.
     */
    args?: Args;
}

interface ApplyLabelEditOperation extends Operation {
    /**
     * The kind of the action.
     */
    kind = 'applyLabelEdit';

    /**
     * Identifier of the label model element.
     */
    labelId: string;

    /**
     * Text that should be applied on the label.
     */
    text: string;
}

type ClipboardData = { [format: string]: string };

interface RequestClipboardDataAction extends RequestAction<SetClipboardDataAction> {
    /**
     * The kind of the action.
     */
    kind = 'requestClipboardData';

    /**
     * The current editor context.
     */
    editorContext: EditorContext;
}

interface SetClipboardDataAction extends ResponseAction {
    /**
     * The kind of the action.
     */
    kind = 'setClipboardData';

    /**
     * The selected elements from the editor context as clipboard data.
     */
    clipboardData: ClipboardData;
}

interface CutOperation extends Operation {
    /**
     * The kind of the action.
     */
    kind = 'cut';

    /**
     * The current editor context.
     */
    editorContext: EditorContext;
}

interface PasteOperation extends Operation {
    /**
     * The kind of the action.
     */
    kind = 'paste';

    /**
     * The current editor context.
     */
    editorContext: EditorContext;

    /**
     * The clipboard data that should be pasted to the editor's last recorded mouse position (see `editorContext`).
     */
    clipboardData: ClipboardData;
}

interface UndoAction {
    /**
     * The kind of the action.
     */
    kind = 'glspUndo';
}

interface RedoAction {
    /**
     * The kind of the action.
     */
    kind = 'glspRedo';
}

interface RequestContextActions extends RequestAction<SetContextActions> {
    /**
     * The kind of the action.
     */
    kind = 'requestContextActions';

    /**
     * The identifier for the context.
     */
    contextId: string;

    /**
     * The current editor context.
     */
    editorContext: EditorContext;
}

interface SetContextActions extends ResponseAction {
    /**
     * The kind of the action.
     */
    kind = 'setContextActions';

    /**
     * The actions available in the queried context.
     */
    readonly actions: LabeledAction[];

    /**
     * Custom arguments.
     */
    args: ?Args;
}

interface Tool {
    /**
     * Unique tool id.
     */
    readonly id: string;

    /**
     * Notifies the tool to become active.
     */
    enable(): void;

    /**
     * Notifies the tool to become inactive.
     */
    disable(): void;
}

interface TriggerNodeCreationAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'triggerNodeCreation';

    /**
     * The type of node that should be created by the node creation tool.
     */
    elementTypeId: string;

    /**
     * Custom arguments.
     */
    args?: Args;
}

interface TriggerEdgeCreationAction extends Action {
    /**
     * The kind of the action.
     */
    kind = 'triggerEdgeCreation';

    /**
     * The type of edge that should be created by the edge creation tool.
     */
    elementTypeId: string;

    /**
     * Custom arguments.
     */
    args?: Args;
}