@ws-ui/store 0.1.1 → 0.1.2

package/dist/modules/model/types.d.ts

@@ -0,0 +1,97 @@
+/// <reference types="@ws-ui/shared/dist/declarations/datasources/interfaces/catalog" />
+import { Edge, Node } from 'react-flow-renderer';
+export interface TypeSuggestItem {
+    /** the title of the attribute type (used for display) */
+    title: string;
+    /**
+     * based on the selected type, the kind can be
+     * - related entity
+     * - related entities
+     * - alias
+     * - storage
+     */
+    kind: catalog.AttributeKind;
+    /**
+     * the calculated kind holds the final value of the attribute kind property.
+     * it is resolved based on the selected type.
+     */
+    calculatedKind: catalog.AttributeKind;
+    /** the actual value of the type.
+     * - can be a primitive type (date, number, bool, ...etc)
+     * - can be a dataclass name or a collection name ( related attribute )
+     * - can be a full path to an existing attribute. (alias)
+     */
+    value: string;
+    /**
+     * it holds to final value for the attributes type property. it is resolved based on the selected type.
+     */
+    calculatedType: string;
+    /**
+     * optional property defining the attribute behavior
+     */
+    behavior?: string;
+}
+export type TypeSuggestItems = TypeSuggestItem[];
+export type ModelNode = Omit<Node, 'type' | 'data'> & {
+    data: catalog.IDataClass;
+    type: 'table';
+};
+export type ModelEdge = Omit<Edge, 'data'> & {
+    data: {
+        sourceDataclass: string;
+        sourceAttribute?: string;
+        targetDataclass: string;
+        targetAttribute?: string;
+    };
+};
+export interface ServerModel {
+    toJSON: boolean;
+    extraProperties?: catalog.IModelProperties;
+    dataClasses: catalog.IDataClass[];
+}
+export type DataclassScope = 'public' | 'publicOnServer';
+export type AttributeScope = 'public' | 'publicOnServer' | 'protected' | 'private';
+export type TIndexType = 'btree' | 'cluster' | 'auto' | undefined;
+export declare enum EAttributeTypes {
+    UUID = "uuid",
+    STRING = "string",
+    TEXT = "text",
+    DATE = "date",
+    TIME = "duration",
+    BOOLEAN = "bool",
+    BYTE = "byte",
+    INTEGER = "word",
+    LONG = "long",
+    LONG64 = "long64",
+    FLOAT = "number",
+    BLOB = "blob",
+    IMAGE = "image",
+    OBJECT = "object"
+}
+export declare enum EAttributeKind {
+    STORAGE = "storage",
+    RELATEDENTITY = "relatedEntity",
+    RELATEDENTITIES = "relatedEntities",
+    CALCULATED = "calculated",
+    COMPOSITION = "composition",
+    ALIAS = "alias"
+}
+export declare const isValidPrimaryKey: (attribute: catalog.IAttribute) => boolean;
+export declare const attributeKinds: {
+    label: string;
+    value: string;
+}[];
+export declare const primaryKeyAttributes: TypeSuggestItems;
+export declare const attributeTypes: TypeSuggestItems;
+export declare const dataclassScopes: {
+    label: string;
+    value: string;
+}[];
+export declare const attributeScopes: {
+    label: string;
+    value: string;
+}[];
+export declare const indexTypes: {
+    label: string;
+    value: string;
+}[];

package/dist/modules/roles/__tests__/adapter.test.d.ts

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

package/dist/modules/roles/adapter.d.ts

