@accordproject/concerto-core 2.0.0-alpha.2 → 2.0.0

package/types/lib/basemodelmanager.d.ts

@@ -0,0 +1,295 @@
+export = BaseModelManager;
+/**
+ * Manages the Concerto model files.
+ *
+ * The structure of {@link Resource}s (Assets, Transactions, Participants) is modelled
+ * in a set of Concerto files. The contents of these files are managed
+ * by the {@link ModelManager}. Each Concerto file has a single namespace and contains
+ * a set of asset, transaction and participant type definitions.
+ *
+ * Concerto applications load their Concerto files and then call the {@link ModelManager#addModelFile addModelFile}
+ * method to register the Concerto file(s) with the ModelManager.
+ *
+ * Use the {@link Concerto} class to validate instances.
+ *
+ * @memberof module:concerto-core
+ */
+declare class BaseModelManager {
+    /**
+     * Create the ModelManager.
+     * @constructor
+     * @param {object} [options] - Serializer options
+     * @param {*} [processFile] - how to obtain a concerto AST from an input to the model manager
+     */
+    constructor(options?: object, processFile?: any);
+    processFile: any;
+    modelFiles: {};
+    factory: any;
+    serializer: any;
+    decoratorFactories: any[];
+    /**
+     * Returns true
+     * @returns {boolean} true
+     */
+    isModelManager(): boolean;
+    /**
+     * Adds root types
+     * @private
+     */
+    private addRootModel;
+    /**
+     * Visitor design pattern
+     * @param {Object} visitor - the visitor
+     * @param {Object} parameters  - the parameter
+     * @return {Object} the result of visiting or null
+     */
+    accept(visitor: any, parameters: any): any;
+    /**
+     * Validates a Concerto file (as a string) to the ModelManager.
+     * Concerto files have a single namespace.
+     *
+     * Note that if there are dependencies between multiple files the files
+     * must be added in dependency order, or the addModelFiles method can be
+     * used to add a set of files irrespective of dependencies.
+     * @param {string|ModelFile} modelFile - The Concerto file as a string
+     * @param {string} [fileName] - a file name to associate with the model file
+     * @throws {IllegalModelException}
+     */
+    validateModelFile(modelFile: string | ModelFile, fileName?: string): void;
+    /**
+     * Throws an error with details about the existing namespace.
+     * @param {ModelFile} modelFile The model file that is trying to declare an existing namespace
+     * @private
+     */
+    private _throwAlreadyExists;
+    /**
+     * Adds a Concerto file (as an AST) to the ModelManager.
+     * Concerto files have a single namespace. If a Concerto file with the
+     * same namespace has already been added to the ModelManager then it
+     * will be replaced.
+     * Note that if there are dependencies between multiple files the files
+     * must be added in dependency order, or the addModelFiles method can be
+     * used to add a set of files irrespective of dependencies.
+     * @param {ModelFile} modelFile - Model as a ModelFile object
+     * @param {string} [cto] - an optional cto string
+     * @param {string} [fileName] - an optional file name to associate with the model file
+     * @param {boolean} [disableValidation] - If true then the model files are not validated
+     * @throws {IllegalModelException}
+     * @return {Object} The newly added model file (internal).
+     */
+    addModelFile(modelFile: ModelFile, cto?: string, fileName?: string, disableValidation?: boolean): any;
+    /**
+     * Adds a model to the ModelManager.
+     * Concerto files have a single namespace. If a Concerto file with the
+     * same namespace has already been added to the ModelManager then it
+     * will be replaced.
+     * Note that if there are dependencies between multiple files the files
+     * must be added in dependency order, or the addModel method can be
+     * used to add a set of files irrespective of dependencies.
+     * @param {*} modelInput - Model (as a string or object)
+     * @param {string} [cto] - an optional cto string
+     * @param {string} [fileName] - an optional file name to associate with the model file
+     * @param {boolean} [disableValidation] - If true then the model files are not validated
+     * @throws {IllegalModelException}
+     * @return {Object} The newly added model file (internal).
+     */
+    addModel(modelInput: any, cto?: string, fileName?: string, disableValidation?: boolean): any;
+    /**
+     * Updates a Concerto file (as a string) on the ModelManager.
+     * Concerto files have a single namespace. If a Concerto file with the
+     * same namespace has already been added to the ModelManager then it
+     * will be replaced.
+     * @param {string|ModelFile} modelFile - Model as a string or object
+     * @param {string} [fileName] - a file name to associate with the model file
+     * @param {boolean} [disableValidation] - If true then the model files are not validated
+     * @throws {IllegalModelException}
+     * @returns {Object} The newly added model file (internal).
+     */
+    updateModelFile(modelFile: string | ModelFile, fileName?: string, disableValidation?: boolean): any;
+    /**
+     * Remove the Concerto file for a given namespace
+     * @param {string} namespace - The namespace of the model file to delete.
+     */
+    deleteModelFile(namespace: string): void;
+    /**
+     * Add a set of Concerto files to the model manager.
+     * @param {string[]|ModelFile[]} modelFiles - An array of models as strings or ModelFile objects.
+     * @param {string[]} [fileNames] - A array of file names to associate with the model files
+     * @param {boolean} [disableValidation] - If true then the model files are not validated
+     * @returns {Object[]} The newly added model files (internal).
+     */
+    addModelFiles(modelFiles: string[] | ModelFile[], fileNames?: string[], disableValidation?: boolean): any[];
+    /**
+     * Validates all models files in this model manager
+     */
+    validateModelFiles(): void;
+    /**
+     * Downloads all ModelFiles that are external dependencies and adds or
+     * updates them in this ModelManager.
+     * @param {Object} [options] - Options object passed to ModelFileLoaders
+     * @param {FileDownloader} [fileDownloader] - an optional FileDownloader
+     * @throws {IllegalModelException} if the models fail validation
+     * @return {Promise} a promise when the download and update operation is completed.
+     */
+    updateExternalModels(options?: any, fileDownloader?: FileDownloader): Promise<any>;
+    /**
+     * Write all models in this model manager to the specified path in the file system
+     *
+     * @param {string} path to a local directory
+     * @param {Object} [options] - Options object
+     * @param {boolean} options.includeExternalModels -
+     *  If true, external models are written to the file system. Defaults to true
+     */
+    writeModelsToFileSystem(path: string, options?: {
+        includeExternalModels: boolean;
+    }): void;
+    /**
+     * Get the array of model file instances
+     * @param {Boolean} [includeConcertoNamespace] - whether to include the concerto namespace
+     * (default to false)
+     * @return {ModelFile[]} The ModelFiles registered
+     * @private
+     */
+    private getModelFiles;
+    /**
+     * Gets all the Concerto models
+     * @param {Object} [options] - Options object
+     * @param {boolean} options.includeExternalModels -
+     *  If true, external models are written to the file system. Defaults to true
+     * @return {Array<{name:string, content:string}>} the name and content of each CTO file
+     */
+    getModels(options?: {
+        includeExternalModels: boolean;
+    }): Array<{
+        name: string;
+        content: string;
+    }>;
+    /**
+     * Check that the type is valid and returns the FQN of the type.
+     * @param {string} context - error reporting context
+     * @param {string} type - fully qualified type name
+     * @return {string} - the resolved type name (fully qualified)
+     * @throws {IllegalModelException} - if the type is not defined
+     * @private
+     */
+    private resolveType;
+    /**
+     * Remove all registered Concerto files
+     */
+    clearModelFiles(): void;
+    /**
+     * Get the ModelFile associated with a namespace
+     *
+     * @param {string} namespace - the namespace containing the ModelFile
+     * @return {ModelFile} registered ModelFile for the namespace or null
+     */
+    getModelFile(namespace: string): ModelFile;
+    /**
+     * Get the ModelFile associated with a file name
+     *
+     * @param {string} fileName - the fileName associated with the ModelFile
+     * @return {ModelFile} registered ModelFile for the namespace or null
+     * @private
+     */
+    private getModelFileByFileName;
+    /**
+     * Get the namespaces registered with the ModelManager.
+     * @return {string[]} namespaces - the namespaces that have been registered.
+     */
+    getNamespaces(): string[];
+    /**
+     * Look up a type in all registered namespaces.
+     *
+     * @param {string} qualifiedName - fully qualified type name.
+     * @return {ClassDeclaration} - the class declaration for the specified type.
+     * @throws {TypeNotFoundException} - if the type cannot be found or is a primitive type.
+     */
+    getType(qualifiedName: string): ClassDeclaration;
+    /**
+     * Get the AssetDeclarations defined in this model manager
+     * @return {AssetDeclaration[]} the AssetDeclarations defined in the model manager
+     */
+    getAssetDeclarations(): AssetDeclaration[];
+    /**
+     * Get the TransactionDeclarations defined in this model manager
+     * @return {TransactionDeclaration[]} the TransactionDeclarations defined in the model manager
+     */
+    getTransactionDeclarations(): TransactionDeclaration[];
+    /**
+     * Get the EventDeclarations defined in this model manager
+     * @return {EventDeclaration[]} the EventDeclaration defined in the model manager
+     */
+    getEventDeclarations(): EventDeclaration[];
+    /**
+     * Get the ParticipantDeclarations defined in this model manager
+     * @return {ParticipantDeclaration[]} the ParticipantDeclaration defined in the model manager
+     */
+    getParticipantDeclarations(): ParticipantDeclaration[];
+    /**
+     * Get the EnumDeclarations defined in this model manager
+     * @return {EnumDeclaration[]} the EnumDeclaration defined in the model manager
+     */
+    getEnumDeclarations(): EnumDeclaration[];
+    /**
+     * Get the Concepts defined in this model manager
+     * @return {ConceptDeclaration[]} the ConceptDeclaration defined in the model manager
+     */
+    getConceptDeclarations(): ConceptDeclaration[];
+    /**
+     * Get a factory for creating new instances of types defined in this model manager.
+     * @return {Factory} A factory for creating new instances of types defined in this model manager.
+     */
+    getFactory(): Factory;
+    /**
+     * Get a serializer for serializing instances of types defined in this model manager.
+     * @return {Serializer} A serializer for serializing instances of types defined in this model manager.
+     */
+    getSerializer(): Serializer;
+    /**
+     * Get the decorator factories for this model manager.
+     * @return {DecoratorFactory[]} The decorator factories for this model manager.
+     */
+    getDecoratorFactories(): DecoratorFactory[];
+    /**
+     * Add a decorator factory to this model manager.
+     * @param {DecoratorFactory} factory The decorator factory to add to this model manager.
+     */
+    addDecoratorFactory(factory: DecoratorFactory): void;
+    /**
+     * Checks if this fully qualified type name is derived from another.
+     * @param {string} fqt1 The fully qualified type name to check.
+     * @param {string} fqt2 The fully qualified type name it is may be derived from.
+     * @returns {boolean} True if this instance is an instance of the specified fully
+     * qualified type name, false otherwise.
+     */
+    derivesFrom(fqt1: string, fqt2: string): boolean;
+    /**
+     * Resolve the namespace for names in the metamodel
+     * @param {object} metaModel - the MetaModel
+     * @return {object} the resolved metamodel
+     */
+    resolveMetaModel(metaModel: object): object;
+    /**
+     * Populates the model manager from a models metamodel AST
+     * @param {*} ast the metamodel
+     */
+    fromAst(ast: any): void;
+    /**
+     * Get the full ast (metamodel instances) for a modelmanager
+     * @param {boolean} [resolve] - whether to resolve names
+     * @returns {*} the metamodel
+     */
+    getAst(resolve?: boolean): any;
+}
+import ModelFile = require("./introspect/modelfile");
+import { FileDownloader } from "@accordproject/concerto-util";
+import ClassDeclaration = require("./introspect/classdeclaration");
+import AssetDeclaration = require("./introspect/assetdeclaration");
+import TransactionDeclaration = require("./introspect/transactiondeclaration");
+import EventDeclaration = require("./introspect/eventdeclaration");
+import ParticipantDeclaration = require("./introspect/participantdeclaration");
+import EnumDeclaration = require("./introspect/enumdeclaration");
+import ConceptDeclaration = require("./introspect/conceptdeclaration");
+import Factory = require("./factory");
+import Serializer = require("./serializer");
+import DecoratorFactory = require("./introspect/decoratorfactory");

