@ember-nexus/app-core 0.0.1 → 0.0.2

package/dist/types/Service/ApiWrapper.d.ts

@@ -0,0 +1,242 @@
+import { ElementCache, ElementChildrenCache, ElementParentsCache, ElementRelatedCache, IndexCache } from '../Cache/index.js';
+import { DeleteElementEndpoint, GetElementChildrenEndpoint, GetElementEndpoint, GetElementParentsEndpoint, GetElementRelatedEndpoint, GetIndexEndpoint, PatchElementEndpoint, PostElementEndpoint, PostIndexEndpoint, PutElementEndpoint } from '../Endpoint/Element/index.js';
+import { DeleteTokenEndpoint, GetMeEndpoint, GetTokenEndpoint, PostChangePasswordEndpoint, PostRegisterEndpoint, PostTokenEndpoint } from '../Endpoint/User/index.js';
+import { ServiceResolver } from '../Service/index.js';
+import { Collection, Data, Node, NodeWithOptionalId, Relation, RelationWithOptionalId, Token, UniqueUserIdentifier, Uuid } from '../Type/Definition/index.js';
+import { ServiceIdentifier } from '../Type/Enum/index.js';
+declare class ApiWrapper {
+    private getElementEndpoint;
+    private getElementChildrenEndpoint;
+    private getElementParentsEndpoint;
+    private getElementRelatedEndpoint;
+    private getIndexEndpoint;
+    private postIndexEndpoint;
+    private postElementEndpoint;
+    private putElementEndpoint;
+    private patchElementEndpoint;
+    private deleteElementEndpoint;
+    private postRegisterEndpoint;
+    private postChangePasswordEndpoint;
+    private getMeEndpoint;
+    private postTokenEndpoint;
+    private getTokenEndpoint;
+    private deleteTokenEndpoint;
+    private elementCache;
+    private elementChildrenCache;
+    private elementParentsCache;
+    private elementRelatedCache;
+    private indexCache;
+    static identifier: ServiceIdentifier;
+    constructor(getElementEndpoint: GetElementEndpoint, getElementChildrenEndpoint: GetElementChildrenEndpoint, getElementParentsEndpoint: GetElementParentsEndpoint, getElementRelatedEndpoint: GetElementRelatedEndpoint, getIndexEndpoint: GetIndexEndpoint, postIndexEndpoint: PostIndexEndpoint, postElementEndpoint: PostElementEndpoint, putElementEndpoint: PutElementEndpoint, patchElementEndpoint: PatchElementEndpoint, deleteElementEndpoint: DeleteElementEndpoint, postRegisterEndpoint: PostRegisterEndpoint, postChangePasswordEndpoint: PostChangePasswordEndpoint, getMeEndpoint: GetMeEndpoint, postTokenEndpoint: PostTokenEndpoint, getTokenEndpoint: GetTokenEndpoint, deleteTokenEndpoint: DeleteTokenEndpoint, elementCache: ElementCache, elementChildrenCache: ElementChildrenCache, elementParentsCache: ElementParentsCache, elementRelatedCache: ElementRelatedCache, indexCache: IndexCache);
+    static constructFromServiceResolver(serviceResolver: ServiceResolver): ApiWrapper;
+    /**
+     * Returns a node or relation by its identifier.
+     *
+     * If cached, the element is returned immediately. Otherwise, it is fetched via the API.
+     * The element cache is always kept in sync with the latest local state.
+     *
+     * Set the `forceLoad` flag to `true` to force an API request, bypassing the cache.
+     *
+     * @example
+     * ```ts
+     * const apiWrapper = serviceResolver.getServiceOrFail<ApiWrapper>(ApiWrapper.identifier);
+     * const element = await apiWrapper.getElement('56cca4fa-b270-45ca-8209-845368e7fc07');
+     * ```
+     *
+     * @see [Ember Nexus API: Get element endpoint](https://ember-nexus.github.io/api/#/api-endpoints/element/get-element)
+     */
+    getElement(elementId: Uuid, { forceLoad, }?: {
+        forceLoad?: boolean;
+    }): Promise<Node | Relation>;
+    /**
+     * Returns all children of a parent node and all relations between the parent node and them by specifying the parent
+     * identifier. Data is returned as a paginated collection object.
+     *
+     * If cached, the collection is returned immediately. Otherwise, it is fetched via the API.
+     * The collection cache might contain outdated local state.
+     *
+     * Set the `forceLoad` flag to `true` to force an API request, bypassing the cache.
+     *
+     * @example
+     * ```ts
+     * const apiWrapper = serviceResolver.getServiceOrFail<ApiWrapper>(ApiWrapper.identifier);
+     * const collection = await apiWrapper.getElementChildren('56cca4fa-b270-45ca-8209-845368e7fc07');
+     * ```
+     *
+     * @see [Ember Nexus API: Get element children endpoint](https://ember-nexus.github.io/api/#/api-endpoints/element/get-children)
+     */
+    getElementChildren(parentId: Uuid, { page, pageSize, forceLoad, }?: {
+        page?: number;
+        pageSize?: number;
+        forceLoad?: boolean;
+    }): Promise<Collection>;
+    /**
+     * Returns all parents of a child node and all relations between the child node and them by specifying the child
+     * identifier. Data is returned as a paginated collection object.
+     *
+     * If cached, the collection is returned immediately. Otherwise, it is fetched via the API.
+     * The collection cache might contain outdated local state.
+     *
+     * Set the `forceLoad` flag to `true` to force an API request, bypassing the cache.
+     *
+     * @example
+     * ```ts
+     * const apiWrapper = serviceResolver.getServiceOrFail<ApiWrapper>(ApiWrapper.identifier);
+     * const collection = await apiWrapper.getElementParents('56cca4fa-b270-45ca-8209-845368e7fc07');
+     * ```
+     *
+     * @see [Ember Nexus API: Get element parents endpoint](https://ember-nexus.github.io/api/#/api-endpoints/element/get-parents)
+     */
+    getElementParents(childId: Uuid, { page, pageSize, forceLoad, }?: {
+        page?: number;
+        pageSize?: number;
+        forceLoad?: boolean;
+    }): Promise<Collection>;
+    /**
+     * Returns all related nodes of a central node and all relations between the central node and them by specifying the
+     * central identifier. Data is returned as a paginated collection object.
+     *
+     * If cached, the collection is returned immediately. Otherwise, it is fetched via the API.
+     * The collection cache might contain outdated local state.
+     *
+     * Set the `forceLoad` flag to `true` to force an API request, bypassing the cache.
+     *
+     * @example
+     * ```ts
+     * const apiWrapper = serviceResolver.getServiceOrFail<ApiWrapper>(ApiWrapper.identifier);
+     * const collection = await apiWrapper.getElementRelated('56cca4fa-b270-45ca-8209-845368e7fc07');
+     * ```
+     *
+     * @see [Ember Nexus API: Get element related endpoint](https://ember-nexus.github.io/api/#/api-endpoints/element/get-related)
+     */
+    getElementRelated(centerId: Uuid, { page, pageSize, forceLoad, }?: {
+        page?: number;
+        pageSize?: number;
+        forceLoad?: boolean;
+    }): Promise<Collection>;
+    /**
+     * Returns all nodes on the root level.
+     * As this collection only returns nodes, no relations will be returned. Data is returned as a paginated collection
+     * object.
+     *
+     * If cached, the collection is returned immediately. Otherwise, it is fetched via the API.
+     * The collection cache might contain outdated local state.
+     *
+     * Set the `forceLoad` flag to `true` to force an API request, bypassing the cache.
+     *
+     * @example
+     * ```ts
+     * const apiWrapper = serviceResolver.getServiceOrFail<ApiWrapper>(ApiWrapper.identifier);
+     * const collection = await apiWrapper.getIndex();
+     * ```
+     *
+     * @see [Ember Nexus API: Get index endpoint](https://ember-nexus.github.io/api/#/api-endpoints/element/get-index)
+     */
+    getIndex({ page, pageSize, forceLoad, }?: {
+        page?: number;
+        pageSize?: number;
+        forceLoad?: boolean;
+    }): Promise<Collection>;
+    /**
+     * Creates a new node or relation.
+     *
+     * If the created element is a node, it will become part of the root level, i.e. returned by the get index endpoint.
+     * Relations, on the other hand, will be created between their start and end nodes.
+     *
+     * @example
+     * ```ts
+     * const apiWrapper = serviceResolver.getServiceOrFail<ApiWrapper>(ApiWrapper.identifier);
+     * const nodeId = await apiWrapper.postIndex({
+     *   type: 'Data',
+     *   data: {
+     *     some: 'data'
+     *   }
+     * });
+     * ```
+     *
+     * @see [Ember Nexus API: Create root level element endpoint](https://ember-nexus.github.io/api/#/api-endpoints/element/post-index)
+     */
+    postIndex(element: NodeWithOptionalId | RelationWithOptionalId): Promise<Uuid>;
+    /**
+     * Creates a new node.
+     *
+     * The created node will be saved as a child of the referenced parent node.
+     *
+     * **Note**: This endpoint can not be used to create relations, as relations can not be the child of some parent.
+     *
+     * @example
+     * ```ts
+     * const apiWrapper = serviceResolver.getServiceOrFail<ApiWrapper>(ApiWrapper.identifier);
+     * const nodeId = await apiWrapper.postElement(
+     *   '3175a7a0-b510-4554-94b0-242badcf0d32',
+     *   {
+     *     type: 'Data',
+     *     data: {
+     *       some: 'data'
+     *     }
+     *   }
+     * );
+     * ```
+     *
+     * @see [Ember Nexus API: Create element endpoint](https://ember-nexus.github.io/api/#/api-endpoints/element/post-element)
+     */
+    postElement(parentId: Uuid, element: NodeWithOptionalId): Promise<Uuid>;
+    /**
+     * Replaces an element's data.
+     *
+     * The provided data will replace the element's existing data.
+     *
+     * @example
+     * ```ts
+     * const apiWrapper = serviceResolver.getServiceOrFail<ApiWrapper>(ApiWrapper.identifier);
+     * await apiWrapper.putElement(
+     *   'a22b1d7c-5970-4d93-8e86-f6a6f01ca172',
+     *   {
+     *     some: 'new data'
+     *   }
+     * );
+     * ```
+     *
+     * @see [Ember Nexus API: Replace element endpoint](https://ember-nexus.github.io/api/#/api-endpoints/element/put-element)
+     */
+    putElement(elementId: Uuid, data: Data): Promise<void>;
+    /**
+     * Updates an element.
+     *
+     * The provided data will be appended to the element's existing data. Existing properties will be overwritten if the
+     * new data contains identical property keys.
+     *
+     * @example
+     * ```ts
+     * const apiWrapper = serviceResolver.getServiceOrFail<ApiWrapper>(ApiWrapper.identifier);
+     * await apiWrapper.patchElement(
+     *   'adc387a6-7f6c-49d5-a9fa-df3b5bf0c14f',
+     *   {
+     *     some: 'new data'
+     *   }
+     * );
+     * ```
+     *
+     * @see [Ember Nexus API: Update element endpoint](https://ember-nexus.github.io/api/#/api-endpoints/element/patch-element)
+     */
+    patchElement(elementId: Uuid, data: Data): Promise<void>;
+    /**
+     * Deletes an element.
+     *
+     * @example
+     * ```ts
+     * const apiWrapper = serviceResolver.getServiceOrFail<ApiWrapper>(ApiWrapper.identifier);
+     * await apiWrapper.deleteElement('f15abfb5-af82-45d0-96db-27766cbfd941');
+     * ```
+     *
+     * @see [Ember Nexus API: Delete element endpoint](https://ember-nexus.github.io/api/#/api-endpoints/element/delete-element)
+     */
+    deleteElement(elementId: Uuid): Promise<void>;
+    postRegister(uniqueUserIdentifier: UniqueUserIdentifier, password: string, data?: Data): Promise<Uuid>;
+    postChangePassword(uniqueUserIdentifier: UniqueUserIdentifier, currentPassword: string, newPassword: string): Promise<void>;
+    getMe(): Promise<Node>;
+    postToken(uniqueUserIdentifier: UniqueUserIdentifier, password: string, data?: Data): Promise<Token>;
+    getToken(): Promise<Node>;
+    deleteToken(): Promise<void>;
+}
+export { ApiWrapper };