@@ -0,0 +1,179 @@
+import { EPermissionType, IGraphData, IPermission, IPrivilege, IResource, IResourcePermission, ISanitized, TById, TRawData, TRole, TRolesDict, TSanitizedPrivilege } from './types';
+/**
+ * pushes uniquely list of items
+ * @param array input array
+ * @param args list of elements to add to the array
+ * @returns an array containing unique fields
+ */
+export declare function uniquePush<T = string>(array: T[], ...args: T[]): T[];
+/**
+ * Sanitize a privileges array
+ * @param data unsanitized data
+ * @returns sanitized data
+ */
+export declare function sanitizePrivileges(data: IPrivilege[]): TById;
+/**
+ * sort list of sanitized pivileges
+ * @param dict sanitized data
+ * @returns sorted privileges
+ */
+export declare function sort(dict: TById): TSanitizedPrivilege[];
+/**
+ * Lists the parents of a specific element
+ * @param id identifier of the current element
+ * @param dict sanitized privileges
+ * @returns parents of the current element
+ */
+export declare function parents(id: string, dict: TById): string[];
+/**
+ * Lists the children of a specific element
+ * @param id identifier of the current element
+ * @param dict sanitized privileges
+ * @returns children of the current element
+ */
+export declare function children(id: string, dict: TById): string[];
+/**
+ * Calculates from a sanitized privileges dictionary the list of allowed to include children
+ * @param id identifier of the current element
+ * @param dict sanitized privileges
+ * @returns allowed to include privileges
+ */
+export declare function allowed(id: string, dict: TById): string[];
+/**
+ * Removes an element from a sanitized dictionary
+ * @param id identifier of the current element
+ * @param dict sanitized privileges
+ * @returns new dictionary containing the initialone except the one with "id"
+ */
+export declare function remove(id: string, dict: TById): TById;
+/**
+ * Adds an existing node as a child of another node
+ * @param parentId the parent identifier
+ * @param childId the child identifer
+ * @param dict sanitized privileges dictionary
+ * @returns the new dictionary
+ */
+export declare function addIn(parentId: string, childId: string, dict: TById): TById;
+/**
+ * Removes an existing node from its (specified) parent
+ * @param parentId the parent identifier
+ * @param childId the child identifer
+ * @param dict sanitized privileges dictionary
+ * @returns the new dictionary
+ */
+export declare function removeFrom(parentId: string, childId: string, dict: TById): TById;
+/**
+ * Create a new privilege
+ * @param name the privilege name
+ * @param dict sanitized privileges dictionary
+ * @returns the new dictionary
+ */
+export declare function create(name: string, dict: TById): TById;
+export declare function createWithResource(name: string, resource: string, type: EPermissionType, action: IResourcePermission['name'], dict: TById): TById;
+/**
+ * Renames an existing node
+ * @param name the new name
+ * @param id the node identifier
+ * @param dict sanitized privileges dictionary
+ * @returns the new dictionary
+ */
+export declare function rename(name: string, id: string, dict: TById): TById;
+/**
+ * Populates a list privileges IDs
+ * @param ids the identifiers of privileges to populate
+ * @param dict sanitized privileges dictionary
+ * @returns populated privileges
+ */
+export declare function populateShallow(ids: string[], dict: TById): (IPrivilege | null)[];
+/**
+ * Get the privilege object from its identifier
+ * @param id the identifier of the node
+ * @param dict sanitized privileges dictionary
+ * @returns populated privilege
+ */
+export declare function getPrivilegeById(id: string, dict: TById): TSanitizedPrivilege | null;
+/**
+ * Maps the privileges to their permissions
+ * @param param0 the raw permission object
+ * @returns an object mapping the privilege to its permission
+ */
+export declare function actionsToPrivs({ applyTo, type, ...actions }: IPermission): {
+    [privName: string]: string[];
+};
+/**
+ * Converts a raw permission to a resource
+ * @param item a permission
+ * @returns the resource object
+ */
+export declare function getResourceFromType(item: IPermission): IResource;
+/**
+ * Sanitizes the raw permissions
+ * @param data list of raw permissions
+ * @param byKey dictionary
+ * @returns a new dictionary containing the sanitized permissions
+ */
+export declare function sanitizePermissions(data: IPermission[], byKey: TById): TById;
+/**
+ * Converts a dictionary indexed by id to a new one indexed by name
+ * @param dict dictioanry
+ * @returns a new dictionary indexed by privilege name
+ */
+export declare function getDictByName(dict: TById): TById;
+/**
+ * Sanitizes the content of roles.json file
+ * @param data raw data
+ * @returns sanitized data
+ */
+export declare function sanitize(data: TRawData): ISanitized;
+/**
+ * Converts sanitized data to a valid API payload
+ * @param data sanitized dictionary
+ * @returns raw data
+ */
+export declare function toAPI(data: ISanitized): TRawData;
+export declare function getGraphData(id: string, dict: TById): IGraphData;
+/**
+ *
+ * @param id privilege id
+ * @param permission
+ * @param dict
+ */
+export declare function addPermission(id: string, permission: IPermission, dict: TById): TById;
+/**
+ *
+ * @param id
+ * @param permission
+ * @param dict
+ */
+export declare function removePermission(id: string, permission: IPermission, dict: TById): TById;
+/**
+ *
+ * @param id
+ * @param permission
+ * @param dict
+ */
+export declare function resetResources(id: string, dict: TById): TById;
+/**
+ *
+ * @param id privilege id
+ * @param resource resource name
+ * @param type resource type
+ * @param permission permission name
+ * @param dict privileges dictionary
+ * @returns
+ */
+export declare function togglePrivilegePermission(id: string, resource: string, type: EPermissionType, permission: IResourcePermission['name'], dict: TById): TById;
+/**
+ *
+ * @param id
+ * @param permission
+ * @param dict
+ */
+export declare function togglePermission(id: string, resource: IResource, permission: IResourcePermission, dict: TById): TById;
+export declare function getPromotions(id: string, dict: TById): Record<string, string[]>;
+export declare function getInheritedResources(id: string, dict: TById): IResource[];
+export declare const toState: (rolesArray: TRole[]) => TRolesDict;
+export declare const removeRole: (id: string, roles: TRolesDict) => TRolesDict;
+export declare const editRole: (id: string, newName: string, roles: TRolesDict) => TRolesDict;
+export declare const createRole: (id: string, roles: TRolesDict) => TRolesDict;
+export declare const saveRole: (role: TRole, roles: TRolesDict) => TRolesDict;