package/types/lib/decoratormanager.d.ts

@@ -0,0 +1,41 @@
+export = DecoratorManager;
+/**
+ * Utility functions to work with
+ * [DecoratorCommandSet](https://models.accordproject.org/concerto/decorators.cto)
+ * @memberof module:concerto-core
+ */
+declare class DecoratorManager {
+    /**
+     * Applies all the decorator commands from the DecoratorCommandSet
+     * to the ModelManager.
+     * @param {ModelManager} modelManager the input model manager
+     * @param {*} decoratorCommandSet the DecoratorCommandSet object
+     * @returns {ModelManager} a new model manager with the decorations applied
+     */
+    static decorateModels(modelManager: ModelManager, decoratorCommandSet: any): ModelManager;
+    /**
+     * Compares two values. If the first argument is falsy
+     * the function returns true.
+     * @param {string | null} test the value to test (lhs)
+     * @param {string} value the value to compare (rhs)
+     * @returns {Boolean} true if the lhs is falsy or test === value
+     */
+    static falsyOrEqual(test: string | null, value: string): boolean;
+    /**
+     * Applies a decorator to a decorated model element.
+     * @param {*} decorated the type to apply the decorator to
+     * @param {string} type the command type
+     * @param {*} newDecorator the decorator to add
+     */
+    static applyDecorator(decorated: any, type: string, newDecorator: any): void;
+    /**
+     * Executes a Command against a ClassDeclaration, adding
+     * decorators to the ClassDeclaration, or its properties, as required.
+     * @param {string} namespace the namespace for the declaration
+     * @param {*} declaration the class declaration
+     * @param {*} command the Command object from the
+     * org.accordproject.decoratorcommands model
+     */
+    static executeCommand(namespace: string, declaration: any, command: any): void;
+}
+import ModelManager = require("./modelmanager");