package/dist/types/Service/CollectionParser.d.ts

@@ -0,0 +1,15 @@
+import { ElementParser } from './ElementParser.js';
+import { ServiceResolver } from './ServiceResolver.js';
+import { Collection } from '../Type/Definition/index.js';
+import { ServiceIdentifier } from '../Type/Enum/index.js';
+/**
+ * Class which helps to parse collections.
+ */
+declare class CollectionParser {
+    private elementParser;
+    static identifier: ServiceIdentifier;
+    constructor(elementParser: ElementParser);
+    static constructFromServiceResolver(serviceResolver: ServiceResolver): CollectionParser;
+    deserializeCollection(rawCollection: object): Promise<Collection>;
+}
+export { CollectionParser };

package/dist/types/Service/ElementParser.d.ts

@@ -0,0 +1,12 @@
+import { EventDispatcher } from './EventDispatcher.js';
+import { ServiceResolver } from './ServiceResolver.js';
+import { Node, Relation } from '../Type/Definition/index.js';
+import { ServiceIdentifier } from '../Type/Enum/index.js';
+declare class ElementParser {
+    private eventDispatcher;
+    static identifier: ServiceIdentifier;
+    constructor(eventDispatcher: EventDispatcher);
+    static constructFromServiceResolver(serviceResolver: ServiceResolver): ElementParser;
+    deserializeElement(element: object): Promise<Node | Relation>;
+}
+export { ElementParser };

