@imtf/dms-core 1.0.0-beta.1

package/core/providers/Inodes/service.d.ts

@@ -0,0 +1,149 @@
+import { AxiosRequestConfig } from "axios";
+import { FileInode, ImmutableInode, Inode, InodeEventList, InodeList, InodeRefList, StateMachineActionResult, StateMachineApplyAction, Tag, TagList } from "./types";
+export declare const paths: Readonly<{
+    readonly home: (params?: {} | undefined) => string;
+    readonly workspace: (params?: {} | undefined) => string;
+    readonly inodes: (params?: {} | undefined) => string;
+    readonly inode: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly inodeTags: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly inodeList: (params?: {} | undefined) => string;
+    readonly inodeAcls: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly inodeAclGroups: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly children: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly copyTo: (params?: {
+        inodeOid: string | null;
+        targetOid: string | null;
+    } | undefined) => string;
+    readonly comments: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly timeline: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly tags: (params?: {} | undefined) => string;
+    readonly urls: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly changeType: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly fileContent: (params?: {
+        downloadId: string | null;
+    } | undefined) => string;
+    readonly thumbnail: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly properties: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly propertyComponents: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly propertyGroups: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly topPanels: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly versions: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly promoteBinary: (params?: {
+        version: string | null;
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly updateAllowedChildrenTypes: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly updateAllowedChildrenTemplates: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly customizableFields: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly mergePdf: (params?: {} | undefined) => string;
+    readonly bulk: (params?: {} | undefined) => string;
+    readonly bulkUpdateContent: (params?: {} | undefined) => string;
+    readonly bulkCopyTo: (params?: {
+        targetOid: string | null;
+    } | undefined) => string;
+    readonly bulkLinkTo: (params?: {
+        targetOid: string | null;
+    } | undefined) => string;
+    readonly bulkFavorite: (params?: {} | undefined) => string;
+    readonly bulkUnfavorite: (params?: {} | undefined) => string;
+    readonly bulkWatch: (params?: {} | undefined) => string;
+    readonly bulkUnwatch: (params?: {} | undefined) => string;
+    readonly bulkStateAction: (params?: {} | undefined) => string;
+    readonly bulkRestore: (params?: {} | undefined) => string;
+    readonly bulkDownload: (params?: {} | undefined) => string;
+    readonly download: (params?: {} | undefined) => string;
+    readonly templates: (params?: {} | undefined) => string;
+    readonly terms: (params?: {} | undefined) => string;
+    readonly dmsOperations: (params?: {} | undefined) => string;
+    readonly downloadTimeline: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly barcodeProcessing: (params?: {} | undefined) => string;
+    readonly businessProcesses: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly businessProcessesCapabilities: (params?: {
+        inodeOid: string | null;
+    } | undefined) => string;
+    readonly relatedDossiers: (params?: {
+        dossierType: string | null;
+        dossierName: string | null;
+    } | undefined) => string;
+}>;
+export declare function getImmutable(inodeOid: string, params: Record<string, unknown>): Promise<ImmutableInode>;
+export declare function get(inodeOid: string, params: Record<string, unknown>): Promise<Inode>;
+export declare function getList(inodeRefList: InodeRefList): Promise<Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode">[]>;
+export declare function save(inode: Inode): Promise<Inode>;
+export declare function saveBulk(inodeList: InodeList, mergeOnNameConflict?: boolean): Promise<Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode">[]>;
+export declare function create(inode: Partial<Inode>): Promise<Inode>;
+export declare function copy(inodeOid: string, targetOid: string): Promise<import("immutable").Collection<unknown, unknown>>;
+export declare function copyBulk(inodeRefList: InodeRefList, targetOid: string): Promise<Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode">[]>;
+export declare function saveChildrenAllowedTypes(inodeOid: string, typesObject: unknown): Promise<any[]>;
+export declare function saveChildrenAllowedTemplates(inodeOid: string, templatesObject: unknown): Promise<any[]>;
+export declare function trash(inodeRefList: InodeRefList, params: Record<string, unknown>): Promise<import("axios").AxiosResponse<any, any>>;
+export declare function getHome(): Promise<Inode>;
+export declare function getWorkspace(): Promise<Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode">[]>;
+export declare function getChildren(inodeOid: string, params: Record<string, unknown>): Promise<Inode[]>;
+export declare function uploadFiles(files: File[], inodes: FileInode[], params: Record<string, unknown>): Promise<Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode">[]>;
+export declare function getTimeLine(inodeOid: string, params: Record<string, unknown>): Promise<InodeEventList>;
+export declare function getTags(inputVal: string, limit?: number): Promise<Tag[]>;
+export declare function createTag(name: string): Promise<Tag>;
+export declare function getTagsForInode(inodeOid: string): Promise<Tag[]>;
+export declare function updateTags(inodeOid: string, tags: Tag[]): Promise<import("axios").AxiosResponse<TagList, any>>;
+export declare function favoriteBulk(inodeRefList: InodeRefList): Promise<Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode">[]>;
+export declare function unfavoriteBulk(inodeRefList: InodeRefList): Promise<Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode">[]>;
+export declare function getInodeUrls(inodeOid: string): Promise<any[]>;
+export declare function watchBulk(inodeRefList: InodeRefList): Promise<import("axios").AxiosResponse<void, any>>;
+export declare function unwatchBulk(inodeRefList: InodeRefList): Promise<import("axios").AxiosResponse<void, any>>;
+export declare function stateAction(action: StateMachineApplyAction): Promise<StateMachineActionResult>;
+export declare function generateDownloadToken(downloadId: string): Promise<import("axios").AxiosResponse<string, any>> & {
+    "@@redux-saga/CANCEL_PROMISE"?: import("axios").Canceler;
+};
+export declare function getPropertiesComponents(inodeOid: string): Promise<import("immutable").Collection<unknown, unknown>>;
+export declare function getBinaryBlob(downloadId: string): Promise<any>;
+export declare function getVersions(inodeOid: string): Promise<any[]>;
+export declare function updateBinary(inodeOid: string, file: File, params: Record<string, unknown>): Promise<any[]>;
+export declare function restoreInodeBulk(inodeList: InodeList): Promise<Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode">[]>;
+export declare function getFieldsDefinition(inodeOid: string): Promise<any[]>;
+export declare function getAllChildren<Params extends Record<string, unknown>>(inodeOid: string, params: Params): Promise<{
+    allChildren: Inode[];
+    exploredFolders: string[];
+}>;
+export declare function getInodeProperties(inodeOid: string): Promise<import("./types").PropertiesGroup[]>;
+export declare function getInodeTimelineCsv(inodeOid: string, options: AxiosRequestConfig): Promise<any>;

package/core/providers/Inodes/types.d.ts

@@ -0,0 +1,411 @@
+import { List, MapOf } from "immutable";
+import { COMMENT, DENIED_INODE, DOSSIER, DOSSIER_TYPE, FILE, FOLDER, INODE_LIST, INODE_REF, INODE_REF_LIST, PROPERTY, PROPERTY_LIST, STACK, STATE_MACHINE_APPLY_ACTION, TAG, TAGLIST, TEMPLATE, TEMPLATE_REF, TERM_REF } from "../../../core/constants/kinds";
+import { UI } from "../../components/dms-ui/constants";
+import { SUPPORTED_MIME_TYPES } from "../../containers/PDFTronViewer/constants";
+import { TimelineEvent } from "../App/types";
+import { Case, CaseRef } from "../Cases/types";
+import { CaseDefinition, TaskDefinition } from "../Definitions/types";
+import type { Task } from "../Tasks/types";
+import { User, UserGroup } from "../User/types";
+export type DossierRef = {
+    kind: "acm.DossierRef";
+    oid: string;
+    uri: string;
+};
+export type ImmutableInode<Kind extends "dms-core.File" | "dms-core.Folder" | "dms-core.Dossier" | "dms-core.Template" = typeof FILE | typeof FOLDER | typeof DOSSIER | typeof TEMPLATE> = MapOf<Omit<Inode<Kind>, "allowedTypes" | "capabilities" | "childrenAllowedTemplates" | "childrenAllowedTypes" | "properties" | "stateMachines" | "ancestors" | "type"> & {
+    allowedTypes: List<MapOf<InodeTypeRef>>;
+    type: MapOf<InodeTypeRef>;
+    ancestors: List<MapOf<Ancestor>>;
+    capabilities: MapOf<Capabilities>;
+    childrenAllowedTemplates: List<MapOf<TemplateRef>>;
+    childrenAllowedTypes: List<MapOf<InodeTypeRef>>;
+    properties: MapOf<{
+        kind: typeof PROPERTY_LIST;
+        items: List<MapOf<Property>>;
+    }>;
+    stateMachines: List<MapOf<Omit<StateMachine, "actions"> & {
+        actions: List<MapOf<StateMachineAction>>;
+    }>>;
+}>;
+export type Inode<Kind extends typeof FILE | typeof FOLDER | typeof DOSSIER | typeof TEMPLATE | typeof DENIED_INODE = typeof FILE | typeof FOLDER | typeof DOSSIER | typeof TEMPLATE | typeof DENIED_INODE> = {
+    allowedTypes: InodeTypeRef[];
+    ancestors?: Ancestor[];
+    capabilities?: Capabilities;
+    childrenAllowedTemplates?: TemplateRef[];
+    childrenAllowedTypes?: InodeTypeRef[];
+    creationDate: string;
+    deleted?: boolean;
+    deleteInfo?: {
+        kind: "dms-core.DeleteInfo";
+        timestamp: string;
+        user: User;
+    };
+    shared?: boolean;
+    downloadId: string;
+    favorite?: boolean;
+    forceChildrenWithTemplate?: boolean;
+    forceChildrenWithType?: boolean;
+    forceWithType?: boolean;
+    kind: Kind;
+    commentsCount?: number;
+    label: string;
+    mimeType: keyof typeof SUPPORTED_MIME_TYPES | string;
+    modificationDate: string;
+    name: string;
+    oid: string;
+    orderingWeight: number;
+    parentOid?: string;
+    watched?: boolean;
+    template?: TemplateRef;
+    permissions: {
+        [key: string]: boolean | undefined;
+    } | null;
+    fields: {
+        [key: string]: string;
+    };
+    caseRefs?: {
+        items: CaseRef[];
+    };
+    mdmEntityRefs?: {
+        kind: "dms-core.MdmEntityRefList";
+        items: Array<{
+            kind: "dms-core.MdmEntityRef";
+            oid: string;
+            uri: string;
+        }>;
+    };
+    referredUnfile?: {
+        referrers: InodeRef[];
+    };
+    tags?: TagList;
+    properties: {
+        kind: typeof PROPERTY_LIST;
+        items: Property[];
+    };
+    size: number;
+    stateMachines?: StateMachine[];
+    type?: InodeTypeRef;
+    uri: string;
+    version: number;
+    /**
+     * For barcode processing : backend give us a transientFileId
+     * to be able to process a previously uploaded file without
+     * reuploading it.
+     */
+    transientFileId?: string;
+};
+export type InodeStack = {
+    kind: typeof STACK;
+    oid: number;
+    items: Inode[];
+};
+type Ancestor = {
+    kind: typeof INODE_REF;
+    name: Inode["name"];
+    label: Inode["label"];
+    oid: Inode["oid"];
+};
+type Capabilities = {
+    kind: "dms.core.Capabilities";
+    canAddFolderOfTypes: InodeType["name"][];
+    canViewPanels: string[];
+    canAddFile: boolean;
+    canSendLinkByEmail: boolean;
+    canAddFileOfTypes: InodeType["name"][];
+    canAssignTypes: InodeType["name"][];
+    canCreateCase: boolean;
+    canAddFileWithoutBinary: boolean;
+    canAddFileWithoutBinaryOfTypes: InodeType["name"][];
+};
+export type InodeList = {
+    kind: typeof INODE_LIST;
+    items: Inode[];
+};
+export type InodeRef = {
+    kind: typeof INODE_REF;
+    oid: string;
+    name: string;
+    label?: string;
+};
+export type InodeRefList = {
+    kind: typeof INODE_REF_LIST;
+    items: InodeRef[];
+};
+export interface FileInode extends Inode {
+    kind: typeof FILE;
+    mimeType: string;
+}
+export interface TemplateInode extends Inode {
+    kind: typeof TEMPLATE;
+}
+export type Tag = {
+    kind: typeof TAG;
+    name: string;
+};
+export type TagList = {
+    kind: typeof TAGLIST;
+    items: Tag[];
+};
+export type Comment = {
+    kind: typeof COMMENT;
+    commentOn: Inode;
+    text: string;
+    oid: string;
+    creationDate: string;
+    author: {
+        firstname: string;
+        lastname: string;
+        [key: string]: any;
+    };
+};
+export type CommentList = {
+    comments: Comment[];
+};
+export type StateMachine = {
+    kind: "dms-core.StateMachine";
+    name?: string;
+    label?: string;
+    state: StateMachineState;
+    actions: StateMachineAction[];
+};
+export type StateMachineAction = {
+    kind: "dms-core.StateMachineAction";
+    name: string;
+    label: string;
+};
+export type ProcessState = {
+    kind: "dms-core.ui.ProcessState";
+    process: StateMachine["name"];
+    state: StateMachineState["name"];
+    label: StateMachineState["label"];
+};
+export type StateMachineState = {
+    kind: "dms-core.State";
+    name: string;
+    label: string;
+    metadata: {
+        [key: string]: unknown;
+    };
+};
+export type StateMachineApplyAction = {
+    kind: typeof STATE_MACHINE_APPLY_ACTION;
+    inodeRefList: InodeRefList;
+    label: string;
+    name: string;
+};
+export type StateMachineActionResult = {
+    kind: "dms-core.StateMachineActionResult";
+    [key: string]: any;
+};
+export type TermRef = {
+    kind: typeof TERM_REF;
+    label: string | null;
+    name: string;
+    orderingWeight: number;
+};
+export type InodeType = {
+    kind: "dms-core.Type";
+    name: string;
+    label: string;
+    orderingWeight?: number;
+    colour: string;
+    oid?: string;
+    creationDate?: string;
+    modificationDate?: string;
+    termReferences?: TermRef[];
+};
+export type InodeTypeRef = Pick<InodeType, "name" | "label" | "orderingWeight" | "colour"> & {
+    kind: "dms-core.TypeRef";
+};
+export type TypeOrTemplate = InodeType | InodeTypeRef | TemplateRef;
+export type DossierType = {
+    kind: typeof DOSSIER_TYPE;
+    dossierIdentifier: TermRef;
+} & Omit<InodeType, "kind">;
+export type InodeTypeList = {
+    kind: "dms-core.TypeList";
+    items: (InodeType | DossierType)[];
+};
+export type DmsAclGroup = {
+    kind: "dms-core.AclGroup";
+    inodeRef: InodeRef;
+    acls: DmsAcl[];
+};
+export type DmsAcl = {
+    kind: "dms-core.Acl";
+    additive: boolean;
+    inheritable: boolean;
+    principal: User | UserGroup;
+    operations: DmsAclOperation[];
+};
+export type DmsAclOperation = {
+    kind: "dms-core.Operation";
+    label: string;
+    name: string;
+};
+export type TemplateRef = {
+    kind: typeof TEMPLATE_REF;
+    name: InodeType["name"];
+    label: InodeType["label"];
+    orderingWeight: InodeType["orderingWeight"];
+};
+export type Property = {
+    kind: typeof PROPERTY;
+    name: string;
+    value: string | number | null;
+};
+export type PropertyList = {
+    kind: typeof PROPERTY_LIST;
+    items: Property[];
+};
+export type PropertiesComponent = {
+    kind: Exclude<(typeof UI)[keyof typeof UI], "dms-core.ui.component.Group">;
+    label: string;
+    name: string;
+    width?: number;
+    disabled?: boolean;
+    hidden?: boolean;
+    required?: boolean;
+    value?: string | number;
+    orderingWeight?: number;
+    datasourceName?: string;
+};
+export type PropertiesGroupList = {
+    kind: "dms-core.ui.component.GroupList";
+    items: PropertiesGroup[];
+};
+export type PropertiesGroup = {
+    kind: "dms-core.ui.component.Group";
+    components: PropertiesComponent[];
+    inodeRef: InodeRef;
+    typeRef: InodeTypeRef;
+};
+export type ValidationResult = {
+    kind: "dms-core.InodeValidationResultResource";
+    message: string;
+    validatorName: string;
+    validatorLabel: string;
+    valid: boolean;
+};
+export type ErrorResource = {
+    kind: "dms-core.Error";
+    name: string;
+    dmsInternalcode: number;
+    label: string;
+    timestamp: string;
+    correlationId: string;
+    description?: string;
+    systemInfos?: string;
+    stacktrace?: string;
+    conflictedId?: string;
+};
+export type NavigateOnCaseCreation = "case" | "disabled";
+export type BusinessProcessRefList = {
+    kind: "dms-inodes-business-processes.BusinessProcessRefList";
+    items: BusinessProcess[];
+};
+export type BusinessProcess = BusinessProcessHumanTaskRef | BusinessProcessCaseRef;
+export type BusinessProcessHumanTaskRef = {
+    kind: "dms-inodes-business-processes.BusinessProcessHumanTaskRef";
+    completedDate: string | null;
+    completedBy: string | null;
+    adhoc: boolean;
+    completionOutcome: string;
+    completionOutcomeLabel: string;
+} & Pick<Task, "uri" | "oid" | "presentableId" | "definitionName" | "definitionLabel" | "creationDate" | "label" | "modificationDate" | "completionOutcome" | "status" | "caseRef">;
+export type BusinessProcessCaseRef = {
+    kind: "dms-inodes-business-processes.BusinessProcessCaseRef";
+} & Pick<Case, "uri" | "oid" | "presentableId" | "definitionName" | "definitionLabel" | "creationDate" | "modificationDate" | "status">;
+export type BusinessProcessesCapabilities = {
+    canCreateCase: boolean;
+    canCreateCaseDeniedReason?: {
+        code: string;
+        text: string;
+    };
+    creatableCaseDefinitionNames: CaseDefinition["name"][];
+    creatableCaseDefinitionsNotAvailableReason?: {
+        code: string;
+        text: string;
+    };
+    canCreateTask: boolean;
+    canCreateTaskDeniedReason?: {
+        code: string;
+        text: string;
+    };
+    creatableTaskDefinitionNames: TaskDefinition["name"][];
+    creatableTaskDefinitionsNotAvailableReason?: {
+        code: string;
+        text: string;
+    };
+};
+export type VersionInfo = {
+    kind: "dms-core.VersionInfo";
+    version: number;
+    oid: string;
+    timestamp: string;
+    fileOid: string;
+    username: string;
+    firstname: string;
+    lastname: string;
+};
+export type VersionInfoList = {
+    kind: "dms-core.VersionInfoList";
+    items: VersionInfo[];
+};
+export type InodeState = {
+    [oid: Inode["oid"]]: {
+        item?: Inode;
+        versions?: VersionInfo[];
+        dossierOverview?: {
+            data: any;
+            template: any;
+        };
+        error?: any;
+    };
+};
+export type InodeEventList = {
+    kind: "acm.InodeEventList";
+    items: TimelineEvent[];
+};
+export type TopPanels = {
+    kind: "dms-core.ui.TopPanels";
+    name: string;
+    template: {
+        properties: {
+            key: string;
+            label: string;
+        }[];
+    };
+};
+/** Documentation : https://imtf.atlassian.net/wiki/spaces/FM/pages/530186290 */
+export type InodeChangeStatus = 
+/**
+ * Targetted inode accepts all inode's types/templates or inodes don't have
+ * type/template and no type/template is forced
+ * -> Returns unchanged inodes
+ */
+"NO_CHANGES_NEEDED"
+/** User doesn't have permission to assign types/templates */
+ | "NOT_PERMITTED"
+/** Type is forced but there's no enabled types to assign */
+ | "NOT_ASSIGNABLE"
+/**
+ * Folders  cannot have their templates changed
+ * -> Return warning modal
+ */
+ | "CANNOT_MODIFY_FOLDER_TEMPLATE"
+/** Targetted inode doesn't accept and doesn't forces types but some files have types
+ * -> User has to confirm if he wants to remove the types
+ */
+ | "REMOVE_TYPE_CONFIRMATION"
+/** Targetted inode accepts and forces only one type
+ * -> ONLY_ONE_TYPE : Confirmation will be asked if moving
+ * -> ONLY_ONE_TYPE_UPLOAD : Inodes will be assigned to the only type accepted if uploading
+ */
+ | "ONLY_ONE_TYPE" | "ONLY_ONE_TYPE_UPLOAD"
+/** Targetted inode accepts multiple types (forced or not)
+ * -> ASSIGN_TYPE : User has to choose the type
+ * -> ASSIGN_TYPE_AND_PROPERTIES : If enablePropertiesUpload is true we display assignTypeAndPropertiesModal
+ */
+ | "ASSIGN_TYPE" | "ASSIGN_TYPE_AND_PROPERTIES";
+export {};

package/core/providers/Inodes/utils/can.d.ts

@@ -0,0 +1,16 @@
+import { ImmutableInode, Inode } from "../types";
+export declare const immutableCan: Readonly<{
+    addFile(inode: unknown): boolean;
+    addFolder(inode: unknown): boolean;
+    createCase(inode: unknown): boolean;
+    assignType(inode: ImmutableInode, typeName: string): boolean;
+    viewPanels(inode: ImmutableInode, panelKey: string): boolean | string[];
+}>;
+declare const _default: Readonly<{
+    addFile(inode: unknown): boolean;
+    addFolder(inode: unknown): boolean;
+    createCase(inode: unknown): boolean;
+    assignType(inode: Inode, typeName: string): boolean | undefined;
+    viewPanels<K extends string | undefined = undefined>(inode: unknown, panelKey?: K): K extends string ? boolean : string[] | false;
+}>;
+export default _default;

package/core/providers/Inodes/utils/getUrl.d.ts

@@ -0,0 +1 @@
+export function getUrl(inodeOrToken: any): string | null;

package/core/providers/Inodes/utils/hasPermission.d.ts

@@ -0,0 +1,2 @@
+export default function hasPermission(inode: unknown, permission: string, defaultPermission?: boolean): boolean;
+export declare function immutableHasPermission(inode: unknown, permission: string, defaultPermission?: boolean): boolean;

package/core/providers/Inodes/utils/is.d.ts

@@ -0,0 +1,39 @@
+import { DOSSIER, FILE, FOLDER, TEMPLATE } from "../../../../core/constants/kinds";
+import { Inode, InodeStack } from "../types";
+export declare function isInodeKind(kind: string | undefined): boolean;
+export declare function isInode(inode: unknown): inode is Inode;
+export declare function isFolder(inode: unknown): inode is Inode<typeof FOLDER>;
+export declare function isDossier(inode: unknown): inode is Inode<typeof DOSSIER>;
+export declare function isTemplate(inode: unknown): inode is Inode<typeof TEMPLATE>;
+export declare function isDeleted(inode: unknown): inode is Inode;
+export declare function isFile(inode: unknown): inode is Inode<typeof FILE>;
+export declare function isReadableImage(inode: unknown): inode is Inode<typeof FILE> & {
+    mimeType: "jpeg" | "png" | "gif" | "bmp";
+};
+export declare function isPDF(inode: unknown): inode is Inode<typeof FILE> & {
+    mimeType: "application/pdf";
+};
+export declare function isXML(inode: unknown): inode is Inode<typeof FILE> & {
+    mimeType: "text/xml" | "application/xml";
+};
+export declare function isJSON(inode: unknown): inode is Inode<typeof FILE> & {
+    mimeType: "application/json";
+};
+export declare function isText(inode: unknown): inode is Inode<typeof FILE> & {
+    mimeType: "text/plain";
+};
+export declare function isInodeStack(inode: unknown): inode is InodeStack;
+export declare function isNotArchive(inode: unknown): inode is Inode & {
+    kind: typeof FILE;
+    uri: `${"neo4j"}${string}`;
+};
+declare const OFFICE_DOCUMENTS: string[];
+export declare function isAnOfficeDocument(inode: unknown): inode is Inode & {
+    kind: typeof FILE;
+    mimeType: (typeof OFFICE_DOCUMENTS)[number];
+};
+export declare function isDisplayableFile(inode: unknown): inode is Inode & {
+    kind: typeof FILE | typeof FOLDER | typeof DOSSIER;
+    mimeType: "application/pdf" | "jpeg" | "png" | "gif" | "bmp" | "text/xml" | "application/xml" | "application/json" | "text/plain" | (typeof OFFICE_DOCUMENTS)[number];
+};
+export {};

package/core/providers/Inodes/utils/isImmutable.d.ts

@@ -0,0 +1,15 @@
+import { ImmutableInode } from "../types";
+export declare function isImmutableInode(inode: unknown): inode is ImmutableInode;
+export declare function isImmutableFolder(inode: any): inode is ImmutableInode;
+export declare function isImmutableDossier(inode: any): inode is ImmutableInode;
+export declare function isImmutableTemplate(inode: any): inode is ImmutableInode;
+export declare function isImmutableDeleted(inode: any): inode is ImmutableInode;
+export declare function isImmutableFile(inode: any): inode is ImmutableInode;
+export declare function isImmutableReadableImage(inode: any): inode is ImmutableInode;
+export declare function isImmutablePDF(inode: any): inode is ImmutableInode;
+export declare function isImmutableXML(inode: any): inode is ImmutableInode;
+export declare function isImmutableJSON(inode: any): inode is ImmutableInode;
+export declare function isImmutableText(inode: any): inode is ImmutableInode;
+export declare function isImmutableNotArchive(inode: any): inode is ImmutableInode;
+export declare function isAnImmutableOfficeDocument(inode: any): inode is ImmutableInode;
+export declare function isImmutableDisplayableFile(inode: any): inode is ImmutableInode;

package/core/providers/Inodes/utils/resolveUnauthorizedInodes.d.ts

@@ -0,0 +1,11 @@
+import { Inode } from "../types";
+/**
+ * Resolves unauthorized inodes by adding the parentOid to the item.
+ * This is needed because the parentOid is not returned by the API for unauthorized inodes.
+ * It was causing the inodes to not be well rendered in the tree view.
+ * @param items The array of inodes
+ * @param parentOid The parentOid to add to the unauthorized inodes
+ * @returns The array of inodes with the parentOid added
+ */
+declare const resolveUnauthorizedInodes: (items: Inode[], parentOid: string) => Inode[];
+export default resolveUnauthorizedInodes;

package/core/providers/Inodes/utils/saveProperties.d.ts

@@ -0,0 +1,2 @@
+import { Inode, PropertyList } from "../types";
+export default function saveProperties(values: PropertyList, inodeOid: Inode["oid"]): void;

package/core/providers/Inodes/utils/sortByOrderingWeight.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sorts a particular key in each item by their ordering weights
+ * @param items The array of object
+ * @param keyToSort The key to sort in each item
+ */
+export declare function sortByOrderingWeight<T extends Record<string, any>, K extends keyof T>(items: T[], keyToSort: K): T[];

package/core/providers/Inspectors/Context.d.ts

@@ -0,0 +1,11 @@
+import { SupportedItem } from "../App/types";
+import { SidePanelInspectorDefinition } from "../Definitions/types";
+import { InspectorModule, InspectorModuleDefinition, InspectorProps } from "./types";
+type InspectorContextType = {
+    getModules: (item: SupportedItem, inspectorDefinitions: SidePanelInspectorDefinition[], rawItems: InspectorProps["rawItems"], scope: string | undefined) => InspectorModule[];
+    registerInspectors: (inspectors: InspectorModuleDefinition[]) => void;
+    activeTabName: string | undefined;
+    setActiveTabName: (name: string | undefined) => void;
+};
+declare const InspectorsContext: import("react").Context<InspectorContextType>;
+export default InspectorsContext;