package/types/lib/factory.d.ts

@@ -131,5 +131,6 @@ declare class Factory {
      */
     private parseGenerateOptions;
 }
+import ModelManager = require("./modelmanager");
 import Resource = require("./model/resource");
 import Relationship = require("./model/relationship");

package/types/lib/introspect/assetdeclaration.d.ts

@@ -18,4 +18,11 @@ declare class AssetDeclaration {
      * @throws {IllegalModelException}
      */
     constructor(modelFile: ModelFile, ast: any);
+    /**
+     * Returns the kind of declaration
+     *
+     * @return {string} what kind of declaration this is
+     */
+    declarationKind(): string;
 }
+import ModelFile = require("./modelfile");

package/types/lib/introspect/classdeclaration.d.ts

@@ -47,6 +47,15 @@ declare class ClassDeclaration extends Decorated {
      * @return {ClassDeclaration} The super type, or null if non specified.
      */
     _resolveSuperType(): ClassDeclaration;
+    /**
+     * Semantic validation of the structure of this class. Subclasses should
+     * override this method to impose additional semantic constraints on the
+     * contents/relations of fields.
+     *
+     * @throws {IllegalModelException}
+     * @protected
+     */
+    protected validate(): void;
     /**
      * Returns true if this class is declared as abstract in the model file
      *
@@ -198,3 +207,5 @@ declare class ClassDeclaration extends Decorated {
     isClassDeclaration(): boolean;
 }
 import Decorated = require("./decorated");
+import Property = require("./property");
+import ModelFile = require("./modelfile");

package/types/lib/introspect/conceptdeclaration.d.ts

@@ -11,5 +11,11 @@ export = ConceptDeclaration;
  * @memberof module:concerto-core
  */
 declare class ConceptDeclaration extends ClassDeclaration {
+    /**
+     * Returns the kind of declaration
+     *
+     * @return {string} what kind of declaration this is
+     */
+    declarationKind(): string;
 }
 import ClassDeclaration = require("./classdeclaration");

package/types/lib/introspect/decorated.d.ts

@@ -46,10 +46,11 @@ declare class Decorated {
      * override this method to impose additional semantic constraints on the
      * contents/relations of fields.
      *
+     * @param {...*} args the validation arguments
      * @throws {IllegalModelException}
-     * @private
+     * @protected
      */
-    private validate;
+    protected validate(...args: any[]): void;
     /**
      * Returns the decorators for this class.
      *
@@ -63,4 +64,5 @@ declare class Decorated {
      */
     getDecorator(name: string): Decorator;
 }
+import ModelFile = require("./modelfile");
 import Decorator = require("./decorator");

package/types/lib/introspect/decorator.d.ts

@@ -11,9 +11,9 @@ declare class Decorator {
      * @param {Object} ast - The AST created by the parser
      * @throws {IllegalModelException}
      */
-    constructor(parent: ClassDeclaration | Property, ast: any);
+    constructor(parent: Property | ClassDeclaration, ast: any);
     ast: any;
-    parent: any;
+    parent: Property | ClassDeclaration;
     arguments: any[];
     /**
      * Visitor design pattern
@@ -27,7 +27,7 @@ declare class Decorator {
      * Returns the owner of this property
      * @return {ClassDeclaration|Property} the parent class or property declaration
      */
-    getParent(): ClassDeclaration | Property;
+    getParent(): Property | ClassDeclaration;
     /**
      * Process the AST and build the model
      * @throws {IllegalModelException}
@@ -52,3 +52,5 @@ declare class Decorator {
      */
     getArguments(): object[];
 }
+import Property = require("./property");
+import ClassDeclaration = require("./classdeclaration");

package/types/lib/introspect/decoratorfactory.d.ts

@@ -14,5 +14,8 @@ declare class DecoratorFactory {
      * @param {Object} ast - The AST created by the parser
      * @return {Decorator} The decorator.
      */
-    newDecorator(parent: ClassDeclaration | Property, ast: any): Decorator;
+    newDecorator(parent: Property | ClassDeclaration, ast: any): Decorator;
 }
+import Property = require("./property");
+import ClassDeclaration = require("./classdeclaration");
+import Decorator = require("./decorator");

package/types/lib/introspect/enumdeclaration.d.ts

@@ -8,5 +8,11 @@ export = EnumDeclaration;
  * @memberof module:concerto-core
  */
 declare class EnumDeclaration extends ClassDeclaration {
+    /**
+     * Returns the kind of declaration
+     *
+     * @return {string} what kind of declaration this is
+     */
+    declarationKind(): string;
 }
 import ClassDeclaration = require("./classdeclaration");

package/types/lib/introspect/eventdeclaration.d.ts

@@ -20,4 +20,11 @@ declare class EventDeclaration {
      * @private
      */
     private process;
+    /**
+     * Returns the kind of declaration
+     *
+     * @return {string} what kind of declaration this is
+     */
+    declarationKind(): string;
 }
+import ModelFile = require("./modelfile");

package/types/lib/introspect/illegalmodelexception.d.ts

@@ -1,5 +1,4 @@
 export = IllegalModelException;
-declare const IllegalModelException_base: typeof import("@accordproject/concerto-cto/types/lib/basefileexception");
 /**
  * Exception throws when a composer file is semantically invalid
  * @extends BaseFileException
@@ -7,7 +6,7 @@ declare const IllegalModelException_base: typeof import("@accordproject/concerto
  * @class
  * @memberof module:concerto-core
  */
-declare class IllegalModelException extends IllegalModelException_base {
+declare class IllegalModelException extends BaseFileException {
     /**
      * Create an IllegalModelException.
      * @param {string} message - the message for the exception
@@ -21,3 +20,5 @@ declare class IllegalModelException extends IllegalModelException_base {
      */
     constructor(message: string, modelFile?: ModelFile, fileLocation?: any, component?: string);
 }
+import { BaseFileException } from "@accordproject/concerto-util";
+import ModelFile = require("./modelfile");

package/types/lib/introspect/introspector.d.ts

@@ -41,3 +41,5 @@ declare class Introspector {
      */
     private getModelManager;
 }
+import ModelManager = require("../modelmanager");
+import ClassDeclaration = require("./classdeclaration");

package/types/lib/introspect/metamodel.d.ts

@@ -1,52 +1,18 @@
-export = MetaModel;
 /**
- * Class to work with the Concerto metamodel
+ * Create a metamodel manager (for validation against the metamodel)
+ * @return {*} the metamodel manager
  */
-declare class MetaModel {
-    /**
-     * Returns the metamodel CTO
-     * @returns {string} the metamodel as a CTO string
-     */
-    static getMetaModelCto(): string;
-    /**
-     * Create a metamodel manager (for validation against the metamodel)
-     * @return {*} the metamodel manager
-     */
-    static createMetaModelManager(): any;
-    /**
-     * Validate against the metamodel
-     * @param {object} input - the metamodel in JSON
-     * @return {object} the validated metamodel in JSON
-     */
-    static validateMetaModel(input: object): object;
-    /**
-     * Resolve the namespace for names in the metamodel
-     * @param {object} modelManager - the ModelManager
-     * @param {object} metaModel - the MetaModel
-     * @param {boolean} [validate] - whether to perform validation
-     * @return {object} the resolved metamodel
-     */
-    static resolveMetaModel(modelManager: object, metaModel: object, validate?: boolean): object;
-    /**
-     * Export metamodel from a model file
-     * @param {object} modelFile - the ModelFile
-     * @param {boolean} [validate] - whether to perform validation
-     * @return {object} the metamodel for this model
-     */
-    static modelFileToMetaModel(modelFile: object, validate?: boolean): object;
-    /**
-     * Export metamodel from a model manager
-     * @param {object} modelManager - the ModelManager
-     * @param {boolean} [resolve] - whether to resolve names
-     * @param {boolean} [validate] - whether to perform validation
-     * @return {object} the metamodel for this model manager
-     */
-    static modelManagerToMetaModel(modelManager: object, resolve?: boolean, validate?: boolean): object;
-    /**
-     * Import metamodel to a model manager
-     * @param {object} metaModel - the metamodel
-     * @param {boolean} [validate] - whether to perform validation
-     * @return {object} the metamodel for this model manager
-     */
-    static modelManagerFromMetaModel(metaModel: object, validate?: boolean): object;
-}
+export function newMetaModelManager(): any;
+/**
+ * Validate metamodel instance against the metamodel
+ * @param {object} input - the metamodel instance in JSON
+ * @return {object} the validated metamodel instance in JSON
+ */
+export function validateMetaModel(input: object): object;
+/**
+ * Import metamodel to a model manager
+ * @param {object} metaModel - the metamodel
+ * @param {boolean} [validate] - whether to perform validation
+ * @return {object} the metamodel for this model manager
+ */
+export function modelManagerFromMetaModel(metaModel: object, validate?: boolean): object;

package/types/lib/introspect/modelfile.d.ts

@@ -250,6 +250,8 @@ declare class ModelFile {
     private fromAst;
     namespace: any;
 }
+import ModelManager = require("../modelmanager");
+import ClassDeclaration = require("./classdeclaration");
 import AssetDeclaration = require("./assetdeclaration");
 import TransactionDeclaration = require("./transactiondeclaration");
 import EventDeclaration = require("./eventdeclaration");

package/types/lib/introspect/participantdeclaration.d.ts

@@ -14,4 +14,11 @@ declare class ParticipantDeclaration {
      * @throws {IllegalModelException}
      */
     constructor(modelFile: ModelFile, ast: any);
+    /**
+     * Returns the kind of declaration
+     *
+     * @return {string} what kind of declaration this is
+     */
+    declarationKind(): string;
 }
+import ModelFile = require("./modelfile");

package/types/lib/introspect/property.d.ts

@@ -25,6 +25,13 @@ declare class Property extends Decorated {
     type: any;
     array: boolean;
     optional: boolean;
+    /**
+     * Validate the property
+     * @param {ClassDeclaration} classDecl the class declaration of the property
+     * @throws {IllegalModelException}
+     * @protected
+     */
+    protected validate(classDecl: ClassDeclaration): void;
     /**
      * Returns the name of a property
      * @return {string} the name of this field
@@ -72,3 +79,4 @@ declare class Property extends Decorated {
     isPrimitive(): boolean;
 }
 import Decorated = require("./decorated");
+import ClassDeclaration = require("./classdeclaration");

package/types/lib/introspect/transactiondeclaration.d.ts

@@ -14,4 +14,11 @@ declare class TransactionDeclaration {
      * @throws {IllegalModelException}
      */
     constructor(modelFile: ModelFile, ast: any);
+    /**
+     * Returns the kind of declaration
+     *
+     * @return {string} what kind of declaration this is
+     */
+    declarationKind(): string;
 }
+import ModelFile = require("./modelfile");

package/types/lib/introspect/validator.d.ts

@@ -45,3 +45,4 @@ declare class Validator {
      */
     private validate;
 }
+import Field = require("./field");

package/types/lib/model/identifiable.d.ts

@@ -22,9 +22,9 @@ declare class Identifiable extends Typed {
      * @param {string} type - The type this instance.
      * @param {string} id - The identifier of this instance.
      * @param {string} timestamp - The timestamp of this instance
-     * @private
+     * @protected
      */
-    private constructor();
+    protected constructor();
     $identifier: string;
     $timestamp: string;
     /**