package/dist/types/Service/EventDispatcher.d.ts

@@ -1,12 +1,18 @@
-import { EventDispatcherInterface, EventInterface, EventListener, EventListenerIdentifier, LoggerInterface } from '../Type/Definition/index.js';
+import { ServiceResolver } from './ServiceResolver.js';
+import { EventDispatcherInterface, EventInterface, EventListener, EventListenerTarget, LoggerInterface } from '../Type/Definition/index.js';
+import { ServiceIdentifier } from '../Type/Enum/index.js';
 declare class EventDispatcher implements EventDispatcherInterface {
-    private readonly entries;
     private logger;
+    static identifier: ServiceIdentifier;
+    private eventListenerTargets;
+    private isSilent;
     constructor(logger: LoggerInterface);
+    static constructFromServiceResolver(serviceResolver: ServiceResolver): EventDispatcher;
+    setSilent(silent: boolean): this;
     dispatchEvent(event: EventInterface): Promise<void>;
-    addListener(eventListenerIdentifier: EventListenerIdentifier, eventListener: EventListener, priority?: number): this;
-    removeListener(eventListenerIdentifier: EventListenerIdentifier, eventListener: EventListener): this;
-    getListeners(eventListenerIdentifier: EventListenerIdentifier): EventListener[];
-    hasListeners(eventListenerIdentifier: EventListenerIdentifier): boolean;
+    addListener(eventListenerTarget: EventListenerTarget, eventListener: EventListener, priority?: number): this;
+    removeListener(eventListenerTarget: EventListenerTarget, eventListener: EventListener): this;
+    getListeners(eventListenerTarget: EventListenerTarget): EventListener[];
+    hasListeners(eventListenerTarget: EventListenerTarget): boolean;
 }
 export { EventDispatcher };

