import { isLocal } from '../models';
import { Element } from '../models/element';
import { ElementPrivileges, WorkRecordDataResponse } from '../services';
import { ReminderWrapper } from './calendar.interface';
import { ElementSchema, ElementType, ExternalFile, Template } from './editors.interface';
export type User = {
    uid: string;
    cn: string;
    sn: string;
};
export interface ElementTypePrivilegesList {
    count: number;
    'element-types': {
        id: string;
    }[];
    filters: {
        page: number;
        'per-page': number;
        'with-right': string;
    };
}
export interface CloneConfig {
    withFiles?: boolean;
    retainParent?: boolean;
}
export interface NativeFile {
    id?: string;
    uri: string;
    width?: number;
    height?: number;
    size?: number;
    name: string;
    mimeType?: string;
}
export interface BrowserFile {
    file: File;
}
export type PlatformFile = NativeFile | BrowserFile;
export interface LocalFile<T = PlatformFile> {
    data: T;
    id: string;
    isLoading?: boolean;
    extraData?: Record<string, string | boolean>;
}
export declare enum LinkRel {
    SELF_LOCAL = "self_local",
    SELF = "self",
    REMINDERS_LOCAL = "reminders_local",
    REMINDERS = "reminders",
    NAME_LOCAL = "name_local",
    NAME = "name",
    PARENT_LOCAL = "parent_local",
    PARENT = "parent",
    OWNER_LOCAL = "owner_local",
    OWNER = "owner",
    WORK = "work",
    AUTHOR_LOCAL = "author_local",
    AUTHOR = "author",
    REFRESH = "refresh",
    COMMENTS = "comments",
    COMMENTS_LOCAL = "comments_local",
    DOWNLOAD = "download"
}
export type eDocuImageSize = 'image-preview-720x360' | 'image-preview-360x360' | 'image-preview-w1536' | 'image-preview-w1024' | 'image-preview-w768' | 'image-preview-w480' | 'image-preview-m100' | 'download';
export type FormDataValue = string | number | string[] | [number, number] | undefined | null;
export type Operation = RemoveOperation | AddOperation | PlusOperation | ReplaceOperation;
export type JsonPatchOperation = RemoveOperation | AddOperation | ReplaceOperation;
export declare enum Operations {
    ADD = "add",
    REMOVE = "remove",
    PLUS = "plus",
    REPLACE = "replace"
}
export type ReplaceOperation = {
    op: Operations.REPLACE;
    path: string;
    value: NonNullable<FormDataValue> | null;
    inheritedFrom?: string;
    isPublic?: boolean;
};
export type RemoveOperation = {
    op: Operations.REMOVE;
    path: string;
    inheritedFrom?: string;
    isPublic?: boolean;
};
export type AddOperation = {
    op: Operations.ADD;
    path: string;
    value: NonNullable<FormDataValue> | null;
    inheritedFrom?: string;
    isPublic?: boolean;
};
export type PlusOperation = {
    op: Operations.PLUS;
    path: string;
    value: NonNullable<FormDataValue> | null;
    inheritedFrom?: string;
    isPublic?: boolean;
};
export interface RestApiLink {
    rel: LinkRel;
    href: string;
}
export type ElementMetaAttributes = {
    _type: ElementType;
    author?: User;
    hash: string;
    links?: RestApiLink[];
    organization: string;
    timestamp?: string;
    isPublic?: boolean;
    _element_parent?: AttributeData<AttributeValueTypeElement | Element | string>;
};
export type ElementAttributeData = Record<string, AttributeData | AttributeFileData>;
export type ElementData = ElementAttributeData & ElementMetaAttributes;
export type ElementFormData = {
    [attribute: string]: AttributeValue | AttributeFileData | undefined;
};
export type ElementFormDataWithoutFiles = {
    [attribute: string]: AttributeValue | undefined;
};
export type ElementsTypeData = {
    [type: string]: AttributeDefinitions;
};
export type ElementsTemplates = Map<string, Record<string, ElementTemplateV1>>;
export type ElementsPrivileges = Map<string, Record<string, ElementPrivileges>>;
export interface PreparedFiles<T = PlatformFile> {
    attribute: string | {
        hash: string;
        id: string;
    };
    value: LocalFile<T>[];
}
export declare enum ElementSchemaVersion {
    V1 = "v1",
    V2 = "v2"
}
export interface ElementRaw {
    children?: ElementDataWrapper[];
    childrenCount?: number;
    element: ElementData;
    parent?: ElementData;
    reminders?: Record<string, ReminderWrapper>;
    remindersCount?: number;
    workRecords?: WorkRecordDataResponse;
    workRecordsCount?: number;
    predecessors?: ElementDataWrapper[];
    predecessorsCount?: number;
    references?: Record<string, ElementData[]>;
    referencesCount?: number;
}
export interface ElementMembrane extends ElementRaw {
    visibilityException?: VisibilityException;
}
export interface GetElementV1Response extends ElementMembrane {
    schemaVersion: ElementSchemaVersion.V1;
    element_type: ElementTypeDefinition;
    template: ElementTemplateV1;
    mode: {
        state: string;
    };
}
export interface GetElementV2Response extends ElementMembrane {
    schemaVersion: ElementSchemaVersion.V2;
    schema: ElementSchema;
    template: Template;
}
export interface MembraneGetError {
    error: {
        code: string;
        description: string;
    };
}
export type ElementCreateData = {
    operations: Operation[];
    organization: {
        id: string;
    };
    parent?: {
        hash: string;
    };
    author?: {
        id: string;
    };
};
export type ElementBatchCreateData = ElementCreateData & {
    element: {
        type: string;
    };
};
export type StartChecklistData = {
    checklist: string;
    element: string;
    organization: string;
};
type WithRequired<T, K extends keyof T> = T & {
    [P in K]-?: T[P];
};
type ElementRawWithChildren = WithRequired<ElementRaw, 'children' | 'childrenCount'>;
export type StartChecklistResponse = {
    checklist: ElementRawWithChildren;
    record: ElementRawWithChildren;
};
export type FileBatchResponse = {
    'attribute-name': string;
    'is-public': boolean;
    hash: string;
    'file-name': string;
    'file-size': number;
    'is-relevant': boolean;
    'element-hash': string;
    links: RestApiLink[];
}[];
export type ElementDataWrapper = {
    element: ElementData;
};
export interface ElementTypeDefinition {
    _id: string;
    name: string;
    attributes: Record<string, AttributeDefinition>;
    actions: string[];
    positional: boolean;
}
export interface VisibilityException {
    visibilityAttr: string;
    attrs?: string | string[];
    nestedAttr?: {
        [key: string]: NestedAttrValue[];
    };
    _unsafeDisableHashMerging?: boolean;
    hideWorkrecords?: boolean;
    hiddenAttrs?: 'all' | string[];
}
export interface NestedAttrValue {
    types: string[];
    attrs: string[];
}
export type AttributeDefinition = {
    required?: boolean;
    type: string;
    order?: number;
    key: string;
    values?: string[];
    modifiable?: boolean;
    multiple?: boolean;
    query?: string;
    isModel?: boolean;
    isRelationData?: boolean;
    isRecurrence?: boolean;
    isExternalFile?: boolean;
    isTable?: boolean;
    tableDefinition?: string;
    ignoredAttributes?: string[];
    markdown?: boolean;
    useCheckbox?: boolean;
    hidden?: boolean;
    extraConfig?: Record<string, unknown>;
};
export type AttributeDefinitions = {
    [attribute: string]: AttributeDefinition;
};
export type AttributePrivileges = {
    [attribute: string]: string[];
};
export interface AttributeMeta {
    author?: User;
    organization?: string;
    timestamp?: string;
    isPublic?: boolean;
}
export interface AttributeData<T = AttributeValue> extends AttributeMeta {
    value: T;
}
export type AttributeFileData<T = PlatformFile> = (AttributeFileValue | LocalFile<T>)[];
export interface AttributeFileValue {
    file: {
        author: {
            cn: string;
            sn: string;
            uid: string;
        };
        comments: [];
        file_size: number;
        filename: string;
        hash: string;
        organization: string;
        relevant: boolean;
        timestamp: string;
        archived: boolean;
        extraData?: Record<string, string | boolean>;
        isPublic?: boolean;
    };
    links: RestApiLink[];
}
export interface AttributeValueTypeElement {
    element_name: AttributeData<string>;
    hash: string;
    _type: string;
    organization: string;
    timestamp?: string;
    author?: User;
    links?: RestApiLink[];
    updatedAt?: string;
    updatedBy?: User;
}
export type AttributeValueGeo = [number, number];
export type AttributeValueSingle = string | number | boolean | Date | AttributeValueTypeElement | Element | User | AttributeValueGeo;
export type AttributeValueMultiple = string[] | number[] | AttributeValueTypeElement[] | Element[] | User[];
export type AttributeValue = AttributeValueSingle | AttributeValueMultiple;
export type DehydratedAttributeValueSingle = string | number | boolean;
export type DehydratedAttributeValueMultiple = string[] | number[];
export type DehydratedAttributeValue = DehydratedAttributeValueSingle | DehydratedAttributeValueMultiple;
export type DehydratedElementAttributeData = Record<string, AttributeData<DehydratedAttributeValue> | AttributeFileData>;
export type DehydratedElementData = DehydratedElementAttributeData & ElementMetaAttributes;
export type DehydratedElementValues = Record<string, AttributeFileData<PlatformFile> | DehydratedAttributeValue>;
export type ILogicalOperator = '===' | '!==' | '!!' | '!' | 'CONTAINS' | 'IN' | 'NOTIN';
interface ShowHide {
    enabled: boolean;
    collapsed: boolean;
}
export interface ViewConfigCondition {
    attribute: string;
    comparsionOperator: ILogicalOperator;
    comparedValue: string | number;
}
export interface ConditionalViewConfig {
    type: 'default' | 'always' | 'custom' | 'collapsed';
    conditions?: {
        items: ViewConfigCondition[];
        logicalOperator: 'some' | 'every';
    };
}
export type ClusterAttribute = AttributeDefinition & {
    visibility: ConditionalViewConfig;
    tag?: string;
    directiveData?: string;
};
export interface ParsedDirective<T = unknown> {
    type: string;
    data: T;
    visibility: ConditionalViewConfig;
}
export interface AttributeGroup {
    url: string;
    id: string;
    header: string;
    row: number;
    x: number;
    width: number;
    attributes: ClusterAttribute[];
    styles: {
        center: boolean;
        border: number;
        radius: number;
        offset: number;
        aside: boolean;
        showHide: ShowHide;
        visibility: ConditionalViewConfig;
        collapse: ConditionalViewConfig;
    };
    directives: ParsedDirective[];
    data: Partial<ElementData>;
}
export interface ElementTemplateV1 {
    id: string;
    name: string;
    user: string;
    elementType: {
        id: string;
        name: string;
    };
    organization: string;
    state: string;
    created: Date;
    edited: Date;
    public: boolean;
    showHeader: boolean;
    styles: {
        headerColor: string;
        headerImage: {
            link: string;
            w: number;
            h: number;
        };
        primaryColor: string;
        secondaryColor: string;
        linkColor: string;
        backgroundColor: string;
        overridable: boolean;
        showControls: boolean;
        showBreadcrumbs: boolean;
        galleryMode: boolean;
        hideHeader: boolean;
        lighterPrimaryColor: string;
        darkerPrimaryColor: string;
        customCSS: string;
        forceOverride: boolean;
        customCSSRules: string;
    };
    attributes?: {
        [key: string]: {
            reactions: {
                colors: TemplateAttributeReactionValue[];
                suffix: TemplateAttributeReactionValue[];
                prefix: TemplateAttributeReactionValue[];
            };
            conditions: {
                conditions: ConditionalViewConfig['conditions'];
                id: string;
                type: 'custom' | 'always';
            }[];
        };
    };
    groups: AttributeGroup[];
}
export interface TemplateAttributeReactionValue {
    condition: string;
    value: string;
    type: number;
}
export type ComposedReactions = {
    prefix: string;
    suffix: string;
    colors: {
        attribute?: {
            value?: {
                ['background-color']?: string;
            };
        };
    };
};
export type ReactionCallback = (accu: ComposedReactions, reaction: TemplateAttributeReactionValue) => void;
export type ParsedCluster = AttributeGroup & {
    data: Partial<ElementData>;
    directives: ParsedDirective[];
};
export interface GoUrlsResponse {
    number: number;
    urls: string[];
}
export type DataSource = 'offline-cache' | 'backend' | 'local';
export declare const isRemoteFile: (file: unknown) => file is AttributeFileValue;
export declare const isExternalFile: (file: unknown) => file is ExternalFile;
export declare const isLocalFile: (file: unknown) => file is LocalFile;
export declare const isFileData: (files: unknown) => files is AttributeFileData;
export type LocalElement = Mixin<typeof isLocal>;
export declare const instanceOfLocalElement: (object: any) => object is LocalElement;
export declare class AccessDeniedError extends Error {
    constructor(message?: string);
}
export type AnyFunction<A = any> = (...input: any[]) => A;
export type Mixin<T extends AnyFunction> = InstanceType<ReturnType<T>>;
export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
export {};