@elek-io/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,816 @@
+import * as _elek_io_shared from '@elek-io/shared';
+import { ServiceType, ElekIoCoreOptions, BaseFile, GitTag, Sort, PaginatedList, FileType, FileReference, ExtendedCrudService, CreateGitTagProps, ReadGitTagProps, DeleteGitTagProps, ListGitTagsProps, CountGitTagsProps, UserFile, User, SetUserProps, GitInitOptions, GitCloneOptions, GitSwitchOptions, GitLogOptions, GitCommit, Asset, CreateAssetProps, ReadAssetProps, UpdateAssetProps, DeleteAssetProps, ListAssetsProps, CountAssetsProps, Collection, CreateCollectionProps, ReadCollectionProps, UpdateCollectionProps, DeleteCollectionProps, ListCollectionsProps, CountCollectionsProps, Value, CreateValueProps, ReadValueProps, UpdateValueProps, DeleteValueProps, ListValuesProps, CountValuesProps, ValidateValueProps, Entry, CreateEntryProps, ReadEntryProps, UpdateEntryProps, DeleteEntryProps, ListEntriesProps, CountEntriesProps, Project, CreateProjectProps, ReadProjectProps, UpdateProjectProps, UpgradeProjectProps, DeleteProjectProps, ListProjectsProps, ProjectExport, ConstructorElekIoCoreProps } from '@elek-io/shared';
+import { z } from 'zod';
+import { SpawnOptionsWithoutStdio } from 'child_process';
+import Fs from 'fs-extra';
+
+/**
+ * A base service that provides properties for most other services
+ */
+declare abstract class AbstractCrudService {
+    readonly type: ServiceType;
+    readonly options: ElekIoCoreOptions;
+    /**
+     * Dynamically generated git messages for operations
+     */
+    readonly gitMessage: {
+        create: string;
+        update: string;
+        delete: string;
+    };
+    /**
+     * Do not instantiate directly as this is an abstract class
+     */
+    protected constructor(type: ServiceType, options: ElekIoCoreOptions);
+    /**
+     * Returns the filtered, sorted and paginated version of given list
+     *
+     * @todo Sorting and filtering requires all models to be loaded
+     * from disk. This results in a huge memory spike before the
+     * filtering and pagination takes effect - removing most of it again.
+     * This approach is still better than returning everything and
+     * letting the frontend handle it, since the memory usage would then be constant.
+     * But this still could fill the memory limit of node.js (default 1,4 GB).
+     *
+     * @param list Array to filter, sort and paginate
+     * @param sort Array of sort objects containing information about what to sort and how
+     * @param filter Filter all object values of `list` by this string
+     * @param limit Limit the result to this amount. If 0 is given, no limit is applied
+     * @param offset Start at this index instead of 0
+     */
+    protected paginate<T extends BaseFile | GitTag>(list: T[], sort?: Sort<T>[], filter?: string, limit?: number, offset?: number): Promise<PaginatedList<T>>;
+    /**
+     * Returns a list of all file references of given project and type
+     *
+     * @param type File type of the references wanted
+     * @param projectId Project to get all asset references from
+     * @param collectionId Only needed when requesting files of type "Entry"
+     */
+    protected listReferences(type: FileType, projectId?: string, collectionId?: string): Promise<FileReference[]>;
+    private getFolderReferences;
+    /**
+     * Searches for all files inside given folder,
+     * parses their names and returns them as FileReference
+     *
+     * Ignores files not matching the [id].[language].[extension]
+     * or [id].[extension] format for their names
+     */
+    private getFileReferences;
+}
+
+/**
+ * Service that manages CRUD functionality for GitTags
+ */
+declare class GitTagService extends AbstractCrudService implements ExtendedCrudService<GitTag> {
+    private git;
+    constructor(options: ElekIoCoreOptions, git: GitService['git']);
+    /**
+     * Creates a new tag
+     *
+     * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---annotate
+     */
+    create(props: CreateGitTagProps): Promise<GitTag>;
+    /**
+     * Returns a tag by ID
+     *
+     * Internally uses list() with id as pattern.
+     */
+    read(props: ReadGitTagProps): Promise<GitTag>;
+    /**
+     * Updating a git tag is not supported.
+     * Please delete the old and create a new one
+     *
+     * @see https://git-scm.com/docs/git-tag#_on_re_tagging
+     */
+    update(): Promise<never>;
+    /**
+     * Deletes a tag
+     *
+     * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---delete
+     *
+     * @param path  Path to the repository
+     * @param id    UUID of the tag to delete
+     */
+    delete(props: DeleteGitTagProps): Promise<void>;
+    /**
+     * Gets all local tags or filter them by pattern
+     *
+     * They are sorted by authordate of the commit, not the timestamp the tag is created.
+     * This ensures tags are sorted correctly in the timeline of their commits.
+     *
+     * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---list
+     */
+    list(props: ListGitTagsProps): Promise<PaginatedList<GitTag>>;
+    /**
+     * Returns the total number of tags inside given repository
+     *
+     * Internally uses list(), so do not use count()
+     * in conjuncion with it to avoid multiple git calls.
+     *
+     * @param path Path to the repository
+     */
+    count(props: CountGitTagsProps): Promise<number>;
+    /**
+     * Type guard for GitTag
+     *
+     * @param obj The object to check
+     */
+    private isGitTag;
+}
+
+/**
+ * Service that manages CRUD functionality for JSON files on disk
+ */
+declare class JsonFileService extends AbstractCrudService {
+    private cache;
+    constructor(options: ElekIoCoreOptions);
+    /**
+     * Creates a new file on disk. Fails if path already exists
+     *
+     * @param data Data to write into the file
+     * @param path Path to write the file to
+     * @param schema Schema of the file to validate against
+     * @returns Validated content of the file from disk
+     */
+    create<T extends z.ZodType<BaseFile>>(data: unknown, path: string, schema: T): Promise<z.output<T>>;
+    /**
+     * Reads the content of a file on disk. Fails if path does not exist
+     *
+     * @param path Path to read the file from
+     * @param schema Schema of the file to validate against
+     * @returns Validated content of the file from disk
+     */
+    read<T extends z.ZodType<BaseFile | UserFile>>(path: string, schema: T): Promise<z.output<T>>;
+    /**
+     * Overwrites an existing file on disk
+     *
+     * @todo Check how to error out if the file does not exist already
+     *
+     * @param data Data to write into the file
+     * @param path Path to the file to overwrite
+     * @param schema Schema of the file to validate against
+     * @returns Validated content of the file from disk
+     */
+    update<T extends z.ZodType<BaseFile | UserFile>>(data: unknown, path: string, schema: T): Promise<z.output<T>>;
+    private serialize;
+    private deserialize;
+}
+
+/**
+ * Service that manages CRUD functionality for Asset files on disk
+ */
+declare class UserService {
+    private readonly jsonFileService;
+    constructor(jsonFileService: JsonFileService);
+    /**
+     * Returns the User currently working with Core
+     */
+    get(): Promise<User | undefined>;
+    /**
+     * Sets the User currently working with Core
+     *
+     * By doing so all git operations are done with the signature of this User
+     */
+    set(props: SetUserProps): Promise<User>;
+}
+
+/**
+ * Service that manages Git functionality
+ *
+ * Uses dugite Node.js bindings for Git to be fully compatible
+ * and be able to leverage Git LFS functionality
+ * @see https://github.com/desktop/dugite
+ *
+ * Heavily inspired by the GitHub Desktop app
+ * @see https://github.com/desktop/desktop
+ *
+ * Git operations are sequential!
+ * We use a FIFO queue to translate async calls
+ * into a sequence of git operations
+ */
+declare class GitService {
+    private version;
+    private queue;
+    private gitTagService;
+    private userService;
+    constructor(options: ElekIoCoreOptions, userService: UserService);
+    /**
+     * CRUD methods to work with git tags
+     */
+    get tags(): GitTagService;
+    /**
+     * Reads the currently used version of Git
+     */
+    getVersion(): Promise<void>;
+    /**
+     * Create an empty Git repository or reinitialize an existing one
+     *
+     * @see https://git-scm.com/docs/git-init
+     *
+     * @param path    Path to initialize in. Fails if path does not exist
+     * @param options Options specific to the init operation
+     */
+    init(path: string, options?: Partial<GitInitOptions>): Promise<void>;
+    /**
+     * Clone a repository into a directory
+     *
+     * @see https://git-scm.com/docs/git-clone
+     *
+     * @todo Implement progress callback / events
+     *
+     * @param url     The remote repository URL to clone from
+     * @param path    The destination path for the cloned repository.
+     *                Which is only working if the directory is existing and empty.
+     * @param options Options specific to the clone operation
+     */
+    clone(url: string, path: string, options?: Partial<GitCloneOptions>): Promise<void>;
+    /**
+     * Add file contents to the index
+     *
+     * @see https://git-scm.com/docs/git-add
+     *
+     * @param path  Path to the repository
+     * @param files Files to add
+     */
+    add(path: string, files: string[]): Promise<void>;
+    /**
+     * Switch branches
+     *
+     * @see https://git-scm.com/docs/git-switch/
+     *
+     * @param path    Path to the repository
+     * @param name    Name of the branch to switch to
+     * @param options Options specific to the switch operation
+     */
+    switch(path: string, name: string, options?: Partial<GitSwitchOptions>): Promise<void>;
+    /**
+     * Reset current HEAD to the specified state
+     *
+     * @todo maybe add more options
+     * @see https://git-scm.com/docs/git-reset
+     *
+     * @param path    Path to the repository
+     * @param mode    Modifies the working tree depending on given mode
+     * @param commit  Resets the current branch head to this commit / tag
+     */
+    reset(path: string, mode: 'soft' | 'hard', commit: string): Promise<void>;
+    /**
+     * Restore working tree files
+     *
+     * @see https://git-scm.com/docs/git-restore/
+     *
+     * @todo It's probably a good idea to not use restore
+     * for a use case where someone just wants to have a look
+     * and maybe copy something from a deleted file.
+     * We should use `checkout` without `add .` and `commit` for that
+     *
+     * @param path    Path to the repository
+     * @param source  Git commit SHA or tag name to restore to
+     * @param files   Files to restore
+     */
+    /**
+     * Fetch from and integrate with another repository or a local branch
+     *
+     * @see https://git-scm.com/docs/git-pull
+     *
+     * @param path Path to the repository
+     */
+    pull(path: string): Promise<void>;
+    /**
+     * Record changes to the repository
+     *
+     * @see https://git-scm.com/docs/git-commit
+     *
+     * @param path    Path to the repository
+     * @param message A message that describes the changes
+     */
+    commit(path: string, message: string): Promise<void>;
+    /**
+     * Gets local commit history
+     *
+     * @see https://git-scm.com/docs/git-log
+     *
+     * @todo Check if there is a need to trim the git commit message of chars
+     * @todo Use this method in a service. Decide if we need a HistoryService for example
+     *
+     * @param path    Path to the repository
+     * @param options Options specific to the log operation
+     */
+    log(path: string, options?: Partial<GitLogOptions>): Promise<GitCommit[]>;
+    refNameToTagName(refName: string): string | undefined;
+    /**
+     * Returns a timestamp of given files creation
+     *
+     * Git only returns the timestamp the file was added,
+     * which could be different from the file being created.
+     * But since file operations will always be committed
+     * immediately, this is practically the same.
+     *
+     * @param path Path to the repository
+     * @param file File to get timestamp from
+     */
+    getFileCreatedTimestamp(path: string, file: string): Promise<number>;
+    /**
+     * Returns a timestamp of the files last modification
+     *
+     * @param path Path to the repository
+     * @param file File to get timestamp from
+     */
+    getFileLastUpdatedTimestamp(path: string, file: string): Promise<number>;
+    /**
+     * Returns created and updated timestamps from given file
+     *
+     * @param path Path to the project
+     * @param file Path to the file
+     */
+    getFileCreatedUpdatedMeta(path: string, file: string): Promise<{
+        created: number;
+        updated: number;
+    }>;
+    /**
+     * A reference is used in Git to specify branches and tags.
+     * This method checks if given name matches the required format
+     *
+     * @see https://git-scm.com/docs/git-check-ref-format
+     *
+     * @param path Path to the repository
+     * @param name Name to check
+     */
+    private checkBranchOrTagName;
+    /**
+     * Installs LFS support and starts tracking
+     * all files inside the lfs folder
+     *
+     * @param path Path to the repository
+     */
+    private installLfs;
+    /**
+     * Sets the git config of given local repository from ElekIoCoreOptions
+     *
+     * @param path Path to the repository
+     */
+    private setLocalConfig;
+    /**
+     * Type guard for GitCommit
+     *
+     * @param obj The object to check
+     */
+    private isGitCommit;
+    /**
+     * Wraps the execution of any git command
+     * to use a FIFO queue for sequential processing
+     *
+     * @param path Path to the repository
+     * @param args Arguments to append after the `git` command
+     */
+    private git;
+}
+
+/**
+ * Service that manages CRUD functionality for Asset files on disk
+ */
+declare class AssetService extends AbstractCrudService implements ExtendedCrudService<Asset> {
+    private readonly jsonFileService;
+    private readonly gitService;
+    constructor(options: ElekIoCoreOptions, jsonFileService: JsonFileService, gitService: GitService);
+    /**
+     * Creates a new Asset
+     */
+    create(props: CreateAssetProps): Promise<Asset>;
+    /**
+     * Returns an Asset by ID and language
+     */
+    read(props: ReadAssetProps): Promise<Asset>;
+    /**
+     * Updates given Asset
+     *
+     * Use the optional "newFilePath" prop to update the Asset itself
+     */
+    update(props: UpdateAssetProps): Promise<Asset>;
+    /**
+     * Deletes given Asset
+     */
+    delete(props: DeleteAssetProps): Promise<void>;
+    list(props: ListAssetsProps): Promise<PaginatedList<Asset>>;
+    count(props: CountAssetsProps): Promise<number>;
+    /**
+     * Checks if given object is of type Asset
+     */
+    isAsset(obj: BaseFile | unknown): obj is Asset;
+    /**
+     * Returns the size of an Asset in bytes
+     *
+     * @param path Path of the Asset to get the size from
+     */
+    private getAssetSize;
+    /**
+     * Creates an Asset from given AssetFile
+     *
+     * @param projectId   The project's ID
+     * @param assetFile   The AssetFile to convert
+     */
+    private toAsset;
+    /**
+     * Returns the found and supported extension as well as mime type,
+     * otherwise throws an error
+     *
+     * @param filePath Path to the file to check
+     */
+    private getSupportedFileTypeOrThrow;
+}
+
+/**
+ * Service that manages CRUD functionality for Collection files on disk
+ */
+declare class CollectionService extends AbstractCrudService implements ExtendedCrudService<Collection> {
+    private jsonFileService;
+    private gitService;
+    constructor(options: ElekIoCoreOptions, jsonFileService: JsonFileService, gitService: GitService);
+    /**
+     * Creates a new Collection
+     */
+    create(props: CreateCollectionProps): Promise<Collection>;
+    /**
+     * Returns a Collection by ID
+     */
+    read(props: ReadCollectionProps): Promise<Collection>;
+    /**
+     * Updates given Collection
+     *
+     * @todo finish implementing checks for FieldDefinitions and extract methods
+     *
+     * @param projectId   Project ID of the collection to update
+     * @param collection  Collection to write to disk
+     * @returns           An object containing information about the actions needed to be taken,
+     *                    before given update can be executed or void if the update was executed successfully
+     */
+    update(props: UpdateCollectionProps): Promise<Collection>;
+    /**
+     * Deletes given Collection (folder), including it's items
+     *
+     * The Fields that Collection used are not deleted.
+     */
+    delete(props: DeleteCollectionProps): Promise<void>;
+    list(props: ListCollectionsProps): Promise<PaginatedList<Collection>>;
+    count(props: CountCollectionsProps): Promise<number>;
+    /**
+     * Checks if given object is of type Collection
+     */
+    isCollection(obj: BaseFile | unknown): obj is Collection;
+}
+
+/**
+ * Service that manages CRUD functionality for Value files on disk
+ */
+declare class ValueService extends AbstractCrudService implements ExtendedCrudService<Value> {
+    private jsonFileService;
+    private gitService;
+    constructor(options: ElekIoCoreOptions, jsonFileService: JsonFileService, gitService: GitService, assetService: AssetService);
+    /**
+     * Creates a new Value
+     */
+    create(props: CreateValueProps): Promise<Value>;
+    /**
+     * Returns a Value by ID and language
+     */
+    read(props: ReadValueProps): Promise<Value>;
+    /**
+     * Updates given Value
+     */
+    update(props: UpdateValueProps): Promise<Value>;
+    /**
+     * Deletes given Value
+     */
+    delete(props: DeleteValueProps): Promise<void>;
+    list(props: ListValuesProps): Promise<PaginatedList<Value>>;
+    count(props: CountValuesProps): Promise<number>;
+    /**
+     * Checks if given object is of type Value
+     */
+    isValue(obj: BaseFile | unknown): obj is Value;
+    /**
+     * Reads the given Value from disk and validates it against the ValueDefinition
+     */
+    validate(props: ValidateValueProps): Promise<_elek_io_shared.SafeParseSuccess<string | undefined> | _elek_io_shared.SafeParseSuccess<number | undefined> | _elek_io_shared.SafeParseError<boolean> | _elek_io_shared.SafeParseSuccess<boolean | undefined>>;
+}
+
+/**
+ * Service that manages CRUD functionality for Entry files on disk
+ */
+declare class EntryService extends AbstractCrudService implements ExtendedCrudService<Entry> {
+    private jsonFileService;
+    private gitService;
+    private collectionService;
+    private valueService;
+    constructor(options: ElekIoCoreOptions, jsonFileService: JsonFileService, gitService: GitService, collectionService: CollectionService, valueService: ValueService);
+    /**
+     * Creates a new Entry
+     */
+    create(props: CreateEntryProps): Promise<Entry>;
+    /**
+     * Returns an Entry by ID and language
+     */
+    read(props: ReadEntryProps): Promise<Entry>;
+    /**
+     * Updates Entry with given ValueReferences
+     */
+    update(props: UpdateEntryProps): Promise<Entry>;
+    /**
+     * Deletes given Entry
+     */
+    delete(props: DeleteEntryProps): Promise<void>;
+    list(props: ListEntriesProps): Promise<_elek_io_shared.PaginatedList<{
+        id: string;
+        fileType: "entry";
+        created: number;
+        language: "bg" | "cs" | "da" | "de" | "el" | "en" | "es" | "et" | "fi" | "fr" | "hu" | "it" | "ja" | "lt" | "lv" | "nl" | "pl" | "pt" | "ro" | "ru" | "sk" | "sl" | "sv" | "zh";
+        valueReferences: {
+            definitionId: string;
+            references: {
+                id: string;
+                language: "bg" | "cs" | "da" | "de" | "el" | "en" | "es" | "et" | "fi" | "fr" | "hu" | "it" | "ja" | "lt" | "lv" | "nl" | "pl" | "pt" | "ro" | "ru" | "sk" | "sl" | "sv" | "zh";
+            };
+        }[];
+        updated?: number | undefined;
+    }>>;
+    count(props: CountEntriesProps): Promise<number>;
+    /**
+     * Checks if given object of Collection, CollectionItem,
+     * Field, Project or Asset is of type CollectionItem
+     */
+    isEntry(obj: BaseFile | unknown): obj is Entry;
+    /**
+     * Validates referenced Values against the Collections definition
+     *
+     * @todo should probably return all errors occurring during parsing instead of throwing
+     */
+    private validateValueReferences;
+}
+
+/**
+ * Service that queries other services for data to search
+ *
+ * @todo refactor for the new Services
+ */
+declare class SearchService extends AbstractCrudService {
+    private assetService;
+    private collectionService;
+    constructor(options: ElekIoCoreOptions, assetService: AssetService, collectionService: CollectionService);
+    /**
+     * Search all models inside the project for given query
+     *
+     * @todo Implement SearchOptions parameter
+     *
+     * @param project Project to search in
+     * @param query Query to search for
+     */
+    search(projectId: string, query: string, fileType?: FileType): Promise<{
+        type: "value" | "project" | "asset" | "collection" | "entry";
+        id: string;
+        name: string;
+        matches: {
+            key: string;
+            prefix: string;
+            match: string;
+            suffix: string;
+        }[];
+        language?: "bg" | "cs" | "da" | "de" | "el" | "en" | "es" | "et" | "fi" | "fr" | "hu" | "it" | "ja" | "lt" | "lv" | "nl" | "pl" | "pt" | "ro" | "ru" | "sk" | "sl" | "sv" | "zh" | undefined;
+    }[]>;
+    private truncate;
+}
+
+/**
+ * Service that manages CRUD functionality for Project files on disk
+ */
+declare class ProjectService extends AbstractCrudService implements ExtendedCrudService<Project> {
+    private jsonFileService;
+    private userService;
+    private gitService;
+    private searchService;
+    private assetService;
+    private collectionService;
+    private entryService;
+    private valueService;
+    constructor(options: ElekIoCoreOptions, jsonFileService: JsonFileService, userService: UserService, gitService: GitService, searchService: SearchService, assetService: AssetService, collectionService: CollectionService, entryService: EntryService, valueService: ValueService);
+    /**
+     * Creates a new Project
+     */
+    create(props: CreateProjectProps): Promise<Project>;
+    /**
+     * Returns a Project by ID
+     */
+    read(props: ReadProjectProps): Promise<Project>;
+    /**
+     * Updates given Project
+     */
+    update(props: UpdateProjectProps): Promise<Project>;
+    /**
+     * Upgrades given Project to the latest version of this client
+     *
+     * Needed when a new core version is requiring changes to existing files or structure.
+     *
+     * @todo Find out why using this.snapshotService is throwing isObjWithKeyAndValueOfString of undefined error in gitService (maybe binding issue)
+     */
+    upgrade(props: UpgradeProjectProps): Promise<void>;
+    /**
+     * Deletes given Project
+     *
+     * Deletes the whole Project folder including the history, not only the config file.
+     * Use with caution, since a Project that is only available locally could be lost forever.
+     * Or changes that are not pushed to a remote yet, will be lost too.
+     */
+    delete(props: DeleteProjectProps): Promise<void>;
+    list(props?: ListProjectsProps): Promise<PaginatedList<Project>>;
+    count(): Promise<number>;
+    /**
+     * Search all models inside the project for given query
+     *
+     * @param projectId Project ID to search in
+     * @param query     Query to search for
+     * @param type      (Optional) specify the type to search for
+     */
+    search(projectId: string, query: string, type?: FileType): Promise<{
+        type: "value" | "project" | "asset" | "collection" | "entry";
+        id: string;
+        name: string;
+        matches: {
+            key: string;
+            prefix: string;
+            match: string;
+            suffix: string;
+        }[];
+        language?: "bg" | "cs" | "da" | "de" | "el" | "en" | "es" | "et" | "fi" | "fr" | "hu" | "it" | "ja" | "lt" | "lv" | "nl" | "pl" | "pt" | "ro" | "ru" | "sk" | "sl" | "sv" | "zh" | undefined;
+    }[]>;
+    /**
+     * Checks if given object is of type Project
+     */
+    isProject(obj: BaseFile | unknown): obj is Project;
+    /**
+     * Exports given Project to JSON
+     *
+     * @todo performance tests
+     * @todo add progress callback
+     */
+    exportToJson(projectId: string): Promise<ProjectExport>;
+    /**
+     * Creates the projects folder structure and makes sure to
+     * write empty .gitkeep files inside them to ensure they are
+     * committed
+     */
+    private createFolderStructure;
+    /**
+     * Writes the Projects main .gitignore file to disk
+     *
+     * @todo Add general things to ignore
+     * @see https://github.com/github/gitignore/tree/master/Global
+     */
+    private createGitignore;
+}
+
+/**
+ * The directory in which everything is stored and will be worked in
+ *
+ * @todo make the workingDirectory an elek option to be set via app.getPath('home') (electron instead of node)?
+ */
+declare const workingDirectory: string;
+/**
+ * A collection of often used paths
+ */
+declare const pathTo: {
+    tmp: string;
+    userFile: string;
+    projects: string;
+    project: (projectId: string) => string;
+    projectFile: (projectId: string) => string;
+    lfs: (projectId: string) => string;
+    collections: (projectId: string) => string;
+    collection: (projectId: string, id: string) => string;
+    collectionFile: (projectId: string, id: string) => string;
+    entries: (projectId: string, collectionId: string) => string;
+    entryFile: (projectId: string, collectionId: string, id: string, language: string) => string;
+    values: (projectId: string) => string;
+    valueFile: (projectId: string, id: string, language: string) => string;
+    assets: (projectId: string) => string;
+    assetFile: (projectId: string, id: string, language: string) => string;
+    asset: (projectId: string, id: string, language: string, extension: string) => string;
+};
+/**
+ * Searches for a potential project ID in given path string and returns it
+ *
+ * Mainly used for logging inside the GitService, where we don't have a project ID,
+ * but always have a path which could contain one. The ID is then used,
+ * to log to the current project log, instead of logging to the main log file.
+ *
+ * @todo I really dont like this and I do not know how much performance we loose here
+ */
+declare const fromPath: {
+    projectId: (path: string) => string | undefined;
+};
+/**
+ * Returns a complete default type, hydrated with the partials of value
+ */
+declare function assignDefaultIfMissing<T extends {}>(value: Partial<T> | undefined | null, defaultsTo: T): T;
+/**
+ * Used as parameter for filter() methods to assure,
+ * only values not null, undefined or empty strings are returned
+ *
+ * @param value Value to check
+ */
+declare function notEmpty<T>(value: T | null | undefined): value is T;
+declare function isNoError<T>(item: T | Error): item is T;
+/**
+ * Basically a Promise.all() without rejecting if one promise fails to resolve
+ */
+declare function returnResolved<T>(promises: Promise<T>[]): Promise<Awaited<T>[]>;
+/**
+ * Custom async typescript ready implementation of Node.js child_process
+ *
+ * @see https://nodejs.org/api/child_process.html
+ * @see https://github.com/ralphtheninja/await-spawn
+ */
+declare function spawnChildProcess(command: string, args: ReadonlyArray<string>, options?: SpawnOptionsWithoutStdio): Promise<string>;
+/**
+ * Returns all folders of given path
+ */
+declare function folders(path: string): Promise<Fs.Dirent[]>;
+/**
+ * Returns all files of given path which can be filtered by extension
+ */
+declare function files(path: string, extension?: string): Promise<Fs.Dirent[]>;
+/**
+ * Returns the relative path for given path
+ * by stripping out everything up to the working directory
+ */
+declare function getRelativePath(path: string): string;
+/**
+ * Searches given array of objects for duplicates of given key and returns them
+ *
+ * @param arr Array with possible duplicate values
+ * @param key Key of object T to get duplicates of
+ */
+declare function getDuplicates<T>(arr: T[], key: keyof T): T[];
+
+declare const CoreUtil_assignDefaultIfMissing: typeof assignDefaultIfMissing;
+declare const CoreUtil_files: typeof files;
+declare const CoreUtil_folders: typeof folders;
+declare const CoreUtil_fromPath: typeof fromPath;
+declare const CoreUtil_getDuplicates: typeof getDuplicates;
+declare const CoreUtil_getRelativePath: typeof getRelativePath;
+declare const CoreUtil_isNoError: typeof isNoError;
+declare const CoreUtil_notEmpty: typeof notEmpty;
+declare const CoreUtil_pathTo: typeof pathTo;
+declare const CoreUtil_returnResolved: typeof returnResolved;
+declare const CoreUtil_spawnChildProcess: typeof spawnChildProcess;
+declare const CoreUtil_workingDirectory: typeof workingDirectory;
+declare namespace CoreUtil {
+  export { CoreUtil_assignDefaultIfMissing as assignDefaultIfMissing, CoreUtil_files as files, CoreUtil_folders as folders, CoreUtil_fromPath as fromPath, CoreUtil_getDuplicates as getDuplicates, CoreUtil_getRelativePath as getRelativePath, CoreUtil_isNoError as isNoError, CoreUtil_notEmpty as notEmpty, CoreUtil_pathTo as pathTo, CoreUtil_returnResolved as returnResolved, CoreUtil_spawnChildProcess as spawnChildProcess, CoreUtil_workingDirectory as workingDirectory };
+}
+
+/**
+ * elek.io Core
+ *
+ * Provides access to all services Core is offering
+ */
+declare class ElekIoCore {
+    private readonly options;
+    private readonly userService;
+    private readonly gitService;
+    private readonly jsonFileService;
+    private readonly assetService;
+    private readonly searchService;
+    private readonly projectService;
+    private readonly collectionService;
+    private readonly entryService;
+    private readonly valueService;
+    constructor(props?: ConstructorElekIoCoreProps);
+    /**
+     * Utility / helper functions
+     */
+    get util(): typeof CoreUtil;
+    /**
+     *
+     */
+    get user(): UserService;
+    /**
+     * CRUD methods to work with Projects
+     */
+    get projects(): ProjectService;
+    /**
+     * CRUD methods to work with Assets
+     */
+    get assets(): AssetService;
+    /**
+     * CRUD methods to work with Collections
+     */
+    get collections(): CollectionService;
+    /**
+     * CRUD methods to work with Entries
+     */
+    get entries(): EntryService;
+    /**
+     * CRUD methods to work with Values
+     */
+    get values(): ValueService;
+}
+
+export { ElekIoCore as default };