package/dist/types/Service/FetchHelper.d.ts

@@ -0,0 +1,34 @@
+import { ApiConfiguration } from './ApiConfiguration.js';
+import { Logger } from './Logger.js';
+import { ServiceResolver } from './ServiceResolver.js';
+import { ResponseError } from '../Error/index.js';
+import { Uuid } from '../Type/Definition/index.js';
+import { ServiceIdentifier } from '../Type/Enum/index.js';
+/**
+ * Collection of different fetch helper methods.
+ */
+declare class FetchHelper {
+    private logger;
+    private apiConfiguration;
+    static identifier: ServiceIdentifier;
+    constructor(logger: Logger, apiConfiguration: ApiConfiguration);
+    static constructFromServiceResolver(serviceResolver: ServiceResolver): FetchHelper;
+    rethrowErrorAsNetworkError(error: unknown): never;
+    logAndThrowError(error: unknown): never;
+    parseJsonResponse(response: Response): Promise<object>;
+    parseEmptyResponse(response: Response): Promise<void>;
+    parseLocationResponse(response: Response): Promise<Uuid>;
+    createResponseErrorFromBadResponse(response: Response, data: Record<string, unknown>): ResponseError;
+    addAuthorizationHeader(headers: HeadersInit): void;
+    addAcceptJsonAndProblemJsonHeader(headers: HeadersInit): void;
+    addIfNoneMatchHeader(headers: HeadersInit, etag: string): void;
+    addContentTypeJsonHeader(headers: HeadersInit): void;
+    getDefaultGetOptions(etag?: string): RequestInit;
+    getDefaultDeleteOptions(): RequestInit;
+    getDefaultPostOptions(body: string): RequestInit;
+    getDefaultPatchOptions(body: string): RequestInit;
+    getDefaultPutOptions(body: string): RequestInit;
+    buildUrl(url: string): string;
+    runWrappedFetch(url: string, init?: RequestInit | undefined): Promise<Response>;
+}
+export { FetchHelper };