package/dist/modules/roles/index.d.ts

@@ -0,0 +1,21 @@
+declare const _default: import("redux").Reducer<{
+    flags: {
+        touched?: boolean | undefined;
+        removed?: boolean | undefined;
+        pinned?: boolean | undefined;
+        loading?: boolean | undefined;
+        old?: boolean | undefined;
+        enabled?: boolean | undefined;
+        confirmed?: boolean | undefined;
+    };
+    date?: string | undefined;
+    privileges: import("./types").TById;
+    roles: import("./types").TRolesDict;
+    forceLogin?: boolean | undefined;
+    selectedTab: "roles" | "privileges";
+}>;
+export default _default;
+export * from './reducer';
+export * from './thunks';
+export * from './types';
+export * from './adapter';

package/dist/modules/roles/reducer.d.ts

@@ -0,0 +1,64 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { IRolesState, TById, TRawData, TRolesDict } from './types';
+declare const stateSlice: import("@reduxjs/toolkit").Slice<{
+    flags: {
+        touched?: boolean | undefined;
+        removed?: boolean | undefined;
+        pinned?: boolean | undefined;
+        loading?: boolean | undefined;
+        old?: boolean | undefined;
+        enabled?: boolean | undefined;
+        confirmed?: boolean | undefined;
+    };
+    date?: string | undefined;
+    privileges: TById;
+    roles: TRolesDict;
+    forceLogin?: boolean | undefined;
+    selectedTab: "roles" | "privileges";
+}, {
+    updatePrivileges: (state: import("immer/dist/internal.js").WritableDraft<IRolesState>, action: PayloadAction<TById>) => void;
+    updateRoles: (state: import("immer/dist/internal.js").WritableDraft<IRolesState>, action: PayloadAction<TRolesDict>) => void;
+    updateRolesAndPrivileges: (state: import("immer/dist/internal.js").WritableDraft<IRolesState>, action: PayloadAction<{
+        roles: TRolesDict;
+        privileges: TById;
+    }>) => void;
+    toggleTab: (state: import("immer/dist/internal.js").WritableDraft<IRolesState>, action: PayloadAction<'privileges' | 'roles'>) => void;
+    toggleForceLogin: (state: import("immer/dist/internal.js").WritableDraft<IRolesState>, action: PayloadAction<boolean>) => void;
+    setRolesContent(state: import("immer/dist/internal.js").WritableDraft<IRolesState>, action: PayloadAction<{
+        content: TRawData;
+        date?: string;
+        flags?: IRolesState['flags'];
+    }>): {
+        flags: {
+            touched?: boolean | undefined;
+            removed?: boolean | undefined;
+            pinned?: boolean | undefined;
+            loading?: boolean | undefined;
+            old?: boolean | undefined;
+            enabled?: boolean | undefined;
+            confirmed?: boolean | undefined;
+        };
+        date?: string | undefined;
+        privileges: TById;
+        roles: TRolesDict;
+        forceLogin?: boolean | undefined;
+        selectedTab: "roles" | "privileges";
+    };
+}, "roles">;
+export declare const updatePrivileges: import("@reduxjs/toolkit").ActionCreatorWithPayload<TById, string>, updateRoles: import("@reduxjs/toolkit").ActionCreatorWithPayload<TRolesDict, string>, setRolesContent: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    content: TRawData;
+    date?: string | undefined;
+    flags?: Partial<{
+        touched: boolean;
+        removed: boolean;
+        pinned: boolean;
+        loading: boolean;
+        old: boolean;
+        enabled: boolean;
+        confirmed: boolean;
+    }> | undefined;
+}, string>, toggleTab: import("@reduxjs/toolkit").ActionCreatorWithPayload<"roles" | "privileges", string>, toggleForceLogin: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, string>, updateRolesAndPrivileges: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    roles: TRolesDict;
+    privileges: TById;
+}, string>;
+export default stateSlice;

package/dist/modules/roles/thunks.d.ts

@@ -0,0 +1,24 @@
+import { ITabFlags } from '@ws-ui/shared';
+import { IFileContentResponse, ISetFileContentResponse } from '@ws-ui/shared';
+import { AppState } from '..';
+import { ISanitized } from './types';
+export declare const fetchRoles: import("@reduxjs/toolkit").AsyncThunk<IFileContentResponse<ISanitized>, void, {
+    state: AppState;
+    rejectValue: string;
+}>;
+export declare const fetchRolesChanges: import("@reduxjs/toolkit").AsyncThunk<Partial<{
+    touched: boolean;
+    removed: boolean;
+    pinned: boolean;
+    loading: boolean;
+    old: boolean;
+    enabled: boolean;
+    confirmed: boolean;
+}>, void, {
+    state: AppState;
+}>;
+export declare const isRolesOutdated: (date: string | undefined) => Promise<boolean>;
+export declare const saveRoles: import("@reduxjs/toolkit").AsyncThunk<ISetFileContentResponse, ISanitized, {
+    state: AppState;
+    rejectValue: string | ITabFlags;
+}>;

package/dist/modules/roles/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Raw API response typing
+ */
+import { ITabFlags } from '@ws-ui/shared';
+export type TRawData = Partial<{
+    privileges: IPrivilege[];
+    roles: IRole[];
+    permissions: Partial<{
+        allowed: IPermission[];
+    }>;
+    forceLogin: boolean;
+}>;
+export type TPermissionOption = Pick<IPermission, 'applyTo' | 'type'>;
+export type TAction = 'read' | 'create' | 'update' | 'drop' | 'describe' | 'execute' | 'promote';
+export type IRolesState = ISanitized & {
+    flags: ITabFlags;
+    date?: string;
+    selectedTab: 'privileges' | 'roles';
+};
+export interface IPrivilege {
+    id?: string;
+    privilege: string;
+    includes?: string[];
+}
+export interface IRole {
+    id?: string;
+    role: string;
+    privileges?: string[];
+}
+export type TRole = Required<IRole>;
+export declare enum EPermissionType {
+    DATACLASS = "dataclass",
+    METHOD = "method",
+    ATTRIBUTE = "attribute",
+    DATASTORE = "datastore"
+}
+export interface IPermission {
+    applyTo: string;
+    type: EPermissionType;
+    read?: string | string[];
+    create?: string | string[];
+    update?: string | string[];
+    drop?: string | string[];
+    describe?: string | string[];
+    execute?: string | string[];
+    promote?: string | string[];
+}
+/**
+ * Sanitized data
+ */
+export interface ISanitized {
+    privileges: TById;
+    roles: TRolesDict;
+    forceLogin?: boolean;
+}
+export interface IResourcePermission {
+    name: TAction;
+    from: string[];
+    checked?: boolean;
+    info?: string;
+}
+export interface IResource {
+    resource: string;
+    type: EPermissionType;
+    permissions: IResourcePermission[];
+}
+export type TSanitizedPrivilege = Required<IPrivilege> & {
+    parents: string[];
+    resources: IResource[];
+};
+export type TById = {
+    [id: string]: TSanitizedPrivilege;
+};
+export type TRolesDict = {
+    [id: string]: TRole;
+};
+export interface ILink {
+    source: string;
+    target: string;
+}
+export interface IGraphData {
+    selected: string;
+    parents: string[][];
+    children: string[][];
+    links: ILink[];
+}