package/dist/types/Service/ServiceResolver.d.ts

@@ -3,7 +3,8 @@ declare class ServiceResolver {
     private readonly services;
     constructor();
     hasService(serviceIdentifier: ServiceIdentifier): boolean;
-    getService(serviceIdentifier: ServiceIdentifier): null | unknown;
+    getService<T = unknown>(serviceIdentifier: ServiceIdentifier): null | T;
+    getServiceOrFail<T = unknown>(serviceIdentifier: ServiceIdentifier): T;
     setService(serviceIdentifier: ServiceIdentifier, service: unknown): ServiceResolver;
     deleteService(serviceIdentifier: ServiceIdentifier): ServiceResolver;
     getServiceIdentifiers(): ServiceIdentifier[];

package/dist/types/Service/TokenParser.d.ts

@@ -0,0 +1,12 @@
+import { Token } from '../Type/Definition/index.js';
+import { ServiceIdentifier } from '../Type/Enum/index.js';
+/**
+ * Class which helps to parse tokens.
+ */
+declare class TokenParser {
+    static identifier: ServiceIdentifier;
+    constructor();
+    static constructFromServiceResolver(): TokenParser;
+    rawTokenToToken(token: object): Token;
+}
+export { TokenParser };

package/dist/types/Service/index.d.ts

@@ -1,3 +1,9 @@
+export * from './ApiConfiguration.js';
+export * from './ApiWrapper.js';
+export * from './CollectionParser.js';
+export * from './ElementParser.js';
 export * from './EventDispatcher.js';
+export * from './FetchHelper.js';
 export * from './Logger.js';
 export * from './ServiceResolver.js';
+export * from './TokenParser.js';

package/dist/types/Type/Definition/Action.d.ts

@@ -10,4 +10,4 @@ interface Action<T = unknown, C = object> {
     supports(data: unknown): boolean;
     execute(data: unknown, configuration?: C): Promise<T>;
 }
-export { ActionManifest, Action };
+export { Action, ActionManifest };

package/dist/types/Type/Definition/Collection.d.ts

@@ -0,0 +1,15 @@
+import { Node } from './Node.js';
+import { Relation } from './Relation.js';
+type Collection = {
+    id: string;
+    totalNodes: number;
+    links: {
+        first: string;
+        previous: string | null;
+        next: string | null;
+        last: string;
+    };
+    nodes: Array<Node>;
+    relations: Array<Relation>;
+};
+export { Collection };

package/dist/types/Type/Definition/Data.d.ts

@@ -0,0 +1,2 @@
+type Data = Record<string, unknown>;
+export { Data };

package/dist/types/Type/Definition/Element.d.ts

@@ -0,0 +1,8 @@
+import { Data } from './Data.js';
+import { Uuid } from './Uuid.js';
+type Element = {
+    type: string;
+    id: Uuid;
+    data: Data;
+};
+export { Element };

package/dist/types/Type/Definition/ElementCollection.d.ts

@@ -0,0 +1,14 @@
+import { Node } from './Node.js';
+import { Relation } from './Relation.js';
+type ElementCollection = {
+    id: string;
+    totalNodes: number;
+    links: {
+        first: string;
+        previous: string | null;
+        next: string | null;
+        last: string;
+    };
+    elements: Array<Node | Relation>;
+};
+export { ElementCollection };

package/dist/types/Type/Definition/Event.d.ts

@@ -3,28 +3,13 @@ interface EventInterface {
     getIdentifier(): EventIdentifier;
     isPropagationStopped(): boolean;
     stopPropagation(): this;
-    getContextValue(key: string): unknown;
-    setContextValue(key: string, value: unknown): this;
-    hasContextValue(key: string): boolean;
-    clearContextValue(key: string): this;
-    getContext(): Readonly<Record<string, unknown>>;
-    setContext(context: Record<string, unknown>): this;
-    clearContext(): this;
 }
-declare class Event implements EventInterface {
+declare abstract class Event implements EventInterface {
     private readonly identifier;
     private stopped;
-    private context;
-    constructor(identifier: EventIdentifier, context?: Record<string, unknown>);
+    protected constructor(identifier: EventIdentifier);
     getIdentifier(): EventIdentifier;
     isPropagationStopped(): boolean;
     stopPropagation(): this;
-    getContextValue(key: string): unknown;
-    setContextValue(key: string, value: unknown): this;
-    hasContextValue(key: string): boolean;
-    clearContextValue(key: string): this;
-    getContext(): Readonly<Record<string, unknown>>;
-    setContext(context: Record<string, unknown>): this;
-    clearContext(): this;
 }
-export { EventInterface, Event };
+export { Event, EventInterface };

package/dist/types/Type/Definition/EventDispatcher.d.ts

@@ -1,11 +1,11 @@
 import { EventInterface } from './Event.js';
 import { EventListener } from './EventListener.js';
-import { EventListenerIdentifier } from './EventListenerIdentifier.js';
+import { EventListenerTarget } from './EventListenerTarget.js';
 interface EventDispatcherInterface {
     dispatchEvent(event: EventInterface): Promise<void>;
-    addListener(eventListenerIdentifier: EventListenerIdentifier, eventListener: EventListener, priority?: number): this;
-    removeListener(eventListenerIdentifier: EventListenerIdentifier, eventListener: EventListener): this;
-    getListeners(eventListenerIdentifier: EventListenerIdentifier): EventListener[];
-    hasListeners(eventListenerIdentifier: EventListenerIdentifier): boolean;
+    addListener(eventListenerIdentifier: EventListenerTarget, eventListener: EventListener, priority?: number): this;
+    removeListener(eventListenerIdentifier: EventListenerTarget, eventListener: EventListener): this;
+    getListeners(eventListenerIdentifier: EventListenerTarget): EventListener[];
+    hasListeners(eventListenerIdentifier: EventListenerTarget): boolean;
 }
 export { EventDispatcherInterface };

package/dist/types/Type/Definition/EventIdentifier.d.ts

@@ -2,7 +2,7 @@ import { Branded } from './Branded.js';
 /**
  * Type safe variant of string containing event identifier.
  */
-type EventIdentifier = Branded<string, 'eventIdentifier'>;
+type EventIdentifier = Branded<string, 'eventIdentifier'> | string;
 declare const eventIdentifierRegex: RegExp;
 declare function validateEventIdentifierFromString(eventIdentifier: string): EventIdentifier;
-export { EventIdentifier, validateEventIdentifierFromString, eventIdentifierRegex };
+export { EventIdentifier, eventIdentifierRegex, validateEventIdentifierFromString };

package/dist/types/Type/Definition/EventListener.d.ts

@@ -1,4 +1,6 @@
 import { EventInterface } from './Event.js';
 import { OptionalPromise } from './OptionalPromise.js';
-type EventListener = (event: EventInterface) => OptionalPromise<void>;
+interface EventListener<EventType extends EventInterface = EventInterface> {
+    onEvent(event: EventType): OptionalPromise<void>;
+}
 export { EventListener };

package/dist/types/Type/Definition/EventListenerTarget.d.ts

@@ -0,0 +1,10 @@
+import { Branded } from './Branded.js';
+import { EventIdentifier } from './EventIdentifier.js';
+/**
+ * Type safe variant of string containing event identifier.
+ */
+type EventListenerTarget = Branded<string, 'eventListenerIdentifier'> | string;
+declare const eventListenerTargetRegex: RegExp;
+declare function validateEventListenerTargetFromString(eventListenerIdentifier: string): EventListenerTarget;
+declare function getEventListenerTargetsFromEventIdentifier(eventIdentifier: EventIdentifier): EventListenerTarget[];
+export { EventListenerTarget, eventListenerTargetRegex, getEventListenerTargetsFromEventIdentifier, validateEventListenerTargetFromString, };

package/dist/types/Type/Definition/InstanceConfiguration.d.ts

@@ -0,0 +1,14 @@
+type InstanceConfiguration = {
+    version: string;
+    pageSize: {
+        min: number;
+        default: number;
+        max: number;
+    };
+    register: {
+        enabled: boolean;
+        uniqueIdentifier: string;
+        uniqueIdentifierRegex: string | false;
+    };
+} | null;
+export { InstanceConfiguration };

package/dist/types/Type/Definition/Node.d.ts

@@ -0,0 +1,3 @@
+import { Element } from './Element.js';
+type Node = Element;
+export { Node };

package/dist/types/Type/Definition/NodeWithOptionalId.d.ts

@@ -0,0 +1,6 @@
+import { Node } from './Node.js';
+/**
+ * Node with optional id.
+ */
+type NodeWithOptionalId = Omit<Node, 'id'> & Pick<Partial<Node>, 'id'>;
+export { NodeWithOptionalId };

package/dist/types/Type/Definition/PriorityRegistry.d.ts

@@ -16,4 +16,4 @@ declare class PriorityRegistry<T = unknown> implements PriorityRegistryInterface
     setEntry(key: string, entry: T, priority?: number): this;
     getAllEntriesForKey(key: string): T[] | null;
 }
-export { PriorityRegistryInterface, PriorityRegistry };
+export { PriorityRegistry, PriorityRegistryInterface };

package/dist/types/Type/Definition/Registry.d.ts

@@ -13,4 +13,4 @@ declare class Registry<T = unknown> implements RegistryInterface<T> {
     hasEntry(key: string): boolean;
     setEntry(key: string, entry: T): this;
 }
-export { RegistryInterface, Registry };
+export { Registry, RegistryInterface };

package/dist/types/Type/Definition/Relation.d.ts

@@ -0,0 +1,7 @@
+import { Element } from './Element.js';
+import { Uuid } from './Uuid.js';
+type Relation = Element & {
+    start: Uuid;
+    end: Uuid;
+};
+export { Relation };

package/dist/types/Type/Definition/RelationWithOptionalId.d.ts

@@ -0,0 +1,6 @@
+import { Relation } from './Relation.js';
+/**
+ * Relation with optional id.
+ */
+type RelationWithOptionalId = Omit<Relation, 'id'> & Pick<Partial<Relation>, 'id'>;
+export { RelationWithOptionalId };

package/dist/types/Type/Definition/RequestProblem.d.ts

@@ -0,0 +1,10 @@
+import { RequestProblemCategory } from '../Enum/index.js';
+type RequestProblem = {
+    category: RequestProblemCategory;
+    type?: string;
+    title: string;
+    status?: number;
+    detail: string;
+    exception?: Record<string, unknown>;
+};
+export { RequestProblem };

package/dist/types/Type/Definition/Response/EmptyResponse.d.ts

@@ -0,0 +1,4 @@
+type EmptyResponse = {
+    response: Response;
+};
+export { EmptyResponse };

package/dist/types/Type/Definition/Response/NotModifiedResponse.d.ts

@@ -0,0 +1,4 @@
+type NotModifiedResponse = {
+    response: Response;
+};
+export { NotModifiedResponse };

package/dist/types/Type/Definition/Response/ParsedResponse.d.ts

@@ -0,0 +1,5 @@
+type ParsedResponse<T> = {
+    response: Response;
+    data: T;
+};
+export { ParsedResponse };

package/dist/types/Type/Definition/Response/index.d.ts

@@ -0,0 +1,3 @@
+export * from './EmptyResponse.js';
+export * from './NotModifiedResponse.js';
+export * from './ParsedResponse.js';

package/dist/types/Type/Definition/ServiceIdentifier.d.ts

@@ -2,7 +2,7 @@ import { Branded } from './Branded.js';
 /**
  * Type safe variant of string containing service identifier.
  */
-type ServiceIdentifier = Branded<string, 'serviceIdentifier'>;
+type ServiceIdentifier = Branded<string, 'serviceIdentifier'> | string;
 declare const serviceIdentifierRegex: RegExp;
 declare function validateServiceIdentifierFromString(serviceIdentifier: string): ServiceIdentifier;
-export { ServiceIdentifier, validateServiceIdentifierFromString, serviceIdentifierRegex };
+export { ServiceIdentifier, serviceIdentifierRegex, validateServiceIdentifierFromString };

package/dist/types/Type/Definition/Token.d.ts

@@ -0,0 +1,8 @@
+import { Branded } from './Branded.js';
+/**
+ * Type safe variant of string containing single token.
+ */
+type Token = Branded<string, 'Token'>;
+declare const tokenRegex: RegExp;
+declare function validateTokenFromString(token: string): Token;
+export { Token, tokenRegex, validateTokenFromString };

package/dist/types/Type/Definition/UniqueUserIdentifier.d.ts

@@ -0,0 +1,7 @@
+import { Branded } from './Branded.js';
+/**
+ * Type safe variant of string containing single user unique identifier, usually the user's email address.
+ */
+type UniqueUserIdentifier = Branded<string, 'UniqueUserIdentifier'>;
+declare function createUniqueUserIdentifierFromString(uniqueUserIdentifier: string): UniqueUserIdentifier;
+export { createUniqueUserIdentifierFromString, UniqueUserIdentifier };

package/dist/types/Type/Definition/Uuid.d.ts

@@ -0,0 +1,8 @@
+import { Branded } from './Branded.js';
+/**
+ * Type safe variant of string containing single UUIDv4.
+ */
+type Uuid = Branded<string, 'UUID'> | string;
+declare const uuidv4Regex: RegExp;
+declare function validateUuidFromString(uuid: string): Uuid;
+export { Uuid, uuidv4Regex, validateUuidFromString };