package/dist/modules/root/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("redux").Reducer<import("immer/dist/internal.js").WritableDraft<import("./types").IRootState>>;
+export default _default;
+export * from './reducer';
+export * from './thunks';
+export * from './types';

package/dist/modules/root/reducer.d.ts

@@ -0,0 +1,153 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { IWebFormStyleClass } from '@ws-ui/shared';
+import { ITab, ITabExtra, ITabFlags } from '@ws-ui/shared';
+import { IRootState, TActionAddDataSource, TActionRemoveDataSource, TActionSetDataSources } from './types';
+export declare const stateSlice: import("@reduxjs/toolkit").Slice<import("immer/dist/internal.js").WritableDraft<IRootState>, {
+    setPanelState(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<Partial<ITab['view']['panel']> & {
+        path: string;
+    }>): void;
+    addDataSource(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: TActionAddDataSource): void;
+    openSettingsTab(state: import("immer/dist/internal.js").WritableDraft<IRootState>): void;
+    removeDataSource(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: TActionRemoveDataSource): void;
+    setDataSources(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: TActionSetDataSources): void;
+    setTabs(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<ITab[]>): void;
+    closeTab(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<number>): void;
+    closeOthers(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<string>): void;
+    closeAllTabs(state: import("immer/dist/internal.js").WritableDraft<IRootState>): void;
+    closeRightTabs(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<number>): void;
+    closeLeftTabs(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<number>): void;
+    closeSavedTabs(state: import("immer/dist/internal.js").WritableDraft<IRootState>): void;
+    confirmTab(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<string>): void;
+    selectTab(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<string>): void;
+    openTabUnselected(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<ITab>): void;
+    selectTabByReference(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<ITab & {
+        isNew?: boolean;
+    }>): void;
+    setContent(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<{
+        path: string;
+        content: any;
+        contentPath?: string;
+    }>): void;
+    setTabFlags(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<{
+        path: string;
+        flags: ITabFlags;
+    }>): void;
+    setTabsFlags(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<{
+        tabs: string[];
+        flags: ITabFlags;
+    }>): void;
+    setTabExtra(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<{
+        path: string;
+        extra: ITabExtra;
+        flags?: ITabFlags;
+    }>): void;
+    addWebFormStyles(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<{
+        path: string;
+        styles: IWebFormStyleClass[];
+    }>): void;
+    changeTabEditor(state: import("immer/dist/internal.js").WritableDraft<IRootState>, action: PayloadAction<ITab>): import("immer/dist/internal.js").WritableDraft<IRootState>;
+}, "root">;
+export declare const setTabs: import("@reduxjs/toolkit").ActionCreatorWithPayload<ITab<any, Partial<{
+    initialLineInfo: {
+        line: number;
+        offset?: number | undefined;
+        lastModification: number;
+    };
+    initialSelectionInfo: {
+        selection: import("@ws-ui/shared").ITextEditorSelection;
+        lastModification: number;
+    };
+    diffContent: string;
+    attributes: import("@ws-ui/shared").IMethodAttributes;
+    source: import("@ws-ui/shared").ISource;
+    editor: import("@ws-ui/shared").IEditor;
+    ext: import("@ws-ui/shared").DebuggerFileExtension;
+}>>[], string>, closeTab: import("@reduxjs/toolkit").ActionCreatorWithPayload<number, string>, setContent: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    path: string;
+    content: any;
+    contentPath?: string | undefined;
+}, string>, setTabFlags: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    path: string;
+    flags: ITabFlags;
+}, string>, setTabsFlags: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    tabs: string[];
+    flags: ITabFlags;
+}, string>, setTabExtra: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    path: string;
+    extra: ITabExtra;
+    flags?: Partial<{
+        touched: boolean;
+        removed: boolean;
+        pinned: boolean;
+        loading: boolean;
+        old: boolean;
+        enabled: boolean;
+        confirmed: boolean;
+    }> | undefined;
+}, string>, closeAllTabs: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, addDataSource: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    datasourceDef: datasources.ICreateDataSource;
+    path: string;
+}, string>, closeRightTabs: import("@reduxjs/toolkit").ActionCreatorWithPayload<number, string>, closeOthers: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, string>, closeLeftTabs: import("@reduxjs/toolkit").ActionCreatorWithPayload<number, string>, closeSavedTabs: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setDataSources: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    datasourceArr: datasources.ICreateDataSource[];
+    path: string;
+}, string>, removeDataSource: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    path: string;
+    datasourceID: string;
+}, string>, confirmTab: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, string>, selectTab: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, string>, selectTabByReference: import("@reduxjs/toolkit").ActionCreatorWithPayload<ITab<any, Partial<{
+    initialLineInfo: {
+        line: number;
+        offset?: number | undefined;
+        lastModification: number;
+    };
+    initialSelectionInfo: {
+        selection: import("@ws-ui/shared").ITextEditorSelection;
+        lastModification: number;
+    };
+    diffContent: string;
+    attributes: import("@ws-ui/shared").IMethodAttributes;
+    source: import("@ws-ui/shared").ISource;
+    editor: import("@ws-ui/shared").IEditor;
+    ext: import("@ws-ui/shared").DebuggerFileExtension;
+}>> & {
+    isNew?: boolean | undefined;
+}, string>, openTabUnselected: import("@reduxjs/toolkit").ActionCreatorWithPayload<ITab<any, Partial<{
+    initialLineInfo: {
+        line: number;
+        offset?: number | undefined;
+        lastModification: number;
+    };
+    initialSelectionInfo: {
+        selection: import("@ws-ui/shared").ITextEditorSelection;
+        lastModification: number;
+    };
+    diffContent: string;
+    attributes: import("@ws-ui/shared").IMethodAttributes;
+    source: import("@ws-ui/shared").ISource;
+    editor: import("@ws-ui/shared").IEditor;
+    ext: import("@ws-ui/shared").DebuggerFileExtension;
+}>>, string>, addWebFormStyles: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    path: string;
+    styles: IWebFormStyleClass[];
+}, string>, changeTabEditor: import("@reduxjs/toolkit").ActionCreatorWithPayload<ITab<any, Partial<{
+    initialLineInfo: {
+        line: number;
+        offset?: number | undefined;
+        lastModification: number;
+    };
+    initialSelectionInfo: {
+        selection: import("@ws-ui/shared").ITextEditorSelection;
+        lastModification: number;
+    };
+    diffContent: string;
+    attributes: import("@ws-ui/shared").IMethodAttributes;
+    source: import("@ws-ui/shared").ISource;
+    editor: import("@ws-ui/shared").IEditor;
+    ext: import("@ws-ui/shared").DebuggerFileExtension;
+}>>, string>, openSettingsTab: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setPanelState: import("@reduxjs/toolkit").ActionCreatorWithPayload<Partial<{
+    isOpen: boolean;
+    type: string;
+    current: string;
+}> & {
+    path: string;
+}, string>;
+export default stateSlice;