/**
* The i-views API
* Export date: 2020-07-31T14:09:47
* i-views version: 5.3.2
* Build 20073017
**/
/**
* The i-views namespace
* @namespace
**/
var $k = {
/**
* Aborts the current transaction. All changes will be rolled back. Has no effect if not transaction is active.
* No error is thrown.<p/>
* If the transaction function was called with a reject function,
* then this function is called before rolling back the transaction.
*
* @function
* @since 5.1.1
**/
abortTransaction: function() { },
/**
* Check access right
*
* @function
* @param {object} context List of possible operation types: createAttribute { attributeType, element }, createCompleteRelation { relationType, sourceElement, targetElement }, createConcept { superType }, createInstance { type }, createRelation { relationType, sourceElement, targetElement }, delete { element }, deleteAttribute { attribute, element }, deleteConcept { element }, deleteExtension { element, object }, deleteInstance { element }, deleteRelation { relation, element }, modify { element }, modifyAttributeValue { attribute, element }, modifySchema { element }, read { element }, readAttribute { attribute, element }, readConcept { type }, readExtension { element }, readInstance { object }, readObjectsOfType { type }, validateAttributeValue { attributeValue, language, attribute, element }, optional can additionally set the user, e.g. $k.checkAccessRight("read", { "user" : <userInstance>, "element" : <element to check> })
* @throws {$k.exception.TypeError} Unknown operation type
* @throws {$k.exception.TypeError} Context is missing
* @returns {Boolean} The decision as boolean
**/
checkAccessRight: function(context) { },
/**
* Defines a module
*
* @function
* @param {string} [id] Optional module ID
* @param {string[]} dependencies IDs of required modules
* @param factory Factory that returns the value of the module
**/
define: function(id, dependencies, factory) { },
/**
* Evaluates the function in an evelated context that does not check any access right. This function is only allowed in scripts that are controlled by administrators, otherwise an error is thrown
*
* @function
* @since 4.1.0
* @param {Function} f Function that should be evaluated in a system context
* @returns The return value of the function
* @throws {$k.exception.AccessDenied} If an elevated context cannot be activated, e.g. in a script created by a user without administration rights
**/
elevatedDo: function(f) { },
/**
* Filter semantic elements in array with access rights
*
* @function
* @param {string} operationType List of possible operation types: delete, deleteConcept, deleteInstance, modify, modifySchema, read, readExtension, readInstance
* @param {$k.SemanticElement[]} elements
* @param {object} [context]
* @param {object} [decision] Default is true
* @throws {$k.exception.TypeError} Unknown operation type
* @throws {$k.exception.TypeError} Only semantic elements in array can be processed
* @returns {$k.SemanticElement[]} Returns the filtered semantic elements
**/
filterWithAccessRights: function(operationType, elements, context, decision) { },
/**
* Get access right decision
*
* @function
* @param {object} context List of possible operation types: createAttribute { attributeType, element }, createCompleteRelation { relationType, sourceElement, targetElement }, createConcept { superType }, createInstance { type }, createRelation { relationType, sourceElement, targetElement }, delete { element }, deleteAttribute { attribute, element }, deleteConcept { element }, deleteExtension { element, object }, deleteInstance { element }, deleteRelation { relation, element }, modify { element }, modifyAttributeValue { attribute, element }, modifySchema { element }, read { element }, readAttribute { attribute, element }, readConcept { type }, readExtension { element }, readInstance { object }, readObjectsOfType { type }, validateAttributeValue { attributeValue, language, attribute, element }, optional can additionally set the user, e.g. $k.checkAccessRight("read", { "user" : <userInstance>, "element" : <element to check> })
* @throws {$k.exception.TypeError} Unknown operation type
* @throws {$k.exception.TypeError} Context is missing
* @returns {$k.Decision} The decision
* @since 5.3.2
**/
getAccessRightDecision: function(context) { },
/**
* Returns an object from the application client context. The application client context can be used to cache / transfer values across scripts.
* Use <code>getTransactionContext(key)</code> if possible.
* WARNING: do not use this function in REST scripts, "application client" refers to the entire bridge, thus the client context is shared by all users.
* The client context is resetted if
* - the client reconnects
* - client caches are flushed
*
* @function
* @param {string} key Key of the object
* @returns The object with the given key
* @since 4.1.1
**/
getClientContext: function(key) { },
/**
* Returns an object from the transaction context. The client context can be used to cache / transfer values across scripts within the transaction.
*
* @function
* @param {string} key Key of the object
* @returns The object with the given key
* @throws {$k.exception.TransactionError} If no transaction is active
* @since 4.1.1
**/
getTransactionContext: function(key) { },
/**
* Returns true if running in a debugger
*
* @function
* @version Experimental feature, might be removed at any time
* @returns {boolean}
* @since 5.1.1
**/
isDebugEnabled: function() { },
/**
* Return a wrappper for the specified KScript
*
* @function
* @since 5.2.2
* @version Experimental feature, might be removed at any time
* @param {string} scriptName The registered name of the KScript
* @throws {$k.exception.ModuleError} If the script was not found or is not a KScript
**/
kscript: function(scriptName) { },
/**
* Returns the current language (ISO 639 2b)
*
* @function
* @returns {string} Current language, eg. "eng"
* @since 4.1.1
**/
language: function() { },
/**
* Evaluates the function with the given language as current language
*
* @function
* @since 4.1.1
* @param {string} language Language to activate. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng")
* @param {Function} f Function that should be evaluated
* @returns The return value of the function
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
**/
languageDo: function(language, f) { },
/**
* Returns the current locale
*
* @function
* @returns {string} Current locale, eg. "en_US"
* @since 4.1.1
**/
locale: function() { },
/**
* Evaluates the function with the given locale as current locale
*
* @function
* @since 4.1.1
* @param {string} locale Locale, e.g. "en_GB"
* @param {Function} f Function that should be evaluated
* @returns The return value of the function
* @throws {$k.exception.InvalidLanguage} If an invalid locale was specified
**/
localeDo: function(locale, f) { },
/**
* Log an object on the current log stream (if available)
*
* @function
* @param object Object to log. Will be converted with toString().
* @param [level] Log level. Either a number or a string ("debug", "normal", "warning", "error").
* @param {string} [channel] Optional log channel.
* @example
* $k.log("New instance created");
* @example
* $k.log("The cake is a lie", $k.LOG_WARNING, "Portal");
**/
log: function(object, level, channel) { },
/**
* Log an object and additional structured data on the current log stream (if available)
*
* @function
* @param {object} data Data to log
* @param [message] Additional message. Will be converted with toString().
* @param [level] Log level. Either a number or a string ("debug", "normal", "warning", "error").
* @param {string} [channel] Optional log channel.
* @example
* $k.logData({"size":42}, "New instance created");
* @example
* $k.logData({"companionCube":"dead"}, "The cake is a lie", $k.LOG_WARNING, "Portal");
**/
logData: function(data, message, level, channel) { },
/**
* Log level [DEBUG]
**/
LOG_DEBUG: 3,
/**
*
* Log level [ERROR]
**/
LOG_ERROR: 30,
/**
*
* Normal log level
**/
LOG_NORMAL: 10,
/**
*
* Log level [WARNING]
**/
LOG_WARNING: 20,
/**
*
* Map the prototype of instances of the type with the internal name to the prototype object
*
* @function
* @param {string} internalName Internal name of the type of instances to map
* @param proto Prototype object
* @example
* function Person() { }
* Person.prototype.fullName = function() {
* return this.attributeValue("familyName").toUpperCase()
* + ", " + this.attributeValue("firstName");
* };
* $k.mapInstances("person", Person);
* var persons = $k.Registry.type("person").instances();
* for (var p in persons)
* $k.out.print(persons[p].fullName() + "\n");
**/
mapInstances: function(internalName, proto) { },
/**
* Maps a module ID to the ID of a registered script.
* Allows to register scripts containing modules under a different ID
*
* @function
* @param {string} moduleName The ID of the module
* @param {string} registryID The ID of the registered script
**/
mapModule: function(moduleName, registryID) { },
/**
* Map the prototype of types with the internal name to the prototype object
*
* @function
* @param {string} internalName Internal name of the type to map
* @param proto Prototype object
**/
mapTypes: function(internalName, proto) { },
/**
* Loads a module
*
* @function
* @param {string} moduleName The registered name of the module
* @param {boolean} [isLocal] (Since 4.0.2) True if the module script should be evaluated in a local environment, false if it should be evaluated in the environment of the caller. Default is false"
* @returns The model value
* @throws {$k.exception.ModuleError} If the module was not found or defined more than once
**/
module: function(moduleName, isLocal) { },
/**
* Evaluates the function without performing any triggers
*
* @function
* @since 4.1.0
* @param {Function} f Function that should be evaluated
* @returns The return value of the function
**/
noTriggersDo: function(f) { },
/**
* Evaluates the function in a transaction and returns its return value.
* Does not check if the transaction has been accepted or rejected.
* Allows to start a transaction within another transaction, the nested transaction will be a part of the outer transaction
*
* @function
* @param {Function} f Function that should be evaluated in a transaction
* @returns The return value of the function
* @throws {$k.exception.TransactionError} If a read-only transaction is already active
* @see $k.transaction
**/
optimisticTransaction: function(f) { },
/**
* Returns the document that represents the output stream of some script environments.
* The kind of object depends on the environment, but is usually an instance of $k.TextDocument.
*
* @example
* $k.out.print("Name: ", this.name());
* @see $k.TextDocument
* @type {$k.AbstractTextDocument}
**/
out: undefined,
/**
* Calls a function with required modules. Passes the value of each required module
*
* @function
* @param {string[]} dependencies IDs of required modules
* @param {function} callback Callback function
* @returns The return value of the callback function
* @throws {$k.exception.ModuleError} If a required module was not found or defined more than once
**/
require: function(dependencies, callback) { },
/**
* Returns the root type of the semantic network
*
* @function
* @returns {$k.Type}
**/
rootType: function() { },
/**
* Sets an object of the application client context. The application client context can be used to cache / transfer values across scripts.
* Use <code>setTransactionContext(key, value)</code> if possible.
* WARNING: do not use this function in REST scripts, "application client" refers to the entire bridge, thus the client context is shared by all users.
* The client context is resetted if
* - the client reconnects
* - client caches are flushed
*
* @function
* @param {string} key Key of the object
* @param {object} value The object to store
* @since 4.1.1
**/
setClientContext: function(key, value) { },
/**
* Sets an object of the transaction context. The client context can be used to cache / transfer values across scripts within the transaction.
*
* @function
* @param {string} key Key of the object
* @param {object} value The object to store
* @since 4.1.1
**/
setTransactionContext: function(key, value) { },
/**
* Returns the parent type of all shortcut relation types
*
* @function
* @returns {$k.Type}
**/
shortcutRelationType: function() { },
/**
* Suspends the current thread for a given number of milliseconds. Note: This blocks the whole execution of the current client.
*
* @function
* @param {number} delayMillis The number of milliseconds to wait for. The function does not sleep if +-Infinity or NaN is set.
* @since 4.3.0
**/
sleep: function(delayMillis) { },
/**
* Returns the core software version
*
* @function
* @since 4.4.0
* @returns {object} An object containing information about the core software version<code>{major: 4, minor: 4, patch: 0, state: "Release"}</code>
**/
softwareVersion: function() { },
/**
* Returns true if symmetric relation properties are enabled
*
* @function
* @returns {boolean}
**/
symmetricRelationProperties: function() { },
/**
* Returns the parent type of all system relation types
*
* @function
* @returns {$k.Type}
**/
systemRelationType: function() { },
/**
* Evaluates the function, but stops execution after the specified time and evaluates the (optional) timeout function.
*
* If the evaluated function has started a transaction, then this transaction will be rolled back. Outer transaction will not be rolled back. To avoid incomplete write operations, an exception is raised if a write transaction is active when calling this function.
*
* @function
* @since 4.2.0
* @param {number} timeout Timeout in milliseconds
* @param {Function} f Function that should be evaluated
* @param {Function} [timeoutFunction] Function that is evaluated when a timeout occurs.
* @returns The return value of the function, or the value of the timeout function when a timeout occurs, or undefined if no timout function is supplied
* @throws {$k.exception.TransactionError} If a write transaction is active
* @example
* $k.timeLimitedDo(1000,
* function() { return $k.Registry.query("longRunningQuery").findElements() },
* function() { throw "Query did not finish" }
* )
**/
timeLimitedDo: function(timeout, f, timeoutFunction) { },
/**
* Returns the parent type of all attribute types
*
* @function
* @returns {$k.Type}
**/
topAttributeType: function() { },
/**
* Returns the parent type of all relation types
*
* @function
* @returns {$k.Type}
**/
topRelationType: function() { },
/**
* Returns all top types except the top attribute and relation types
*
* @function
* @returns {$k.Type[]}
**/
topTypes: function() { },
/**
* Evaluates the function in a transaction and returns its return value if the transaction has been accepted.
* If the transaction is rejected due to concurrency conflicts, the optional reject function is performed.
* This function does not allow to start a transaction within an outer transaction, use optimisticTransaction() instead.
*
* @function
* @param {Function} f Function that should be evaluated in a transaction
* @param {Function} [rejectFunction] Optional function that is evaluated if the transaction is rejected.
* @returns The return value of the function. If the transaction is rejected, the return value of the reject function (if defined) or undefined is returned.
* @throws {$k.exception.TransactionError} If another transaction is already active
* @see $k.optimisticTransaction
**/
transaction: function(f, rejectFunction) { },
/**
* Returns an object that is bound to the active transaction. It can be used to cache / transfer values across scripts within the transaction.
* Creates a new object if none has been set yet
*
* @function
* @returns The context object
* @throws {$k.exception.TransactionError} If no transaction is active
* @deprecated Use <code>getTransactionContext(key)</code> and <code>setTransactionContext(key, value)</code>
**/
transactionContext: function() { },
/**
* Returns the current user
*
* @function
* @returns {$k.User}
**/
user: function() { },
/**
* Runs the function in an context bound to the user.
* This function is only allowed in scripts that are controlled by administrators, otherwise an error is thrown.<p/>
* Access rights checking is enabled in the function, call $k.elevatedDo() to disable checks
*
* @function
* @since 5.1.0
* @version Experimental feature, might be removed at any time
* @param {$k.User} user User or user instance
* @param {Function} f Function that should be evaluated in the user context
* @returns The return value of the function
* @throws {$k.exception.AccessDenied} If a user context cannot be activated, e.g. in a script created by a user without administration rights
**/
userDo: function(user, f) { },
/**
* Returns the parent type of user-defined relation type
*
* @function
* @returns {$k.Type}
**/
userRelationType: function() { },
/**
* Generates a UUID
*
* @function
* @returns {string}
**/
uuid: function() { },
/**
* Returns the name of the semantic network
*
* @function
* @returns {string}
**/
volume: function() { }
};/*global $k*/
/**
* Global object registry API for accessing objects by internal name / ID
* @namespace
**/
$k.Registry = {
/**
* Returns the semantic element with an attribute with the specified value, or undefined if there is either no such attribute or more than one
*
* @function
* @param {string} internalName The internal name of the attribute
* @param {string} value The value to search for
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {$k.SemanticElement}
* @throws {$k.exception.InvalidValue} If the value is not in the range of allowed values of the attribute
**/
elementAtValue: function(internalName, value, language) { },
/**
* Get the semantic element / domain with the element locator
*
* @since 4.0.2
* @function
* @param {string} locator
* @returns {$k.SemanticElement|$k.Domain}
* @throws {$k.exception.ObjectNotFound} If no element with the locator exists
* @throws {$k.exception.InvalidValue} If the locator is not valid
* @see $k.SemanticElement#locatorString
**/
elementByLocator: function(locator) { },
/**
* Get the semantic element with the element ID
*
* @function
* @param {string} id
* @returns {$k.SemanticElement}
* @throws {$k.exception.ObjectNotFound} If no element with the ID exists
* @throws {$k.exception.InvalidValue} If the ID is not valid
* @see $k.SemanticElement#idNumber
* @see $k.SemanticElement#idString
**/
elementWithID: function(id) { },
/**
* Get the registered folder
*
* @function
* @param {string} folderID Registered ID
* @returns {$k.Folder}
* @throws {$k.exception.ObjectNotFound} If no folder with the ID exists
**/
folder: function(folderID) { },
/**
* Get the registered mapping
*
* @function
* @param {string} mappingID A registered ID
* @returns {$k.Mapping} The found mapping
* @throws {$k.exception.ObjectNotFound} If no mapping with the ID exists
**/
mapping: function(mappingID) { },
/**
* Get the registered query
*
* @function
* @param {string} queryID Registered ID
* @returns {$k.Query}
* @throws {$k.exception.ObjectNotFound} If no expert query with the ID exists
**/
query: function(queryID) { },
/**
* Returns all registered folders
*
* @function
* @returns {$k.Folder[]}
**/
registeredFolders: function() { },
/**
* Get the registered folder element with the ID from the registry
*
* @function
* @deprecated Use specific registry accessors, like <code>query()</code> or <code>folder()</code>
* @param {string} registryType Name of the registry. Corresponds to the value returned by registryType()
* @param {string} objectID
* @returns {object}
* @throws {$k.exception.ObjectNotFound} If no object with the ID exists
* @see $k.FolderElement#registryType
**/
registeredObject: function(registryType, objectID) { },
/**
* Returns all registered queries
*
* @function
* @returns {$k.Query[]}
**/
registeredQueries: function() { },
/**
* Returns the IDs of all registered scripts
*
* @function
* @since 5.1.1
* @version Experimental feature, might be removed at any time
* @returns {string[]}
**/
registeredScriptIDs: function() { },
/**
* Returns all registered semantic collections
*
* @function
* @returns {$k.SemanticCollection[]}
**/
registeredSemanticCollections: function() { },
/**
* Get the registered semantic collection
*
* @function
* @param {string} collectionID Registered ID
* @returns {$k.SemanticCollection}
* @throws {$k.exception.ObjectNotFound} If no topic collection with the ID exists
**/
semanticCollection: function(collectionID) { },
/**
* Gets the type with the internal name
*
* @function
* @param {string} type The internal name of the type
* @returns {$k.Type} The type identified by the internal name
* @throws {$k.exception.ObjectNotFound} If no such type exists
**/
type: function(type) { }
};/*global $k*/
/**
* Namespace of errors
* @namespace
**/
$k.exception = {
/**
* Thrown when an read/write access is denied by the access rights
* @class
**/
AccessDenied: function() {},
/**
* Raised when a HTTP request fails
* @class
**/
HttpError: function() {},
/**
* Thrown when an invalid language was specified
* @class
**/
InvalidLanguage: function() {},
/**
* Thrown when a value is not in the range of allowed values
* @class
**/
InvalidValue: function() {},
/**
* Thrown when a Java error via embedded JNI execution occurs
* @class
**/
JavaError: function() {},
/**
* Thrown when a MailMessage cannot be handled correctly
* @class
**/
MailError: function() {},
/**
* Thrown when an error occurs while importing or exporting a mapping
* @class
**/
MappingError: function() {},
/**
* A required parameter is missing
* @class
**/
MissingParameter: function() {},
/**
* An error related to defining or using module
* @class
**/
ModuleError: function() {},
/**
* Thrown when an object or value is not unique
* @class
**/
NotUnique: function() {},
/**
* Thrown when an object could not be found
* @class
**/
ObjectNotFound: function() {},
/**
* Thrown when attempting to access a topic that was removed
* @class
**/
ObjectRemoved: function() {},
/**
* Thrown when a query could not be solved
* @class
**/
QueryError: function() {},
/**
* Thrown when it is not possible to remove a topic
* @class
**/
RemoveNotPossible: function() {},
/**
* Represents a generic runtime error
* @class
**/
RuntimeError: function() {},
/**
* Thrown when an attempt to modify the schema in an invalid way was made, or if the schema does not allow the operation
* @class
**/
SchemaError: function() {},
/**
* Thrown when the ViewConfiguration cannot identify or synchronize an objects
* @class
**/
SyncError: function() {},
/**
* Thrown when a timeout occurs
* @class
**/
TimeoutError: function() {},
/**
* A transaction-related error
* @class
**/
TransactionError: function() {},
/**
* Thrown when the type of an argument is not suitable
* @class
**/
TypeError: function() {},
/**
* An XML-related error
* @class
**/
XMLError: function() {}
};/*global $k*/
/**
* Built-in implemenation of Mustache.
* See https://mustache.github.io
* @class
**/
$k.Mustache = function() { };
/**
* Renders the template with the data
*
* @function
* @param {string} template The template string to be expanded
* @param {object} data The expansion data object
* @param {object} [partials] Optional partials
* @returns {string} The expanded output
* @throws {$k.exception.InvalidValue} If the mustache expansion runs into any error
**/
$k.Mustache.render = function(template, data, partials) { };
/*global $k*/
/**
* API for adding accesses to the history, either an attribute of the accessed element, or a history log file of the mediator.
* @namespace
**/
$k.History = {
/**
* Add the (trigger) access to the change log attribute. Requires a string attribute with internal name "changeLog", nothing will be logged.
*
* @function
* @param access Access
* @param {$k.SemanticElement} [changeLogContainer] The element, where the change is logged.
* If not specified, the element modified by the access will be used.
**/
addToChangeLog: function(access, changeLogContainer) { },
/**
* Add the (trigger) access to the mediator log. Requires configuring a log file for the volume. If no log filed is configured, nothing will be logged.
*
* @function
* @param access Access
**/
addToMediatorLog: function(access) { }
};/**
* Provides Java native interface in Javascript
* @namespace
**/
var $jni = {
/**
* Returns a class
*
* @function
* @param {string} className
* @returns {$jni.JavaClass}
**/
getClass: function(className) { },
/**
* Returns a Java represantation of the object
*
* @function
* @returns {$jni.JavaObject}
**/
toJava: function(object) { },
/**
* Imports the class(es) as a constructor of the same name
*
* @function
* @param className String or array of strings
* @param {boolean} [useNamespace] True (default) if the classes should be put in a namespace
* @returns {$jni.JavaClass}
**/
use: function(className, useNamespace) { }
};/*global $k*/
/**
* Configuration of an editor
* @class
**/
$k.AbstractEditorConfiguration = function() { };
/**
* Set render context
*
* @since 5.3.0
* @function
* @param {RenderContext} renderContextObject
**/
$k.AbstractEditorConfiguration.prototype.setRenderContext = function(renderContextObject) { };
/*global $k*/
/**
* @class
**/
$k.AbstractTextDocument = function() { };
/**
* Print a CR
*
* @function
**/
$k.AbstractTextDocument.prototype.cr = function() { };
/**
* Print a LF
*
* @since 4.2.1
* @function
**/
$k.AbstractTextDocument.prototype.lf = function() { };
/**
* Print the object on the script document
*
* @function
* @param varargs Objects to print. Will be converted with toString().
**/
$k.AbstractTextDocument.prototype.print = function(varargs) { };
/**
* Print the objects on the script document and adds a line break (LF)
*
* @function
* @param varargs Objects to print. Will be converted with toString().
**/
$k.AbstractTextDocument.prototype.println = function(varargs) { };
/**
* Print a tab
*
* @function
**/
$k.AbstractTextDocument.prototype.tab = function() { };
/**
* Get the contents as string
*
* @function
* @returns {string}
* @throws {$k.exception.TypeError} If the document is based on an external stream (file etc.)
**/
$k.AbstractTextDocument.prototype.text = function() { };
/**
* Returns an XML writer that writes on this document
*
* @function
* @param {object} [options] $(#jsOptionsComment)
* @throws {$k.exception.TypeError} If the document is not stream-based
* @returns {$k.XMLWriter}
**/
$k.AbstractTextDocument.prototype.xmlWriter = function(options) { };
/*global $k*/
/**
* Action on a view
* @class
**/
$k.Action = function() { };
/**
* Get the action response
*
* @since 5.2.2
* @function
* @returns {$k.ActionResponse} returns the action response
**/
$k.Action.prototype.actionResponse = function() { };
/**
* Returns the type of the action (configured or built-in)
*
* @since 5.2.2
* @function
* @returns {string}
**/
$k.Action.prototype.actionType = function() { };
/**
* Get configuration element
*
* @since 5.2.2
* @function
* @returns {$k.SemanticElement}
**/
$k.Action.prototype.configurationElement = function() { };
/**
* get the value of the given parameter
*
* @function
* @param {string} parameter
**/
$k.Action.prototype.getParameter = function(parameter) { };
/**
* get the value of the given variable
*
* @function
* @param {string} variable
* @returns (arrays of) SemanticElements and timestamps are auto-converted to native form
**/
$k.Action.prototype.getVariable = function(variable) { };
/**
* Returns true if the action has validation errors
*
* @function
* @returns {boolean}
* @since 5.3.2
**/
$k.Action.prototype.hasValidationErrors = function() { };
/**
* Returns true if the action is marked as failed
*
* @function
* @returns {boolean}
* @since 5.3.2
**/
$k.Action.prototype.isFailed = function() { };
/**
* get the receiver element of the action
*
* @function
**/
$k.Action.prototype.receiver = function() { };
/**
* get the selected element of the action - if present
*
* @function
**/
$k.Action.prototype.selectedElement = function() { };
/**
* get the session of the action
*
* @function
**/
$k.Action.prototype.session = function() { };
/**
* Specify if the panel shall be closed after the action. Overrides action configuration.
*
* @function
* @param {boolean} closePanel
**/
$k.Action.prototype.setClosePanel = function(closePanel) { };
/**
* Mark the action as failed. The transaction will be aborted and a failure response will be generated.
*
* @function
* @param {string} failMessage
**/
$k.Action.prototype.setFailed = function(failMessage) { };
/**
* Notification function
*
* @function
* @param {string} jseMessageString
* @param {string} [jseTypeString]
* @returns {$k.ActionResponse}
**/
$k.Action.prototype.setNotification = function(jseMessageString, jseTypeString) { };
/**
* Specify if the long running transaction shall be committed after the action. Overrides action configuration.
*
* @function
* @param {boolean} transactionCommit
**/
$k.Action.prototype.setTransactionCommit = function(transactionCommit) { };
/**
* set the value of the given variable
*
* @function
* @param {string} variable
* @param value supported variable types include all javascript base types as well as: timestamp, SemanticElement and arrays of the latter
**/
$k.Action.prototype.setVariable = function(variable, value) { };
/**
* Returns the current action if set, undefined if not.
*
* @function
**/
$k.Action.current = function() { };
/*global $k*/
/**
* @class
**/
$k.ActionResponse = function() { };
/**
* Data function
*
* @function
* @param {object} jseData
* @returns {$k.ActionResponse}
**/
$k.ActionResponse.prototype.setData = function(jseData) { };
/**
* Followup function
*
* @function
* @param {string} jseString
* @returns {$k.ActionResponse}
**/
$k.ActionResponse.prototype.setFollowup = function(jseString) { };
/**
* Set global context object
*
* @function
* @param {object[]} jseGlobalContext
* @returns {$k.ActionResponse}
**/
$k.ActionResponse.prototype.setGlobalContext = function(jseGlobalContext) { };
/**
* Notification function
*
* @function
* @param {string} jseMessageString
* @param {string} [jseTypeString]
* @returns {$k.ActionResponse}
**/
$k.ActionResponse.prototype.setNotification = function(jseMessageString, jseTypeString) { };
/**
* Set the session
*
* @function
* @param {object} session Either a JSON object or a Session
**/
$k.ActionResponse.prototype.setSession = function(session) { };
/**
* @function
**/
$k.ActionResponse.prototype.toJSON = function() { };
/*global $k*/
/**
* A view built with/by view configuration
* @class
* @extends $k.View
**/
$k.ActionView = function() { };
/**
* get the panel configurations activated by the action
*
* @function
* @since 5.3.2
**/
$k.ActionView.prototype.getPanelsToActivate = function() { };
/*global $k*/
/**
* @class
**/
$k.AlternativeGroupCondition = function() { };
/**
* Add a new alternative subquery
*
* @function
* @since 4.2.0
* @returns {$k.StructuredQuery}
**/
$k.AlternativeGroupCondition.prototype.addAlternative = function() { };
/**
* @deprecated This function is not supported any more
* @function
* @since 4.1.0
* @returns {number}
**/
$k.AlternativeGroupCondition.prototype.alternativesId = function() { };
/**
* Returns the parameter name of the condition, if defined
*
* @function
* @since 4.1.0
* @returns {string}
**/
$k.AlternativeGroupCondition.prototype.parameter = function() { };
/**
* Sets the parameter name of the condition
*
* @function
* @since 4.1.0
* @param {string} parameter
**/
$k.AlternativeGroupCondition.prototype.setParameter = function(parameter) { };
/*global $k*/
/**
* Configuration of an application
* @class
* @extends $k.AbstractEditorConfiguration
**/
$k.ApplicationConfiguration = function() { };
/**
* @since 4.1.0
* @function
* @returns {$k.SemanticElement}
**/
$k.ApplicationConfiguration.prototype.configElement = function() { };
/**
* Render the panel contents as a literal object
*
* @since 4.4.0
* @function
* @param {object} [elementOrObject] one of: a) semantic element that should be used as start object b) a PanelActivationContext to be used as start configuration
* @param {object} [keyFilter] Alternative 1: An array of strings defining a filter which property names to include.<br/>
* Alternative 2: An object with "include" and/or "exclude" keys<br/>
* <pre class="code">{"exclude": ["key1", ...]}</pre> includes all but the listed properties, while <pre class="code">{"include": ["key1", ...]}</pre> or <pre class="code">["key1", ...]</pre> includes only the listed properties.
* <br/>Non-optional properties are always included<br/>
* Alternative 3: A JSONRenderContext
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object} The panel contents
**/
$k.ApplicationConfiguration.prototype.panelContents = function(elementOrObject, keyFilter, detailFilter) { };
/**
* Render panels as a literal object
*
* @since 4.4.0
* @function
* @param {object} [keyFilter] Alternative 1: An array of strings defining a filter which property names to include.<br/>
* Alternative 2: An object with "include" and/or "exclude" keys<br/>
* <pre class="code">{"exclude": ["key1", ...]}</pre> includes all but the listed properties, while <pre class="code">{"include": ["key1", ...]}</pre> or <pre class="code">["key1", ...]</pre> includes only the listed properties.
* <br/>Non-optional properties are always included<br/>
* Alternative 3: A JSONRenderContext
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object} The rendered object
**/
$k.ApplicationConfiguration.prototype.render = function(keyFilter, detailFilter) { };
/**
* @function
**/
$k.ApplicationConfiguration.prototype.toJSON = function() { };
/**
* Returns the application confguration defined by the element
*
* @since 4.4.0
* @function
* @param {$k.SemanticElement} configurationElement The application configuration element (use semantic element, identifier oder element id)
* @returns {$k.ViewConfiguration}
**/
$k.ApplicationConfiguration.from = function(configurationElement) { };
/*global $k*/
/**
* Represents an attribute.
* @class
* @extends $k.Property
**/
$k.Attribute = function() { };
/**
* True if the attribute has translated values
*
* @function
* @returns {boolean}
**/
$k.Attribute.prototype.hasTranslatedValues = function() { };
/**
* Removes the translated value for the language
*
* @function
* @param {string} language Language of the value. If not defined, the current language will be used
* @returns {$k.Attribute} The attribute itself
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
* @throws {$k.exception.RemoveNotPossible} If the language cannot be removed, because it is the last remaining translation
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.Attribute.prototype.removeTranslation = function(language) { };
/**
* Sets the value of the attribute
*
* @function
* @param value The value that should be set.
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {$k.Attribute} The attribute
* @throws {$k.exception.InvalidValue} If the value is not in the range of allowed values of the attribute
* @throws {$k.exception.AccessDenied} If modifying is not allowed
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.Attribute.prototype.setValue = function(value, language) { };
/**
* Sets the value of the attribute from the string representation
*
* @function
* @param {string} string The string represantation of the value that should be set.
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {$k.Attribute} The attribute
* @throws {$k.exception.InvalidValue} If the string is not in the range of allowed values of the attribute
* @throws {$k.exception.AccessDenied} If modifying is not allowed
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.Attribute.prototype.setValueString = function(string, language) { };
/**
* Returns the translated languages as 3-letter codes (ISO639 2b).
* Empty if the attribute is not translated
*
* @function
* @returns {string[]}
**/
$k.Attribute.prototype.translatedLanguages = function() { };
/**
* Returns the value of the attribute
*
* @function
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
* @returns The value of the attribute. The type depends on the type of the attribute.
**/
$k.Attribute.prototype.value = function(language) { };
/**
* Returns the range of the values of the attribute
*
* @function
* @returns {$k.ValueRange}
**/
$k.Attribute.prototype.valueRange = function() { };
/**
* Returns the string representation of the value of the attribute
*
* @function
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
* @returns {string}
**/
$k.Attribute.prototype.valueString = function(language) { };
/*global $k*/
/**
* Represents a type of attributes
* @class
* @extends $k.PropertyType
**/
$k.AttributeType = function() { };
/**
* adds the language to the set of possible translations for this attribute
*
* @function
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.AttributeType.prototype.addTranslatedLanguage = function(language) { };
/**
* Returns the semantic element with an attribute of this type with the specified value, or undefined if there is either no such attribute or more than one
*
* @function
* @param {object} value The value to search for
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {$k.SemanticElement}
* @throws {$k.exception.InvalidValue} If the value is not in the range of allowed values of the attribute
**/
$k.AttributeType.prototype.elementAtValue = function(value, language) { };
/**
* Returns all semantic elements with attributes of this types with the specified value
*
* @function
* @param {object} value The value to search for
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {$k.SemanticElement[]}
* @throws {$k.exception.InvalidValue} If the value is not in the range of allowed values of the attribute
**/
$k.AttributeType.prototype.elementsAtValue = function(value, language) { };
/**
* True if the attributes have translated values
*
* @function
* @returns {boolean}
**/
$k.AttributeType.prototype.hasTranslatedValues = function() { };
/**
* Returns the possible translated languages as 3-letter codes (ISO639 2b).
* Empty if the attribute is not translated
*
* @function
* @returns {string[]}
**/
$k.AttributeType.prototype.translatedLanguages = function() { };
/**
* Returns the range of the values of the attributes
*
* @function
* @returns {$k.ValueRange}
**/
$k.AttributeType.prototype.valueRange = function() { };
/*global $k*/
/**
* Selects attributes that match a specified value with regard to a comparison operator
* @class
**/
$k.AttributeValueCondition = function() { };
/**
* @deprecated This function is not supported any more
* @function
* @since 4.1.0
* @returns {number}
**/
$k.AttributeValueCondition.prototype.alternativesId = function() { };
/**
* Returns the attribute condition
*
* @function
* @since 4.1.0
* @returns {$k.HasAttributeCondition}
**/
$k.AttributeValueCondition.prototype.attributeCondition = function() { };
/**
* Returns the default value. The default is used if no parameter for this condition is supplied
*
* @function
* @since 4.1.0
* @returns {Object}
**/
$k.AttributeValueCondition.prototype.defaultValue = function() { };
/**
* Returns true if equality is case insensitive. Only applies to string attributes and equality operators
*
* @function
* @since 4.1.0
* @returns {boolean}
**/
$k.AttributeValueCondition.prototype.ignoreCase = function() { };
/**
* Returns the comparison operator
*
* @function
* @since 4.1.0
* @returns {string}
**/
$k.AttributeValueCondition.prototype.operator = function() { };
/**
* Returns the parameter name of the condition, if defined
*
* @function
* @since 4.1.0
* @returns {string}
**/
$k.AttributeValueCondition.prototype.parameter = function() { };
/**
* Sets the default value. The default is used if no parameter for this condition is supplied
*
* @function
* @since 4.1.0
* @param value
**/
$k.AttributeValueCondition.prototype.setDefaultValue = function(value) { };
/**
* Set to true if equality should be insensitive
*
* @function
* @since 4.1.0
* @param {boolean} ignoreCase
**/
$k.AttributeValueCondition.prototype.setIgnoreCase = function(ignoreCase) { };
/**
* Sets the comparison operator
*
* @function
* @since 4.1.0
* @param {string} operator One of: "containsPhrase", "covers", "distance", "equal" (or "=="), "equalBy", "equalCardinality", "equalGeo", "equalMaxCardinality", "equalMinCardinality", "equalPresentTime", "equalsTopicOneWay", "fulltext", "greater" (or ">"), "greaterOrEqual" (or ">="), "greaterOverlaps", "greaterPresentTime", "isCoveredBy", "less" (or "<"), "lessOrEqual" (or "<="), "lessOverlaps", "lessPresentTime", "notEqual" (or "!="), "overlaps", "range", "regexEqual", "regexFulltext", "unmodifiedEqual", "words"
**/
$k.AttributeValueCondition.prototype.setOperator = function(operator) { };
/**
* Sets the parameter name of the condition
*
* @function
* @since 4.1.0
* @param {string} parameter
**/
$k.AttributeValueCondition.prototype.setParameter = function(parameter) { };
/*global $k*/
/**
* Represents a text document
* @class
* @extends $k.TextDocument
**/
$k.AutoFlushingTextDocument = function() { };
/*global $k*/
/**
* The value of a blob attribute.
* @class
**/
$k.Blob = function() { };
/**
* Returns the blob bytes as base 64 encoded string
*
* @function
* @returns {string}
**/
$k.Blob.prototype.base64String = function() { };
/**
* Returns the charset of the blob
*
* @function
* @returns {string}
* @since 5.1.0
**/
$k.Blob.prototype.charset = function() { };
/**
* Converts the image to another media type
*
* @function
* @param {string} mediaType The media type of the converted image
* @returns {$k.NetEntity} The converted image
* @throws {$k.exception.InvalidValue} If the image could not be converted
**/
$k.Blob.prototype.convertImage = function(mediaType) { };
/**
* Create a thumbnail with the specified maxium dimensions. The aspect ratio is preserved.
* Width or height can be undefined, but not both.
* The media type is optional and specifies the image type of the thumbnail.
* If not defined, the thumbnail will have the same type as the original image.
*
* @function
* @param {number} width The maximum width of the thumbnail
* @param {number} height The maximum height of the thumbnail
* @param {string} [mediaType] The media type of the converted image
* @returns {$k.NetEntity} The converted image
* @throws {$k.exception.InvalidValue} If the image could not be converted
**/
$k.Blob.prototype.createThumbnail = function(width, height, mediaType) { };
/**
* Returns the blob bytes as a data URL
*
* @function
* @returns {string}
* @see http://dataurl.net/#about
**/
$k.Blob.prototype.dataUrl = function() { };
/**
* Returns true if the values are equal
*
* @function
* @returns {boolean}
**/
$k.Blob.prototype.equals = function(value) { };
/**
* Returns the extension of the filename of the blob, without dot
*
* @function
* @returns {string}
**/
$k.Blob.prototype.fileExtension = function() { };
/**
* Returns the filename of the blob
*
* @function
* @returns {string}
**/
$k.Blob.prototype.filename = function() { };
/**
* Returns the image dimensions in pixels as array.
*
* @function
* @returns {array} Array containing width as first and height as second element.
* @throws {$k.exception.InvalidValue} If the blob is no image.
**/
$k.Blob.prototype.imageDimensions = function() { };
/**
* Returns the language of the blob, or undefined if not translated
*
* @function
* @returns {string}
**/
$k.Blob.prototype.language = function() { };
/**
* Returns a string that identifies the blob. Can be used to get the blob contents from the blob REST service.
* Returns undefined if the blob is not stored as the value of an attribute yet.
*
* @function
* @returns {string}
**/
$k.Blob.prototype.locator = function() { };
/**
* Returns the mime type of the blob
*
* @function
* @returns {string}
**/
$k.Blob.prototype.mimeType = function() { };
/**
* Set the blob bytes from base 64 encoded string
*
* @since 4.1.0
* @function
* @param {string} string A base 64 encoded string
* @returns {blob}
**/
$k.Blob.prototype.setBase64String = function(string) { };
/**
* Set the charset of the blob
*
* @since 5.1.0
* @function
* @param {string} string
* @returns {blob}
**/
$k.Blob.prototype.setCharset = function(string) { };
/**
* Set the filename of the blob
*
* @since 4.1.0
* @function
* @param {string} string
* @returns {blob}
**/
$k.Blob.prototype.setFilename = function(string) { };
/**
* Set the mime type of the blob
*
* @since 4.1.0
* @function
* @param {string} string
* @returns {blob}
**/
$k.Blob.prototype.setMimeType = function(string) { };
/**
* Returns the byte size of the blob
*
* @function
* @returns {number}
**/
$k.Blob.prototype.size = function() { };
/**
* Returns the blob bytes as string
*
* @function
* @param {string} charset Charset of the characters. UTF-8 if undefined
* @returns {string}
**/
$k.Blob.prototype.text = function(charset) { };
/**
* Creates a NetEntity from this blob
*
* @function
* @returns {$k.NetEntity}
**/
$k.Blob.prototype.toNetEntity = function() { };
/*global $k*/
/**
* Creates a new cause
*
* @param {number} [quality] Quality of the cause
* @param {object} [causeProperties] Properties of the cause
* @throws {$k.exception.InvalidValue} If the quality is not between 0 and 1
*
* Provides additional details about a hit returned by a query
* @class
**/
$k.Cause = function(quality, properties) { };
/**
* Returns all properties (restricted to those that can be converted to objects)
*
* @since 5.3.0
* @function
**/
$k.Cause.prototype.properties = function() { };
/**
* Returns the value of the named property, or undefined if the property does not exist
*
* @function
* @param {string} name
* @throws {$k.exception.TypeError} If the name is not a string
* @throws {$k.exception.InvalidValue} If the value of the property cannot be converted to an object
**/
$k.Cause.prototype.property = function(name) { };
/**
* Returns the quality of the cause, a number between 0 (worst quality) and 1 (best quality)
*
* @function
* @returns {number}
**/
$k.Cause.prototype.quality = function() { };
/**
* Set the properties of the cause
*
* @function
* @param {object} properties
* @throws {$k.exception.InvalidValue} If the value is not a valid property value
**/
$k.Cause.prototype.setProperties = function(properties) { };
/**
* Set the value of the named property
*
* @function
* @param {string} name
* @param value
* @throws {$k.exception.TypeError} If the name is not a string
* @throws {$k.exception.InvalidValue} If the value is not a valid property value
**/
$k.Cause.prototype.setProperty = function(name, value) { };
/**
* Set the quality, a number between 0 and 1
*
* @function
* @param {number} quality
* @throws {$k.exception.InvalidValue} If the quality is not between 0 and 1
**/
$k.Cause.prototype.setQuality = function(quality) { };
/**
* Set the type
*
* @function
* @param {string} type
* @throws {RangeError} If this is a system-defined cause
**/
$k.Cause.prototype.setType = function(type) { };
/**
* Returns the type of the cause, e.g. 'semantic'
*
* @function
* @returns {string}
**/
$k.Cause.prototype.type = function() { };
/*global $jni*/
/**
* Returns a JavaChar
*
* @param charValue Either an Unicode code point code, or string of length 1
* @returns {JavaChar}
*
* Represents a primitive character (char)
* @class
**/
$jni.char = function(charValue) { };
/**
* Returns the code point of the character
*
* @function
* @returns {number}
**/
$jni.char.prototype.codePoint = function() { };
/**
* Returns a JavaScript representation of the object
*
* @function
* @returns {object}
**/
$jni.char.prototype.toJS = function() { };
/**
* Returns a string containing the character
*
* @function
* @returns {string}
**/
$jni.char.prototype.toString = function() { };
/*global $k*/
/**
* A choice of a choice attribute. The possible choices are defined by ChoiceRange.
* @class
**/
$k.Choice = function() { };
/**
* Returns true if the values are equal
*
* @function
* @returns {boolean}
**/
$k.Choice.prototype.equals = function(value) { };
/**
* Returns the internal name (key) of the choice
*
* @function
* @returns {string} The internal name
**/
$k.Choice.prototype.internalName = function() { };
/**
* Returns the position (0-based) of the choice, if defined
*
* @function
* @returns {number}
**/
$k.Choice.prototype.position = function() { };
/**
* Returns the untranslated string
*
* @function
* @returns {string}
**/
$k.Choice.prototype.untranslatedString = function() { };
/**
* Returns the string representation of the choice.
* Returns the fallback string if the choice does not define a translation for a language
*
* @function
* @param {string} [language] Language of the value. If not defined, the current language will be used
* @returns {string}
**/
$k.Choice.prototype.valueString = function(language) { };
/*global $k*/
/**
* Represents the value range of a choice attribute
* @class
* @extends $k.ValueRange
**/
$k.ChoiceRange = function() { };
/**
* Returns the choice with the internal name
*
* @function
* @param {string} internalName The internal name of the choice
* @returns {$k.Choice}
* @throws {$k.exception.SchemaError} If there is no such choice
**/
$k.ChoiceRange.prototype.choiceInternalNamed = function(internalName) { };
/**
* Returns the possible choices
*
* @function
* @returns {$k.Choice[]}
**/
$k.ChoiceRange.prototype.choices = function() { };
/*global $k*/
/**
* A view built with/by view configuration for a collection of elements, such as a Query or a Table
* @class
* @extends $k.View
**/
$k.CollectionView = function() { };
/**
* Get an array of semantic elements. Use this e.g. for a table result.
*
* @since 5.2.1
* @function
* @returns {Element[]}
**/
$k.CollectionView.prototype.elements = function() { };
/**
* Get the corrresponding hit for the given element if this view holds a collection of hits.
*
* @since 5.3.0
* @function
* @param {$k.SemanticElement} element The element for which a hit shall be found.
* @returns {$k.SemanticElement}
**/
$k.CollectionView.prototype.hit = function(element) { };
/**
* Get an array hits. Use this e.g. for a table result.
*
* @since 5.2.1
* @function
* @returns {Element[]}
**/
$k.CollectionView.prototype.hits = function() { };
/**
* The number of elements (semantic elements or hits) in this query
*
* @since 5.2.1
* @function
* @returns {number}
**/
$k.CollectionView.prototype.resultSize = function() { };
/**
* Set an array of semantic elements. Use this e.g. for a table result.
*
* @since 5.3.0
* @function
* @param {Element[]} elements semantic elements
**/
$k.CollectionView.prototype.setElements = function(elements) { };
/**
* @function
* @param {$k.TableConfiguration} tableConfiguration A table configuration
* @returns {$k.TableConfiguration}
* @since 5.2.1
* @version Experimental feature, might be removed at any time
**/
$k.CollectionView.fromTableConfig = function(tableConfiguration) { };
/*global $k*/
/**
* Constructs a color that represents the specified hex string
*
* @param {string} hexString hex string
* @throws {$k.exception.InvalidValue} If the parameter is not an valid hex string
*
* The value of a color attribute.
* @class
**/
$k.Color = function(hexString) { };
/**
* Returns true if the values are equal
*
* @function
* @returns {boolean}
**/
$k.Color.prototype.equals = function(value) { };
/**
* Returns the hex string representation
*
* @function
* @returns {string}
**/
$k.Color.prototype.toHexString = function() { };
/**
* Returns the string representation
*
* @function
* @returns {string}
**/
$k.Color.prototype.toString = function() { };
/*global $k*/
/**
* Represents a HTTP Cookie (RFC 2109) sent by a client
* @class
**/
$k.Cookie = function() { };
/**
* Returns the name of the cookie
*
* @function
* @returns {string}
**/
$k.Cookie.prototype.name = function() { };
/**
* Returns the value of the cookie
*
* @function
* @returns {string}
**/
$k.Cookie.prototype.value = function() { };
/*global $k*/
/**
* Helper for copying objects.
* @class
**/
$k.Copier = function() { };
/**
* Copies the object and related objects
*
* @function
* @param {Object} object The object to copy
* @version Experimental feature, might be removed at any time
* @since 5.1.1
**/
$k.Copier.prototype.copy = function(object) { };
/**
* Sets the property filter function
*
* @function
* @param {function} checkFunction The function receives an object and should return true if the object should be deep copied.
* @version Experimental feature, might be removed at any time
* @since 5.0.3
**/
$k.Copier.prototype.setDeepCopyFilter = function(checkFunction) { };
/**
* Sets the copy callback function function
*
* @function
* @param {function} checkFunction The function is called after an object is copied. It receives the original object and the copy.
* @version Experimental feature, might be removed at any time
* @since 5.1.1
**/
$k.Copier.prototype.setPostCopyCallback = function(checkFunction) { };
/**
* Sets the property filter function
*
* @function
* @param {function} filterFunction The function receives a property and should return true if the property should be copied.
* @version Experimental feature, might be removed at any time
* @since 5.0.3
**/
$k.Copier.prototype.setPropertyFilter = function(filterFunction) { };
/*global $k*/
/**
* @class
**/
$k.Crypto = function() { };
/**
* Returns an object containing the names of available digest and cipher algorithms.
*
* @function
* @returns {object}
* @version Experimental feature, might be removed at any time
**/
$k.Crypto.availableAlgorithms = function() { };
/**
* Creates a hash object using the given algorithm.
*
* @function
* @param {string} algorithm The algorithm to use
* @returns {$k.Hash} The hash object
* @version Experimental feature, might be removed at any time
**/
$k.Crypto.createHash = function(algorithm) { };
/*global $k*/
/**
* Constructs a Date from the argument(s), which can be a Date object, undefined, milliseconds (UTC) or component values.
* If undefined, the current date is returned
*
* @param [value] Date or year
* @param [month] Month number
* @param [day] Day number
*
* Represents a date
* @class
**/
$k.Date = function(varargs) { };
/**
* Returns true if the values are equal
*
* @function
* @returns {boolean}
**/
$k.Date.prototype.equals = function(value) { };
/**
* Returns the number of the day, e.g. 18 for 2011-03-18
*
* @function
* @returns {number}
**/
$k.Date.prototype.getDayNumber = function() { };
/**
* Returns the number of the month.
* Unlike Date.prototype.month(), this is not the 0-based month index,
* so for January getMonthNumber() returns 1, not 0
*
* @function
* @returns {number}
**/
$k.Date.prototype.getMonthNumber = function() { };
/**
* Returns the full year
*
* @function
* @returns {number}
**/
$k.Date.prototype.getYear = function() { };
/**
* Returns the latest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T23:59:59.999 for the date 2007-03-01.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.Date.prototype.maxDate = function() { };
/**
* Returns the latest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T23:59:59.999 for the date 2007-03-01.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.Date.prototype.maxUTCDate = function() { };
/**
* Returns the earliest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T0:00:00.0 for the date 2007-03-01.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.Date.prototype.minDate = function() { };
/**
* Returns the earliest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T0:00:00.0 for the date 2007-03-01.
* Assumes that this is an UTC date/time
*
* @function
* @returns {Date}
**/
$k.Date.prototype.minUTCDate = function() { };
/**
* Sets the number of the day, e.g. 23 for 2012-05-23
*
* @function
* @param {number} day
**/
$k.Date.prototype.setDayNumber = function(day) { };
/**
* Set the number of the month.
* Unlike Date.prototype.month(), this is not the 0-based month index,
* so for January pass 1 to setMonthNumber() , not 0.
*
* @function
* @param {number} month
**/
$k.Date.prototype.setMonthNumber = function(month) { };
/**
* Sets the full year. The year is not modified, so setYear(99) sets the year 99, not 1999.
*
* @function
* @param {number} year
**/
$k.Date.prototype.setYear = function(year) { };
/**
* Returns the date/time as a Javascript date object.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.Date.prototype.toDate = function() { };
/**
* Returns an ISO 8601 representation of the date/time
*
* @function
* @since 4.1.0
**/
$k.Date.prototype.toISOString = function() { };
/**
* Returns a string representing the date/time, similar to Date.prototype.toJSON ( key )
*
* @function
* @see $k.Date#toJSON
**/
$k.Date.prototype.toJSON = function(key) { };
/**
* Returns the string representation. Equivalent to valueString()
*
* @function
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {string}
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
**/
$k.Date.prototype.toString = function(language) { };
/**
* Returns the date/time as a UTC date/time
* Assumes that this is a local date/time
*
* @function
* @since 4.1.0
**/
$k.Date.prototype.toUTC = function() { };
/**
* Returns the internal millisecond value. Allows comparing date/time values, since the comparision operators call valueOf()
*
* @function
* @returns {number}
**/
$k.Date.prototype.valueOf = function() { };
/**
* Returns the string representation
*
* @function
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {string}
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
**/
$k.Date.prototype.valueString = function(language) { };
/**
* Parse the date/time string. Both ISO 8601 and localized strings are supported.
*
* @function
* @param {string} string The string representation
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns The parsed date/time
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
* @throws {$k.exception.InvalidValue} If value is invalid
**/
$k.Date.parse = function(string, language) { };
/*global $k*/
/**
* Constructs a DateTime from the argument(s), which can be a Date object, undefined, milliseconds (UTC) or component values.
* If undefined, the current date and time is returned
*
* @param [value] Date or year
* @param [month] Month number
* @param [day] Day number
* @param [hours] Hours
* @param [minutes] Minutes
* @param [seconds] Seconds
*
* Represents a date and time without timezone
* @class
**/
$k.DateTime = function(varargs) { };
/**
* Returns true if the values are equal
*
* @function
* @returns {boolean}
**/
$k.DateTime.prototype.equals = function(value) { };
/**
* Returns the number of the day, e.g. 18 for 2011-03-18
*
* @function
* @returns {number}
**/
$k.DateTime.prototype.getDayNumber = function() { };
/**
* Returns the hours
*
* @function
* @returns {number}
**/
$k.DateTime.prototype.getHours = function() { };
/**
* Returns the minutes
*
* @function
* @returns {number}
**/
$k.DateTime.prototype.getMinutes = function() { };
/**
* Returns the number of the month.
* Unlike Date.prototype.month(), this is not the 0-based month index,
* so for January getMonthNumber() returns 1, not 0
*
* @function
* @returns {number}
**/
$k.DateTime.prototype.getMonthNumber = function() { };
/**
* Returns the seconds
*
* @function
* @returns {number}
**/
$k.DateTime.prototype.getSeconds = function() { };
/**
* Returns the full year
*
* @function
* @returns {number}
**/
$k.DateTime.prototype.getYear = function() { };
/**
* Returns the latest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T23:59:59.999 for the date 2007-03-01.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.DateTime.prototype.maxDate = function() { };
/**
* Returns the latest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T23:59:59.999 for the date 2007-03-01.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.DateTime.prototype.maxUTCDate = function() { };
/**
* Returns the earliest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T0:00:00.0 for the date 2007-03-01.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.DateTime.prototype.minDate = function() { };
/**
* Returns the earliest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T0:00:00.0 for the date 2007-03-01.
* Assumes that this is an UTC date/time
*
* @function
* @returns {Date}
**/
$k.DateTime.prototype.minUTCDate = function() { };
/**
* Sets the number of the day, e.g. 23 for 2012-05-23
*
* @function
* @param {number} day
**/
$k.DateTime.prototype.setDayNumber = function(day) { };
/**
* Sets the hours
*
* @function
* @param {number} hours
**/
$k.DateTime.prototype.setHours = function(hours) { };
/**
* Sets the minutes.
*
* @function
* @param {number} minutes
**/
$k.DateTime.prototype.setMinutes = function(minutes) { };
/**
* Set the number of the month.
* Unlike Date.prototype.month(), this is not the 0-based month index,
* so for January pass 1 to setMonthNumber() , not 0.
*
* @function
* @param {number} month
**/
$k.DateTime.prototype.setMonthNumber = function(month) { };
/**
* Sets the seconds.
*
* @function
* @param {number} seconds
**/
$k.DateTime.prototype.setSeconds = function(seconds) { };
/**
* Sets the full year. The year is not modified, so setYear(99) sets the year 99, not 1999.
*
* @function
* @param {number} year
**/
$k.DateTime.prototype.setYear = function(year) { };
/**
* Returns the date/time as a Javascript date object.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.DateTime.prototype.toDate = function() { };
/**
* Returns an ISO 8601 representation of the date/time
*
* @function
* @since 4.1.0
**/
$k.DateTime.prototype.toISOString = function() { };
/**
* Returns a string representing the date/time, similar to Date.prototype.toJSON ( key )
*
* @function
* @see $k.Date#toJSON
**/
$k.DateTime.prototype.toJSON = function(key) { };
/**
* Returns the string representation. Equivalent to valueString()
*
* @function
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {string}
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
**/
$k.DateTime.prototype.toString = function(language) { };
/**
* Returns the date/time as a UTC date/time
* Assumes that this is a local date/time
*
* @function
* @since 4.1.0
**/
$k.DateTime.prototype.toUTC = function() { };
/**
* Returns the date/time as a Javascript date object.
* Assumes that this is an UTC date/time
*
* @function
* @returns {Date}
**/
$k.DateTime.prototype.toUTCDate = function() { };
/**
* Returns the internal millisecond value. Allows comparing date/time values, since the comparision operators call valueOf()
*
* @function
* @returns {number}
**/
$k.DateTime.prototype.valueOf = function() { };
/**
* Returns the string representation
*
* @function
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {string}
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
**/
$k.DateTime.prototype.valueString = function(language) { };
/**
* Parse the date/time string. Both ISO 8601 and localized strings are supported.
*
* @function
* @param {string} string The string representation
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns The parsed date/time
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
* @throws {$k.exception.InvalidValue} If value is invalid
**/
$k.DateTime.parse = function(string, language) { };
/*global $k*/
/**
* A access right decision
* @class
**/
$k.Decision = function() { };
/**
* Description ot the decision
*
* @function
* @returns {string}
* @since 5.3.2
**/
$k.Decision.prototype.description = function() { };
/**
* Permission ot the decision
*
* @function
* @returns {boolean}
* @since 5.3.2
**/
$k.Decision.prototype.permission = function() { };
/*global $k*/
/**
* Represents all instances or subtypes of a type
* @class
**/
$k.Domain = function() { };
/**
* Returns the properties defined for this domain. No inherited or mixed in properties are returned.
*
* @function
* @returns {$k.PropertyType[]}
**/
$k.Domain.prototype.definedProperties = function() { };
/**
* Returns true if this domain represents types, false if it represents instances / properties
*
* @function
* @returns {boolean}
**/
$k.Domain.prototype.isTypeDomain = function() { };
/**
* Returns the attribute type that is used as name for this domain
*
* @function
* @returns {$k.AttributeType[]}
* @since 5.1.3
**/
$k.Domain.prototype.nameAttribute = function() { };
/**
* Returns the possible properties of this domain
*
* @function
* @see Topic#possibleProperties
* @param {$k.PropertyFilter} [filter] Filter that defines which properties are returned
* @returns {$k.PropertyType[]}
**/
$k.Domain.prototype.possibleProperties = function(filter) { };
/**
* Returns the type of the domain
*
* @function
* @returns {$k.Type}
**/
$k.Domain.prototype.type = function() { };
/**
* Returns the supremum domain for the given domains (either Domain objects or internal names of types). Returns undefined if no common domain exists
*
* @function
* @param {$k.Domain[]} elements
* @returns {$k.Domain}
**/
$k.Domain.supremum = function(elements) { };
/*global $k*/
/**
* Selects elements that are included in a list of supplied elements
* @class
**/
$k.ElementsCondition = function() { };
/**
* @deprecated This function is not supported any more
* @function
* @since 4.1.0
* @returns {number}
**/
$k.ElementsCondition.prototype.alternativesId = function() { };
/**
* Returns the parameter name of the condition, if defined
*
* @function
* @since 4.1.0
* @returns {string}
**/
$k.ElementsCondition.prototype.parameter = function() { };
/**
* Sets the parameter name of the condition
*
* @function
* @since 4.1.0
* @param {string} parameter
**/
$k.ElementsCondition.prototype.setParameter = function(parameter) { };
/*global $k*/
/**
* @class
**/
$k.EncryptedAccount = function() { };
/**
* Returns the password as a plain string. Handle with care!
*
* @function
* @since 5.2.2
* @version Experimental feature, might be removed at any time
**/
$k.EncryptedAccount.prototype.password = function() { };
/**
* Returns the username
*
* @function
* @since 5.2.2
* @version Experimental feature, might be removed at any time
**/
$k.EncryptedAccount.prototype.userName = function() { };
/**
* Set the username and password from a volume encrypted authenication string
*
* @function
* @param {string} encryptedAccount Encrypted account (Base64 encoded string generated in the Admin-Tool)
* @since 5.2.2
* @version Experimental feature, might be removed at any time
**/
$k.EncryptedAccount.from = function(encryptedAccount) { };
/*global $k*/
/**
* Constructs a FlexDateTime from the argument(s), which can be a Date object, another FlexDateTime, undefined, or component values.
* If undefined, all components of the returned FlexDateTime are undefined
*
* @param [value] Date or FlexDateTime or year component
* @param [month] Month number
* @param [day] Day number
* @param [hours] Hours
* @param [minutes] Minutes
* @example
* // All components are undefined
* new $k.FlexDateTime();
* // Current date
* new $k.FlexDateTime(new Date());
* // 2007-06-03 21:48
* new $k.FlexDateTime(2007, 6, 3, 21, 48);
*
*
* Represents a flexible date/time without timezone that allowes certain degrees of imprecision.
* FlexDateTime has the following components, which can be set to an integer or undefined:
* year, month number, day number, hours, minutes.
* Note that a FlexDateTime has no seconds.
* @class
**/
$k.FlexDateTime = function(varargs) { };
/**
* Returns true if the date is within the range of this flexible date
*
* @function
* @param {date} date
* @returns {boolean}
**/
$k.FlexDateTime.prototype.coversDate = function(date) { };
/**
* Returns true if the values are equal
*
* @function
* @returns {boolean}
**/
$k.FlexDateTime.prototype.equals = function(value) { };
/**
* Returns the number of the day, e.g. 18 for 2011-03-18
*
* @function
* @returns {number}
**/
$k.FlexDateTime.prototype.getDayNumber = function() { };
/**
* Returns the hours
*
* @function
* @returns {number}
**/
$k.FlexDateTime.prototype.getHours = function() { };
/**
* Returns the minutes
*
* @function
* @returns {number}
**/
$k.FlexDateTime.prototype.getMinutes = function() { };
/**
* Returns the number of the month.
* Unlike Date.prototype.month(), this is not the 0-based month index,
* so for January getMonthNumber() returns 1, not 0
*
* @function
* @returns {number}
**/
$k.FlexDateTime.prototype.getMonthNumber = function() { };
/**
* Returns the full year
*
* @function
* @returns {number}
**/
$k.FlexDateTime.prototype.getYear = function() { };
/**
* Returns the latest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T23:59:59.999 for the date 2007-03-01.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.FlexDateTime.prototype.maxDate = function() { };
/**
* Returns the latest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T23:59:59.999 for the date 2007-03-01.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.FlexDateTime.prototype.maxUTCDate = function() { };
/**
* Returns the earliest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T0:00:00.0 for the date 2007-03-01.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.FlexDateTime.prototype.minDate = function() { };
/**
* Returns the earliest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T0:00:00.0 for the date 2007-03-01.
* Assumes that this is an UTC date/time
*
* @function
* @returns {Date}
**/
$k.FlexDateTime.prototype.minUTCDate = function() { };
/**
* Sets the number of the day, e.g. 23 for 2012-05-23
*
* @function
* @param {number} day
**/
$k.FlexDateTime.prototype.setDayNumber = function(day) { };
/**
* Sets the hours
*
* @function
* @param {number} hours
**/
$k.FlexDateTime.prototype.setHours = function(hours) { };
/**
* Sets the minutes.
*
* @function
* @param {number} minutes
**/
$k.FlexDateTime.prototype.setMinutes = function(minutes) { };
/**
* Set the number of the month.
* Unlike Date.prototype.month(), this is not the 0-based month index,
* so for January pass 1 to setMonthNumber() , not 0.
*
* @function
* @param {number} month
**/
$k.FlexDateTime.prototype.setMonthNumber = function(month) { };
/**
* Sets all components of the FlexDateTime
*
* @function
* @param {number} year
* @param {number} month
* @param {number} day
* @param {number} hours
* @param {number} minutes
**/
$k.FlexDateTime.prototype.setValues = function(year, month, day, hours, minutes) { };
/**
* Sets the full year. The year is not modified, so setYear(99) sets the year 99, not 1999.
*
* @function
* @param {number} year
**/
$k.FlexDateTime.prototype.setYear = function(year) { };
/**
* Returns the date/time as a Javascript date object.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.FlexDateTime.prototype.toDate = function() { };
/**
* Returns a string representing the date/time, similar to Date.prototype.toJSON ( key )
*
* @function
* @see $k.Date#toJSON
**/
$k.FlexDateTime.prototype.toJSON = function(key) { };
/**
* Returns the string representation. Equivalent to valueString()
*
* @function
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {string}
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
**/
$k.FlexDateTime.prototype.toString = function(language) { };
/**
* Returns the date/time as a UTC date/time
* Assumes that this is a local date/time
*
* @function
* @since 4.1.0
**/
$k.FlexDateTime.prototype.toUTC = function() { };
/**
* Returns the date/time as a Javascript date object.
* Assumes that this is an UTC date/time
*
* @function
* @returns {Date}
**/
$k.FlexDateTime.prototype.toUTCDate = function() { };
/**
* Returns the internal millisecond value. Allows comparing date/time values, since the comparision operators call valueOf()
*
* @function
* @returns {number}
**/
$k.FlexDateTime.prototype.valueOf = function() { };
/**
* Returns the string representation
*
* @function
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {string}
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
**/
$k.FlexDateTime.prototype.valueString = function(language) { };
/**
* Parse the date/time string. Both ISO 8601 and localized strings are supported.
*
* @function
* @param {string} string The string representation
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns The parsed date/time
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
* @throws {$k.exception.InvalidValue} If value is invalid
**/
$k.FlexDateTime.parse = function(string, language) { };
/*global $k*/
/**
* A folder which can contain queries, topic collections and other folders
* @class
* @extends $k.PersistentCollection
**/
$k.Folder = function() { };
/**
* Returns the elements which are not folders
*
* @function
* @returns {object[]}
**/
$k.Folder.prototype.leafElements = function() { };
/**
* Returns the subfolders
*
* @function
* @returns {object[]}
**/
$k.Folder.prototype.subfolders = function() { };
/*global $k*/
/**
* An element that can be added to a folder
* @class
**/
$k.FolderElement = function() { };
/**
* Returns the registered ID, or undefined if not registered.
*
* @function
* @returns {string}
**/
$k.FolderElement.prototype.id = function() { };
/**
* Returns the folders that contain this element
*
* @function
* @returns {$k.Folder[]}
**/
$k.FolderElement.prototype.parentFolders = function() { };
/**
* Returns the name of the registry that contains elements of this type
*
* @function
* @returns {string}
**/
$k.FolderElement.prototype.registryType = function() { };
/*global $k*/
/**
* Constructs a geo position with the specified coordinates (in degrees)
*
* @param {number} latitude North-south position
* @param {number} longitude East-west position
* @throws {$k.exception.InvalidValue} If latitude or longitude is not in the range of allowed positions
*
* The value of a geo position attribute.
* @class
**/
$k.GeoPosition = function(latitude, longitude) { };
/**
* Returns the distance to the other position, in meters
*
* @function
* @returns {number}
**/
$k.GeoPosition.prototype.distance = function(position) { };
/**
* Returns true if the values are equal
*
* @function
* @returns {boolean}
**/
$k.GeoPosition.prototype.equals = function(value) { };
/**
* Returns the latitude (north-south position) as degrees
*
* @function
* @returns {number}
**/
$k.GeoPosition.prototype.lat = function() { };
/**
* Returns the longitude (east-west position) as degrees
*
* @function
* @returns {number}
**/
$k.GeoPosition.prototype.long = function() { };
/**
* Set the latitude (north-south position, in degrees)
*
* @function
* @param {number} latitude
**/
$k.GeoPosition.prototype.setLat = function(latitude) { };
/**
* Set the longitude (east-west position, in degrees)
*
* @function
* @param {number} longitude
**/
$k.GeoPosition.prototype.setLong = function(longitude) { };
/**
* Returns the string representation in the specified format ('KML', 'UTM' etc.)
*
* @function
* @param {string} format Name of a supported format
* @returns {string}
* @see $k.GeoRange#formats
**/
$k.GeoPosition.prototype.toFormat = function(format) { };
/*global $k*/
/**
* Represents the value range of a geo position attribute
* @class
* @extends $k.ValueRange
**/
$k.GeoRange = function() { };
/**
* Returns the names of the supported formats
*
* @function
* @returns {string[]}
**/
$k.GeoRange.prototype.formats = function() { };
/**
* Parse the geo position in the specified format and returns the converted value
*
* @function
* @param {string} string The string represantation of the geo position
* @param {string} format The name of a supported format
* @throws {$k.exception.InvalidValue} If the string is not in the range of allowed values of the attribute, or if the format is not supported
* @returns {$k.GeoPosition} The converted value
**/
$k.GeoRange.prototype.parseFormat = function(string, format) { };
/*global $k*/
/**
* Configuration of a graph
* @class
* @extends $k.AbstractEditorConfiguration
**/
$k.GraphConfiguration = function() { };
/**
* Set the node topics
*
* @function
* @since 4.1.0
* @param {$k.SemanticElement[]} semanticElements The topics to add
* @returns {$k.SemanticElement[]} all elements in graph
**/
$k.GraphConfiguration.prototype.addElements = function(semanticElements) { };
/**
* @function
* @since 4.1.0
* @param {object} [keyFilter] Alternative 1: An array of strings defining a filter which property names to include.<br/>
* Alternative 2: An object with "include" and/or "exclude" keys<br/>
* <pre class="code">{"exclude": ["key1", ...]}</pre> includes all but the listed properties, while <pre class="code">{"include": ["key1", ...]}</pre> or <pre class="code">["key1", ...]</pre> includes only the listed properties.
* <br/>Non-optional properties are always included<br/>
* Alternative 3: A JSONRenderContext
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object[]}
**/
$k.GraphConfiguration.prototype.categories = function(keyFilter, detailFilter) { };
/**
* Collapse neigbours from node
*
* @function
* @since 4.1.0
* @param {object} semanticElement The element to collapse
* @returns {object[]} The collapsed graph objects
**/
$k.GraphConfiguration.prototype.collapse = function(semanticElement) { };
/**
* @since 4.1.0
* @function
* @returns {$k.SemanticElement}
**/
$k.GraphConfiguration.prototype.configElement = function() { };
/**
* Add some JSON to each element
*
* @function
* @since 4.3.0
* @param {object[]} elements The elements to be decorated
* @param {object} decoration some JSON
**/
$k.GraphConfiguration.prototype.decorateElements = function(elements, decoration) { };
/**
* Expand Node to its neighbours
*
* @function
* @since 4.1.0
* @param {object[]} semanticElements The element to expand
* @param {Integer} [depth] The depth to expand
* @returns {object[]} The expanded graph objects
**/
$k.GraphConfiguration.prototype.expand = function(semanticElements, depth) { };
/**
* Expand the Nodes to their neighbours
*
* @function
* @since 4.1.0
* @param {integer} [expandDepth] The depth to expand the semantic objects via their connection, default value is 1
* @returns {object[]} The expanded graph objects
**/
$k.GraphConfiguration.prototype.expandNodes = function(expandDepth) { };
/**
* Returns the possible relationtypes by targetTopic
*
* @function
* @since 4.1.0
* @param {semanticElement} sourceTopic Wissensnetzelement
* @param {object} [keyFilter] Alternative 1: An array of strings defining a filter which property names to include.<br/>
* Alternative 2: An object with "include" and/or "exclude" keys<br/>
* <pre class="code">{"exclude": ["key1", ...]}</pre> includes all but the listed properties, while <pre class="code">{"include": ["key1", ...]}</pre> or <pre class="code">["key1", ...]</pre> includes only the listed properties.
* <br/>Non-optional properties are always included<br/>
* Alternative 3: A JSONRenderContext
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object[]} Map with key: target Topic value: Array with possibleRelationTypes
**/
$k.GraphConfiguration.prototype.possibleRelationTargets = function(sourceTopic, keyFilter, detailFilter) { };
/**
* Renders the graph node as literal objects
*
* @function
* @since 4.1.0
* @param {object} [keyFilter] Alternative 1: An array of strings defining a filter which property names to include.<br/>
* Alternative 2: An object with "include" and/or "exclude" keys<br/>
* <pre class="code">{"exclude": ["key1", ...]}</pre> includes all but the listed properties, while <pre class="code">{"include": ["key1", ...]}</pre> or <pre class="code">["key1", ...]</pre> includes only the listed properties.
* <br/>Non-optional properties are always included<br/>
* Alternative 3: A JSONRenderContext
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object[]} The rendered graph objects
**/
$k.GraphConfiguration.prototype.render = function(keyFilter, detailFilter) { };
/**
* @function
* @since 4.1.0
* @returns {semanticElement[]}
**/
$k.GraphConfiguration.prototype.semanticElements = function() { };
/**
* Returns the graph configuration for the context)
*
* @function
* @since 4.1.0
* @param {$k.SemanticElement} [context] Context of the configuration
* @returns {$k.GraphConfiguration}
**/
$k.GraphConfiguration.forContext = function(context) { };
/**
* Returns the confguration defined by the element
*
* @function
* @since 4.1.0
* @param {$k.SemanticElement} configurationElement The configuration element
* @returns {$k.GraphConfiguration}
**/
$k.GraphConfiguration.from = function(configurationElement) { };
/*global $k*/
/**
* A condition that selects elements that have attributes of a specific type.
* @class
* @extends $k.HasPropertyCondition
**/
$k.HasAttributeCondition = function() { };
/**
* Add a value condition. Note that an attribute conditon can only have one value conditon.
*
* @function
* @since 4.1.0
* @param [parameter] Parameter name of the value
* @param {string} [operator] Name of operator
* @param [defaultValue] Default value if no parameter is specified
* @throws {$k.exception.QueryError} If the condition is not valid
* @returns {$k.AttributeValueCondition}
**/
$k.HasAttributeCondition.prototype.addValue = function(parameter, operator, defaultValue) { };
/**
* Returns the attribute value condition, or undefined if there is none
*
* @function
* @since 4.1.0
* @returns {$k.AttributeValueCondition}
**/
$k.HasAttributeCondition.prototype.valueCondition = function() { };
/*global $k*/
/**
* @class
**/
$k.Hash = function() { };
/**
* Calculates the digest of the data passed to this object.
*
* @function
* @param {string} [encoding] Optional encoding of the output.
* @returns {string} If no encoding is given, an array of integers is returned, otherwise a string with the given encoding.
* @version Experimental feature, might be removed at any time
**/
$k.Hash.prototype.digest = function(encoding) { };
/**
* Hashes the given data. This is a shorthand for calling reset, update and digest and changes the object state.
*
* @function
* @param {string} data The data to hash.
* @param {string} [inputEncoding] Optional input encoding.
* @param {string} [outputEncoding] Optional output encoding.
* @returns {string} The hashed data as array of integers.
* @version Experimental feature, might be removed at any time
**/
$k.Hash.prototype.hash = function(data, inputEncoding, outputEncoding) { };
/**
* Resets the hash to its initial state.
*
* @function
* @returns {$k.Hash} The hash itself.
* @version Experimental feature, might be removed at any time
**/
$k.Hash.prototype.reset = function() { };
/**
* Adds the given data to the hash.
*
* @function
* @param {string} data The data to hash.
* @param {string} [encoding] Optional input encoding.
* @returns {$k.Hash} The hash object itself.
* @version Experimental feature, might be removed at any time
**/
$k.Hash.prototype.update = function(data, encoding) { };
/*global $k*/
/**
* A condition that selects elements that have properties of a specific type.
* <p/>
* The linked query of this conditon is the subquery for the properties. This allows to add meta property conditions.
* @class
* @extends $k.LinkedQueryCondition
**/
$k.HasPropertyCondition = function() { };
/**
* Add a handle
*
* @function
* @since 5.3.0
* @version Experimental feature, might be removed at any time
* @param {string} parameter
* @returns {Condition}
**/
$k.HasPropertyCondition.prototype.addHandle = function(parameter) { };
/**
* Returns the desired cardinality of the property
*
* @function
* @since 4.1.0
* @returns {number}
**/
$k.HasPropertyCondition.prototype.cardinality = function() { };
/**
* Sets the desired cardinality of the property. Only applied if a cardinality operator is used.
*
* @function
* @since 4.1.0
* @param {number} cardinality Cardinality. Must be an integer >= 0.
**/
$k.HasPropertyCondition.prototype.setCardinality = function(cardinality) { };
/*global $k*/
/**
* A condition that selects elements that have relations of a specific type.
* @class
* @extends $k.HasPropertyCondition
**/
$k.HasRelationCondition = function() { };
/**
* Set the transitivity of the relation. This defines how many relations are traversed.
*
* @function
* @since 4.1.0
* @param {number} [min] Minimal number of relations to traverse. If undefined, at least one relation must exist. Must be an integer >= 1.
* @param {number} [max] Maximum number of relations to traverse. If undefined or INF, any number of relations are traversed. Must be INF or an integer >= 1 and >= min
* @param {boolean} [boolean] True if only the shortest path between two elements should be traversed
**/
$k.HasRelationCondition.prototype.setTransitivity = function(min, max, boolean) { };
/**
* Returns the subquery for the relation target, or undefined if there is none
*
* @function
* @since 4.1.0
* @returns {$k.StructuredQuery}
**/
$k.HasRelationCondition.prototype.targetQuery = function() { };
/*global $k*/
/**
* Huhu
* @class
**/
$k.HistoryChangeLogEntry = function() { };
/**
* Get description of a log entry
*
* @since 5.2.0
* @function
* @returns {string}
**/
$k.HistoryChangeLogEntry.prototype.description = function() { };
/**
* Get event tag of a log entry
*
* @since 5.2.0
* @function
* @returns {string}
**/
$k.HistoryChangeLogEntry.prototype.eventTag = function() { };
/**
* Get event type of a log entry
*
* @since 5.2.0
* @function
* @returns {string}
**/
$k.HistoryChangeLogEntry.prototype.eventType = function() { };
/**
* Get event type of a log entry in active language
*
* @since 5.2.0
* @function
* @returns {string}
**/
$k.HistoryChangeLogEntry.prototype.eventTypeString = function() { };
/**
* Get language of a log entry
*
* @since 5.2.0
* @function
* @returns {string}
**/
$k.HistoryChangeLogEntry.prototype.language = function() { };
/**
* Get new value of a log entry
*
* @since 5.2.0
* @function
* @returns {string}
**/
$k.HistoryChangeLogEntry.prototype.newValue = function() { };
/**
* Get old value of a log entry
*
* @since 5.2.0
* @function
* @returns {string}
**/
$k.HistoryChangeLogEntry.prototype.oldValue = function() { };
/**
* Get operation string of a log entry
*
* @since 5.2.0
* @function
* @returns {string}
**/
$k.HistoryChangeLogEntry.prototype.operationString = function() { };
/**
* Get property of a log entry
*
* @since 5.2.0
* @function
* @returns {property}
**/
$k.HistoryChangeLogEntry.prototype.property = function() { };
/**
* Get property type of a log entry
*
* @since 5.2.0
* @function
* @returns {type}
**/
$k.HistoryChangeLogEntry.prototype.propertyType = function() { };
/**
* Get timestamp of a log entry
*
* @since 5.2.0
* @function
* @returns {instance}
**/
$k.HistoryChangeLogEntry.prototype.timestamp = function() { };
/**
* Get accessed topic of a log entry
*
* @since 5.2.0
* @function
* @returns {instance}
**/
$k.HistoryChangeLogEntry.prototype.topic = function() { };
/**
* Get user of a log entry
*
* @since 5.2.0
* @function
* @returns {instance}
**/
$k.HistoryChangeLogEntry.prototype.user = function() { };
/*global $k*/
/**
* Creates a new hit
*
* @param {$k.SemanticElement} semanticElement Semantic element of the hit
* @param {number} quality Quality of the hit. If undefined, 1 will be set as quality
* @throws {$k.exception.InvalidValue} If the quality is not between 0 and 1
* @throws {$k.exception.TypeError} If the argument is not a semantic element
*
* Provides details about a topic returned by a query.
* Each hit has a quality between 0 (worst quality) and 1 (best quality).
* Additional details are attached as causes.
* @class
**/
$k.Hit = function(semanticElement, quality) { };
/**
* Add a cause
*
* @function
* @param {$k.Cause} cause
**/
$k.Hit.prototype.addCause = function(cause) { };
/**
* Returns the attribute type of the hit
*
* @since 5.2.2
* @function
* @returns {$k.AttributeType}
**/
$k.Hit.prototype.attributeType = function() { };
/**
* Returns the cause of this hit with the given type, or undefined if no or more than one cause exists
*
* @function
* @returns {$k.Cause[]}
**/
$k.Hit.prototype.causeOfType = function(type) { };
/**
* Returns the elements of all properties matching the given property-keys of all (custom-) causes of this hit
*
* @since 5.3.0
* @function
* @param {string[]} [propertyKeys] property keys
* @returns {$k.SemanticElement[]}
**/
$k.Hit.prototype.causePropertyElements = function(propertyKeys) { };
/**
* Returns the causes of this hit
*
* @function
* @returns {$k.Cause[]}
**/
$k.Hit.prototype.causes = function() { };
/**
* Returns the causes of this hit with the given type
*
* @function
* @returns {$k.Cause[]}
**/
$k.Hit.prototype.causesOfType = function(type) { };
/**
* The semantic element associated with this hit
*
* @since 4.3.0
* @function
* @returns {$k.SemanticElement}
**/
$k.Hit.prototype.element = function() { };
/**
* Returns the language of the hit for translated attributes,
* or undefined if not translated
*
* @since 5.2.2
* @function
* @returns {string}
**/
$k.Hit.prototype.language = function() { };
/**
* Returns the quality of the hit, a number between 0 (worst quality) and 1 (best quality)
*
* @function
* @returns {number}
**/
$k.Hit.prototype.quality = function() { };
/**
* Set the semantic element associated with this hit
*
* @function
* @param {$k.SemanticElement} semanticElement Semantic element of the hit
* @throws {$k.exception.TypeError} If the argument is not a semantic element
**/
$k.Hit.prototype.setElement = function(semanticElement) { };
/**
* Set the quality, a number between 0 and 1
*
* @function
* @param {number} quality
* @throws {$k.exception.InvalidValue} If the quality is not between 0 and 1
**/
$k.Hit.prototype.setQuality = function(quality) { };
/**
* Returns a snippet of the content which contains the matching term(s)
*
* @since 4.4.0
* @function
* @param {string} startTag Text which should be inserted before matching terms in the snippet.
* @param {string} endTag Text which should be inserted before matching terms in the snippet
* @param {number} maxFragmentLength Maximum length of a text fragment in the snippet excluding start and end tags
* @param {number} maxFragments Maximum number of text fragements in a snippet
* @param {string} fragmentSeparator Separator
* @param {string} maxDocCharsToAnalyze Maximum text length for snippet search
* @returns {String}
**/
$k.Hit.prototype.snippet = function(startTag, endTag, maxFragmentLength, maxFragments, fragmentSeparator, maxDocCharsToAnalyze) { };
/**
* Map each hit to a semantic element. Equivalent to (but much faster than)
* <pre><code>hits(function(h) { return h.element())</code></pre>
*
* @function
* @param {$k.Hit[]} hits Hits. Elements are accepted, too (returns the element itself).
* @returns {$k.SemanticElement[]}
* @since 5.3.1
**/
$k.Hit.unwrap = function(hits) { };
/**
* Map each element to a hit. Equivalent to (but much faster than)
* <pre><code>elements.map(function(e) { return new $k.Hit(e, q) })</code></pre>
*
* @function
* @param {$k.SemanticElement[]} elements Element. Hits are accepted, too (returns the hit itself).
* @param {number} [quality] Quality of each hit
* @returns {$k.Hit[]}
* @since 5.3.1
**/
$k.Hit.wrap = function(elements, quality) { };
/*global $k*/
/**
* A single connection to a HTTP server.
* @class
**/
$k.HttpConnection = function() { };
/**
* Sends the requests in an asynchronous manner. Neither waits for sending the request nor for receiving the response.
* Check the log file for errors (channel "javascript").
*
* @function
* @param {$k.HttpRequest} request
* @throws {URIError} If the URI is not allowed
* @since 5.2.2
**/
$k.HttpConnection.prototype.asyncRequest = function(request) { };
/**
* Set the username and password
*
* @function
* @param {string} username
* @param {string} password
* @since 4.0.3
**/
$k.HttpConnection.prototype.authenticate = function(username, password) { };
/**
* Set the username and password from a volume encrypted authenication string
*
* @function
* @param {string} encryptedAccount Encrypted account (Base64 encoded string generated in the Admin-Tool)
* @since 5.2.1
**/
$k.HttpConnection.prototype.authenticateFromEncrypedAccount = function(encryptedAccount) { };
/**
* Sends the requests and returns a reponse
*
* @function
* @param {$k.HttpRequest} request
* @returns {$k.HttpResponse} The response for the request
* @throws {$k.exception.HttpError} If no response was received (timeout etc.)
* @throws {URIError} If the URI is not allowed
* @deprecated Use <code>request()</code>
* @see $k.HttpConnection#request
**/
$k.HttpConnection.prototype.getResponse = function(request) { };
/**
* Use negotiate mechanism for authentication with the proxy
*
* @function
* @since 5.3.2
**/
$k.HttpConnection.prototype.proxyUseNegotiate = function() { };
/**
* Sends the requests and returns a reponse
* <p/>
* Only HTTP(S) requests are allowed. If the URI uses another protocol (e.g. 'file'), then an URIError is raised.
* <p/>
* It is possible to restrict the domains that can be accessed by adding the following to the configuration file of a client (bridge etc.):
* <pre><code>
* [script]
* allowedOutgoingDomains=*.intelligent-views.com,ivinternal:8080
* </code></pre>
*
*
* @function
* @param {$k.HttpRequest} request
* @returns {$k.HttpResponse} The response for the request
* @throws {$k.exception.HttpError} If no response was received (timeout etc.)
* @throws {URIError} If the URI is not allowed
* @since 5.3
**/
$k.HttpConnection.prototype.request = function(request) { };
/**
* Set the proxy data to use for this connection: host, port, type, credentials
*
* @function
* @param {string} [host] name of the proxy host, if omitted deactivates proxy
* @param {number} [port] port of the proxy, default 3128
* @param {string} [type] type of the proxy http/https, default "http"
* @param {string} [credentials] encrypted account (base64 encoded string generated in the Admin-Tool)
* @throws {$k.exception.InvalidValue} An argument has an invalid value
* @since 5.3.2
**/
$k.HttpConnection.prototype.setProxy = function(host, port, type, credentials) { };
/**
* Set the timeout in milliseconds for connection to wait for reponses
*
* @function
* @param {number} timeout number of milliseconds to wait for reponses, default 20000
* @since 4.2.0
**/
$k.HttpConnection.prototype.setTimeout = function(timeout) { };
/**
* Use negotiate mechanism for authentication
*
* @function
* @since 5.2.2
**/
$k.HttpConnection.prototype.useNegotiate = function() { };
/*global $k*/
/**
* Creates a new request
*
* @param {string} url HTTP(S) URL
* @param {string} [method] Request method (GET, POST etc.). If undefined, GET is used
* @param {object} [queryData] Query data
* @throws {$k.exception.InvalidValue} If the URL is invalid
*
* A HTTP request
* @class
* @extends $k.NetEntity
**/
$k.HttpRequest = function(url, method, queryData) { };
/**
* Returns the cookies as an object. The name of a property is the cookie name
*
* @function
* @returns {object}
**/
$k.HttpRequest.prototype.cookies = function() { };
/**
* Returns the requests HTTP method
*
* @function
* @returns {string} HTTP method value of this request
**/
$k.HttpRequest.prototype.method = function() { };
/**
* Returns the query data of the request as an object.
* If the request method is GET, then this is equivalent to urlQueryData().
* For other methods it returns application/x-www-form-urlencoded key/value pairs
*
* @function
* @returns {object}
* @see $k.HttpRequest#urlQueryData
* @see $k.NetEntity#formData
**/
$k.HttpRequest.prototype.queryData = function() { };
/**
* Sets the url-encoded form data of the request
*
* @function
* @param {object} formData
**/
$k.HttpRequest.prototype.setFormData = function(formData) { };
/**
* Sets the query data of the URI.
* Each property is added as a query parameter (key=value).
* If the value of a property is an arry, then a key=value pair is added for each array element.
*
* @function
* @param {object} queryData
**/
$k.HttpRequest.prototype.setQueryData = function(queryData) { };
/**
* Sets the URL
*
* @function
* @param {string} url
* @throws {$k.exception.InvalidValue} If the URL is not valid
**/
$k.HttpRequest.prototype.setUrl = function(url) { };
/**
* Returns the full URL
*
* @function
* @returns {string}
**/
$k.HttpRequest.prototype.url = function() { };
/**
* Returns the URL query data of the URI as an object.
* Each key=value pair is added as a property.
* If a key appears more than once, then the value is an array with all elements
*
* @function
* @returns {object}
* @see $k.HttpRequest#queryData
**/
$k.HttpRequest.prototype.urlQueryData = function() { };
/**
* Creates a new request. THe URL must be already URL-encoded by the sender
*
* @since 5.3.2
* @version Experimental feature, might be removed at any time
* @function
* @param {string} url HTTP(S) URL
* @param {string} [method] Request method (GET, POST etc.). If undefined, GET is used
* @param {object} [queryData] Query data
* @throws {$k.exception.InvalidValue} If the URL is invalid
**/
$k.HttpRequest.fromEncodedURL = function(url, method, queryData) { };
/*global $k*/
/**
* A HTTP response
* @class
* @extends $k.NetEntity
**/
$k.HttpResponse = function() { };
/**
* Returns the status code of the response
*
* @function
* @returns {number}
**/
$k.HttpResponse.prototype.code = function() { };
/**
* Returns true if the code indicates a successful response (2xx), false otherwise
*
* @function
* @returns {boolean}
**/
$k.HttpResponse.prototype.isSuccess = function() { };
/**
* Set the status code of the response
*
* @function
* @param {number} code
* @throws {$k.exception.InvalidValue} If the code is not a valid HTTP status code
**/
$k.HttpResponse.prototype.setCode = function(code) { };
/**
* Set the status code of the response to 400 (Bad request). Equivalent to setCode($k.HttpResponse.BAD_REQUEST)
*
* @function
**/
$k.HttpResponse.prototype.setCodeBadRequest = function() { };
/**
* Set the status code of the response to 404 (Not found). Equivalent to setCode($k.HttpResponse.NOT_FOUND)
*
* @function
**/
$k.HttpResponse.prototype.setCodeNotFound = function() { };
/**
* Set the status code of the response to 304 (Not Modified). Equivalent to setCode($k.HttpResponse.NOT_MODIFIED)
*
* @function
**/
$k.HttpResponse.prototype.setCodeNotModified = function() { };
/**
* Set the status code of the response to 200 (Ok). Equivalent to setCode($k.HttpResponse.OK)
*
* @function
**/
$k.HttpResponse.prototype.setCodeOk = function() { };
/**
* Set the status code of the response to 401 (Unauthorized). Equivalent to setCode($k.HttpResponse.UNAUTHORIZED)
*
* @function
**/
$k.HttpResponse.prototype.setCodeUnauthorized = function() { };
/**
* Add the cookie to the response, instructing the client to set the cookie
*
* @function
* @param {$k.NewCookie} cookie The new cookie
* @throws {$k.exception.TypeError} If the cookie is not a valid new cookie
**/
$k.HttpResponse.prototype.setCookie = function(cookie) { };
/**
* Status code 400 Bad Request
**/
$k.HttpResponse.BAD_REQUEST = 400;
/**
*
* Status code 500 Internal Server Error
**/
$k.HttpResponse.INTERNAL_SERVER_ERROR = 500;
/**
*
* Status code 404 Not Found
**/
$k.HttpResponse.NOT_FOUND = 404;
/**
*
* Status code 304 Not Modified
**/
$k.HttpResponse.NOT_MODIFIED = 304;
/**
*
* Status code 200 OK
**/
$k.HttpResponse.OK = 200;
/**
*
* Status code 401 Unauthorized
**/
$k.HttpResponse.UNAUTHORIZED = 401;
/*global $k*/
/**
* Creates a new InfluxDB cient
*
* @param {string} database Name of the database
* @param {string} [url] URL of the InfluxDB server. Default: http://localhost:8086
* @since 5.2.2
*
* @class
**/
$k.InfluxClient = function(database, url) { };
/**
* Set the username and password from a volume encrypted authenication string
*
* @function
* @param {string} encryptedAccount Encrypted account (Base64 encoded string generated in the Admin-Tool)
* @since 5.2.2
**/
$k.InfluxClient.prototype.authenticateFromEncrypedAccount = function(encryptedAccount) { };
/**
* Executes an InfluxDB query
*
* @function
* @param {string} query Influx query
* @since 5.2.2
**/
$k.InfluxClient.prototype.query = function(query) { };
/**
* Set the retentionPolicy
*
* @function
* @param {string} policy The name of a retention policy
* @since 5.2.2
**/
$k.InfluxClient.prototype.setRetentionPolicy = function(policy) { };
/**
* Set the delay before actually writing datapoints to InfluxDB. All datapoints written during this timespan are combined to a single write request.
*
* @function
* @param {number} delay Number of seconds
* @since 5.2.2
**/
$k.InfluxClient.prototype.setWriteDelay = function(delay) { };
/**
* Write datapoints to InfluxDB
*
* @function
* @param {object[]} datapoints List of datapoints objects:<pre><code> [ {measurement: "m", fields: { }, tags: { } ]</code></pre>
* @since 5.2.2
**/
$k.InfluxClient.prototype.writePoints = function(datapoints) { };
/*global $k*/
/**
* Create a new instance of the type
*
* @since 5.1.1
* @param type Type or internal name
* @param {string} [param] The name of the new instance
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @param {object} [options] Options
* <ul>
* <li> cluster: {$k.SemanticElement} Store the new instance the cluster of the element</li>
* </ul>
* @returns {$k.Instance} The created instance
* @throws {$k.exception.SchemaError} If the type is abstract
* @throws {$k.exception.AccessDenied} If creating an instance is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
*
* Represents an instance.
* @class
* @extends $k.SemanticElement
**/
$k.Instance = function(type, name, language, options) { };
/**
* Change type
*
* @function
* @param jseType Type or internal name
* @param {boolean} [ignoreLossOfProperties] Ignore loss of properties; default: false
* @returns {boolean} True if properties have been lost
* @since 5.3.0
**/
$k.Instance.prototype.changeType = function(jseType, ignoreLossOfProperties) { };
/**
* Create a copy of me
*
* @function
* @returns {$k.Instance}
* @throws {$k.exception.ObjectRemoved} If instance got obsolete on the way here
* @throws {$k.exception.AccessDenied} If current user is not allowed to create a new instance of this instance's type
* @throws {$k.exception.RuntimeError} If anything bad happens during copy
**/
$k.Instance.prototype.copy = function() { };
/**
* Create copies of the named properties at the target
*
* @function
* @param {string[]} propertyNames PropertyTypes or internal names
* @param {$k.Instance} target Target object
* @returns {$k.Instance}
* @throws {$k.exception.RuntimeError} If anything bad happens during copy
**/
$k.Instance.prototype.copyProperties = function(propertyNames, target) { };
/**
* Create an extension of the given type
*
* @function
* @param type Type or internal name
* @returns {$k.Instance[]}
* @throws {$k.exception.SchemaError} If "type" is not a possible extension
* @throws {$k.exception.TypeError} If "type" is not a type or internal name
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.Instance.prototype.createExtension = function(type) { };
/**
* Returns the domain of the instance
*
* @function
* @returns {$k.Domain}
* @since 4.1.0
**/
$k.Instance.prototype.domain = function() { };
/**
* Returns the extension instances
*
* @function
* @returns {$k.Instance[]}
**/
$k.Instance.prototype.extensions = function() { };
/**
* Returns all possible extension types
*
* @function
* @returns {$k.Type[]}
**/
$k.Instance.prototype.possibleExtensions = function() { };
/*global $k*/
/**
* Represents a type of instances
* @class
* @extends $k.Type
**/
$k.InstanceType = function() { };
/**
* Create a new instance of this type
*
* @function
* @param {string} [param] The name of the new instance
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @param {object} [options] Options
* <ul>
* <li> cluster: {$k.SemanticElement} Store the new instance the cluster of the element</li>
* </ul>
* @returns {$k.Instance} The created instance
* @throws {$k.exception.SchemaError} If the type is abstract
* @throws {$k.exception.AccessDenied} If creating an instance is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.InstanceType.prototype.createInstance = function(param, language, options) { };
/**
* Create a new subtype
*
* @function
* @param {string} [param] The name of the new type
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {$k.Type} The created type
* @throws {$k.exception.SchemaError} If subtypes cannot be created
* @throws {$k.exception.AccessDenied} If creating a subtype is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.InstanceType.prototype.createSubtype = function(param, language) { };
/**
* Returns the types that can be extended by this type or a subtype.
* Does not check if this type allows to create extensions
*
* @function
* @returns {$k.InstanceType[]}
* @see $k.Type#canCreateExtensions
**/
$k.InstanceType.prototype.extendedTypes = function() { };
/**
* Returns the types that can extend instances of this type.
* Does not check if these types allow to create extensions
*
* @function
* @returns {$k.InstanceType[]}
* @see $k.Type#canCreateExtensions
**/
$k.InstanceType.prototype.extensionTypes = function() { };
/*global $k*/
/**
* Provides interaction for actions
* @class
**/
$k.Interaction = function() { };
/**
* Creates an editor on the element
*
* @function
* @param {$k.SemanticElement} element
**/
$k.Interaction.prototype.createEditor = function(element) { };
/*global $k*/
/**
* Constructs an interval from start to stop
*
* @param start The lower endpoint
* @param stop The upper endpoint
*
* An interval representing all values between two endpoints. One endpoint may be undefined.
* @class
**/
$k.Interval = function(start, stop) { };
/**
* Returns true if the values are equal
*
* @function
* @returns {boolean}
**/
$k.Interval.prototype.equals = function(value) { };
/**
* Sets the lower endpoint. Pass undefined to denote an interval without lower endpoint
*
* @function
* @param start
**/
$k.Interval.prototype.setStart = function(start) { };
/**
* Sets the upper endpoint. Pass undefined to denote an interval without upper endpoint
*
* @function
* @param stop
**/
$k.Interval.prototype.setStop = function(stop) { };
/**
* Returns the lower endpoint, or undefined if the interval has no lower endpoint.
*
* @function
**/
$k.Interval.prototype.start = function() { };
/**
* Returns the upper endpoint , or undefined if the interval has no upper endpoint.
*
* @function
**/
$k.Interval.prototype.stop = function() { };
/*global $k*/
/**
* Represents the value range of an interval attribute
* @class
* @extends $k.ValueRange
**/
$k.IntervalRange = function() { };
/**
* Returns the value range of the interval endpoints
*
* @function
* @returns {$k.ValueRange}
**/
$k.IntervalRange.prototype.endpointRange = function() { };
/*global $jni*/
/**
* Represents a Java class
* @class
**/
$jni.JavaClass = function() { };
/**
* Returns the static member of the class
*
* @function
* @param {string} name
* @returns {$jni.JavaObject}
**/
$jni.JavaClass.prototype.getStatic = function(name) { };
/**
* Returns the name of the class
*
* @function
* @returns {string}
**/
$jni.JavaClass.prototype.name = function() { };
/**
* Returns a JavaScript representation of the object
*
* @function
* @returns {object}
**/
$jni.JavaClass.prototype.toJS = function() { };
/*global $jni*/
/**
* Creates a new instance of a java class. This constructor is only needed for creating Java instances of classes that have not been imported with use().
*
* @param {string} className The name of the class of the object to construct
* @param varargs Constructor arguments
* @see $jni.use
*
* Represents a Java instance
* @class
**/
$jni.JavaObject = function(varargs) { };
/**
* Returns a JavaScript representation of the object
*
* @function
* @returns {object}
**/
$jni.JavaObject.prototype.toJS = function() { };
/*global $jni*/
/**
* Represent an array of primitive types (byte[], char[] etc.)
* @class
**/
$jni.JavaPrimitiveArray = function() { };
/**
* Returns a JavaScript representation of the object
*
* @function
* @returns {object}
**/
$jni.JavaPrimitiveArray.prototype.toJS = function() { };
/*global $k*/
/**
* Context for rendering JSON
* @class
**/
$k.JSONRenderContext = function() { };
/**
* Get the global context
*
* @deprecated Use <code>session()</code> instead
* @function
* @returns {Array}
**/
$k.JSONRenderContext.prototype.globalContext = function() { };
/**
* Returns the global parameters. <p/>WARNING: This function is highly experimental
*
* @function
* @returns {Object}
* @since 5.1.3
* @version Experimental feature, might be removed at any time
**/
$k.JSONRenderContext.prototype.globalParameters = function() { };
/**
* Get the session
*
* @function
* @returns {$k.Session}
**/
$k.JSONRenderContext.prototype.session = function() { };
/**
* Set filters
*
* @function
* @param {object} keyFilter Alternative 1: An array of strings defining a filter which property names to include.<br/>
* Alternative 2: An object with "include" and/or "exclude" keys<br/>
* <pre class="code">{"exclude": ["key1", ...]}</pre> includes all but the listed properties, while <pre class="code">{"include": ["key1", ...]}</pre> or <pre class="code">["key1", ...]</pre> includes only the listed properties.
* <br/>Non-optional properties are always included<br/>
* Alternative 3: A JSONRenderContext
* @returns {$k.JSONRenderContext}
**/
$k.JSONRenderContext.prototype.setFilters = function(keyFilter) { };
/**
* Set the global context
*
* @deprecated Use <code>setSession()</code> instead
* @function
* @param {object[]} jseGlobalContext
* @returns {$k.JSONRenderContext}
**/
$k.JSONRenderContext.prototype.setGlobalContext = function(jseGlobalContext) { };
/**
* Set levels of detail, e.g. [ "propertyList", "schema" ]
*
* @function
* @param {string[]} levelsOfDetail
* @returns {$k.JSONRenderContext}
**/
$k.JSONRenderContext.prototype.setLevelsOfDetail = function(levelsOfDetail) { };
/**
* Set preferred locator types, e.g. [ "propertyList", "schema" ]
*
* @function
* @param {string[]} preferredLocatorTypes
* @returns {$k.JSONRenderContext}
**/
$k.JSONRenderContext.prototype.setPreferredLocatorTypes = function(preferredLocatorTypes) { };
/**
* Set the session
*
* @function
* @param {object} session Either a JSON object or a Session
**/
$k.JSONRenderContext.prototype.setSession = function(session) { };
/*global $k*/
/**
* Creates a new token
*
* @param {$k.User} [user]
* @param {object} [expiry] Either a number (expiry in seconds since the current date), or a date. Default is 24 hours
* @param {object} [claims]
* @version Experimental feature, might be removed at any time
* @since 5.1.0
*
* Generate and verify JSON web tokens for REST requests
* @class
**/
$k.JWT = function(user, expiry, claims) { };
/**
* Adds additional claims. Overwrites claims with the same name
*
* @function
* @param {object} claims
* @version Experimental feature, might be removed at any time
* @since 5.1.0
**/
$k.JWT.prototype.addClaims = function(claims) { };
/**
* Returns the payload object
*
* @function
* @returns {object}
* @throws {$k.exception.InvalidValue} If the payload is not valid JSON
* @version Experimental feature, might be removed at any time
* @since 5.1.0
**/
$k.JWT.prototype.payload = function() { };
/**
* Set the expiry claim of the token
*
* @function
* @param {object} expiry Either a number (expiry in seconds since the current date), or a date
* @version Experimental feature, might be removed at any time
* @since 5.1.0
**/
$k.JWT.prototype.setExpiry = function(expiry) { };
/**
* Sets the payload object
*
* @function
* @version Experimental feature, might be removed at any time
* @since 5.2.2
**/
$k.JWT.prototype.setPayload = function(data) { };
/**
* Set the renew claim of the token
*
* @function
* @param {object} duration Duration in seconds
* @version Experimental feature, might be removed at any time
* @deprecated Do not use any more. This custom claim is not used.
* @since 5.1.0
**/
$k.JWT.prototype.setRenew = function(duration) { };
/**
* Set the subject claim of the token
*
* @function
* @param {string} subject Subject
* @version Experimental feature, might be removed at any time
* @since 5.1.0
**/
$k.JWT.prototype.setSubject = function(subject) { };
/**
* Set the ID of the user as the subject of the token. Do not use if a REST service expects a different subject value (e.g. E-Mail).
*
* @function
* @param {$k.User} user
* @version Experimental feature, might be removed at any time
* @since 5.1.0
**/
$k.JWT.prototype.setUser = function(user) { };
/**
* Signs the token.
* <p/>
* This method does not check the authentication of the user. This allows custom authentication mechanisms.
* Use $k.User.getAuthenticatedUser() for built-in username/password checking.
*
* @function
* @param {string} [key] Encoded key. If not provided, a volume specific persistent key is used. Available since 5.2.2.. </p>
* Expected formats:
* <ul>
* <li>Symmetric key (e.g. HS256): base64 encoded secret key</li>
* <li>Public key: PEM-encoded certificate</li>
* <li>Private key: PEM-encoded private key</li>
* </ul>
* @param {string} [algorithm] Algorithm to use. Default is HS256. Available since 5.2.2.
* @returns {string} Signed, encoded token (<header>.<payload>.<signature>)
* @see $k.User#getAuthenticatedUser
* @version Experimental feature, might be removed at any time
* @since 5.1.0
**/
$k.JWT.prototype.sign = function(key, algorithm) { };
/**
* Verifies the token.
*
* @function
* @param {object} [expectedClaims] Expected claims. If undefined then only expiry will be checked.
* @param {string} [key] Encoded key. If not provided, a volume specific persistent key is used. Available since 5.2.2.. </p>
* Expected formats:
* <ul>
* <li>Symmetric key (e.g. HS256): base64 encoded secret key</li>
* <li>Public key: PEM-encoded certificate</li>
* <li>Private key: PEM-encoded private key</li>
* </ul>
* @param {string} [algorithm] Algorithm to use. Default is HS256. Available since 5.2.2.
* @throws {$k.exception.AccessDenied} If the token could not be verified (e.g. invalid token or unsupported algorithm)
* @version Experimental feature, might be removed at any time
* @since 5.1.0
**/
$k.JWT.prototype.verify = function(expectedClaims, key, algorithm) { };
/**
* Creates persistent keys for signing
*
* @function
* @param {boolean} [overwrite] True (default) if existing keys should be overwritten, false if keys should only be generated if there are no keys yet.
* @throws {$k.exception.AccessDenied} If generating keys is not allowed
* @version Experimental feature, might be removed at any time
* @since 5.1.0
**/
$k.JWT.createKeys = function(overwrite) { };
/**
* Parses an encoded token. Does not check its validity.
*
* @function
* @param {string} encodedToken
* @returns {JSONWebToken} Token
* @throws {$k.exception.InvalidValue} If the string is not a valid token
* @version Experimental feature, might be removed at any time
* @since 5.1.0
**/
$k.JWT.parse = function(encodedToken) { };
/**
* Verifies the token. Shortcut for $k.JWT.parse(token).verify(claims, key)
*
* @function
* @param {string} token Token to verify
* @param {object} [expectedClaims] Expected claims.
* @param {string} [key] Encoded key. If not provided, a volume specific persistent key is used. Available since 5.2.2.. </p>
* Expected formats:
* <ul>
* <li>Symmetric key (e.g. HS256): base64 encoded secret key</li>
* <li>Public key: PEM-encoded certificate</li>
* <li>Private key: PEM-encoded private key</li>
* </ul>
* @throws {$k.exception.AccessDenied} If the token could not be verified
* @version Experimental feature, might be removed at any time
* @deprecated Use $k.JWT.parse(token).verify(claims, key)
* @since 5.1.0
**/
$k.JWT.verify = function(token, expectedClaims, key) { };
/*global $k*/
/**
* @class
**/
$k.KScript = function() { };
/**
* Calls the KScript
*
* @function
* @param {contextObject} [contextObject] Object that will be bound to the current object of the KScript
* @param {object} [variables] Variables passed to the KScript environment
**/
$k.KScript.prototype.call = function(contextObject, variables) { };
/**
* Calls a function of the KScript
*
* @function
* @param {string} functionName Name of the function
* @param {object[]} [parameters] Parameters passed to the function
* @param {object} [contextObject] Object that will be bound to the current object of the KScript
**/
$k.KScript.prototype.callFunction = function(functionName, parameters, contextObject) { };
/*global $k*/
/**
* Represents the output text document of a legacy KScript
* @class
* @extends $k.AbstractTextDocument
**/
$k.KScriptDocument = function() { };
/*global $k*/
/**
* A condition that links two queries
* @class
**/
$k.LinkedQueryCondition = function() { };
/**
* @deprecated This function is not supported any more
* @function
* @since 4.1.0
* @returns {number}
**/
$k.LinkedQueryCondition.prototype.alternativesId = function() { };
/**
* Returns the linked subquery
*
* @function
* @since 4.1.0
* @returns {$k.StructuredQuery}
**/
$k.LinkedQueryCondition.prototype.linkedQuery = function() { };
/**
* Returns the parameter name of the condition, if defined
*
* @function
* @since 4.1.0
* @returns {string}
**/
$k.LinkedQueryCondition.prototype.parameter = function() { };
/**
* Sets the parameter name of the condition
*
* @function
* @since 4.1.0
* @param {string} parameter
**/
$k.LinkedQueryCondition.prototype.setParameter = function(parameter) { };
/*global $k*/
/**
* A mail message
* @class
* @extends $k.NetEntity
**/
$k.MailMessage = function() { };
/**
* Get the blind carbon copy receivers ('bcc' field)
*
* @function
* @returns {string[]}
**/
$k.MailMessage.prototype.bcc = function() { };
/**
* Get the carbon copy receivers ('cc' field)
*
* @function
* @returns {string[]}
**/
$k.MailMessage.prototype.cc = function() { };
/**
* Get the charset of the headers
*
* @function
**/
$k.MailMessage.prototype.headerCharset = function() { };
/**
* Get the receiver ('to' field)
*
* @function
* @returns {string[]}
**/
$k.MailMessage.prototype.receiver = function() { };
/**
* Send the mail, using the SMTP configuration of the volume
*
* @function
* @param {boolean} [async] True if the mail should be sent asynchronously, false if send() should block until the mail has been sent. Default is true.
**/
$k.MailMessage.prototype.send = function(async) { };
/**
* Get the sender
*
* @function
* @returns {string[]}
**/
$k.MailMessage.prototype.sender = function() { };
/**
* Set the blind carbon copy receivers ('bcc' field)
*
* @function
* @param receivers String or Array of strings
**/
$k.MailMessage.prototype.setBcc = function(receivers) { };
/**
* Set the carbon copy receivers ('cc' field)
*
* @function
* @param receivers String or Array of strings
**/
$k.MailMessage.prototype.setCc = function(receivers) { };
/**
* Set the charset of the headers
*
* @function
* @param {string} charset Charset (encoding) of the headers
* @throws {$k.exception.InvalidValue} If the charset is unknown
**/
$k.MailMessage.prototype.setHeaderCharset = function(charset) { };
/**
* Set the receiver ('to' field)
*
* @function
* @param receivers String or Array of strings
* @throws {$k.exception.InvalidValue} If the value is not a valid receiver
**/
$k.MailMessage.prototype.setReceiver = function(receivers) { };
/**
* Set the sender ('from' field)
*
* @function
* @param {string} sender
* @throws {$k.exception.InvalidValue} If the value is not a valid sender
**/
$k.MailMessage.prototype.setSender = function(sender) { };
/**
* Set the subject
*
* @function
* @param {string} subject
* @throws {$k.exception.InvalidValue} If the value is not a valid subject
**/
$k.MailMessage.prototype.setSubject = function(subject) { };
/**
* Set the name of the user account. Required if the SMTP configuration requires authentication and more than one user is configured
*
* @function
* @param {string} username
**/
$k.MailMessage.prototype.setUserName = function(username) { };
/**
* Get the subject
*
* @function
* @returns {string}
**/
$k.MailMessage.prototype.subject = function() { };
/**
* Get the name of the user account
*
* @function
* @returns {string}
**/
$k.MailMessage.prototype.userName = function() { };
/**
* Tests the SMTP configuration of the volume
*
* @function
* @param {boolean} [throwExceptions] Control, whether a failing connection test throws its exception. Default: false.
* @param {string} [testUserName] The name of the user account. Required if the SMTP configuration requires authentication and more than one user is configured.
**/
$k.MailMessage.testConnection = function(throwExceptions, testUserName) { };
/*global $k*/
/**
* Represents a (external) data mapping
* @class
* @extends $k.FolderElement
**/
$k.Mapping = function() { };
/**
* Same as runExportOnElements()
*
* @function
* @since 4.3.1
* @version Experimental feature, might be removed at any time
**/
$k.Mapping.prototype.exportElements = function(elements) { };
/**
* Uses the mapping as data-source and validates each row with the validation-function.
* Possible parameters: <ul> <li>bindings: database bindings (object with name and value) to use to replace parameters in select statements (database and import only)</li>
* <li>caption: should the first row in the file be ignored, because it contains captions (CSV mappings only)</li>
* <li>captions: Table captions (table mappings only)</li>
* <li>dbEnvironment: database environment string (Oracle mappings only)</li>
* <li>dbHostname: database host name to connect to (MySQL mappings only</li>
* <li>dbPassword: database users password to use (databases only)</li>
* <li>dbUsername: database user name to use (databases only)</li>
* <li>disabledQueryParameters: List of disabled query parameters</li>
* <li>encoding: encoding to use</li>
* <li>importString: use this string instead of configured data source</li>
* <li>isJson: is the source a json file (XML mappings only)</li>
* <li>logTopicsToFolder: should the modified/created topics be logged to folders (false to switch off, true requires configured folder object in mapping) (import only)</li>
* <li>netEntity: use this NetEntity as file input or output. For output to text (CSV etc.) set the charset of the entity before export, the encoding of the mapping is ignored.</li>
* <li>queryParameters: Query parameters object ( e.g. {searchString: 'Goethe'}). Use disabledQueryParameters to deactivate parameters.</li>
* <li>quote: should the cell values should be enclosed with quotes (CSV mappings only)</li>
* <li>separator: separator to use in plain text files (CSV mappings only)</li>
* <li>triggers: should triggers be be activated during import (import only)</li>
* </ul>
*
* @function
* @param {Function} rowFunction function to process each row in a table. The function is invoked with the arguments:
* <ul> <li><array> row: array of column values, including undefined/null values for empty columns</li>
* <li><number> index: number of the row in the input table</li>
* <li><object> table context: object to store context information over multiple rows, initialized with table meta data: { <ul>
* <li><array> captions: array of caption strings, if the mappings provides these</li>
* </ul></li>
* </li>
* </ul>
* @param {Function} errorFunction function invoked on internal errors (invalid file etc):
* <ul> <li><string> error: error text</li>
* </ul>
* @since 4.2.0-tilbago
* @version Experimental feature, might be removed at any time
* @throws {$k.exception.MappingError} Unhandled errors while importing from the table data source (e.g. no connection to database, file not found, ...).
* @returns {$k.Mapping[]} This mapping
**/
$k.Mapping.prototype.iterateRows = function(rowFunction, errorFunction) { };
/**
* Runs this mapping as export
*
* @function
* @since 4.1.0
* @version Experimental feature, might be removed at any time
* @returns {object} Object with the keys 'updated' and 'inserted' with the number of updated/inserted rows (databases only)
* @throws {$k.exception.MappingError} Unhandled error while exporting to the data source (e.g. no connection to database, file not found)
**/
$k.Mapping.prototype.runExport = function() { };
/**
* Runs this mapping as export on some elements
*
* @function
* @since 4.1.0
* @version Experimental feature, might be removed at any time
* @param {$k.SemanticElement[]} elements List of semantic elements to export via this mapping
* @returns {object} Object with the keys 'updated' and 'inserted' with the number of updated/inserted rows (databases only)
* @throws {$k.exception.MappingError} Unhandled error while exporting to the data source (e.g. no connection to database, file not found)
**/
$k.Mapping.prototype.runExportOnElements = function(elements) { };
/**
* Runs this mapping as import
*
* @function
* @since 4.1.0
* @version Experimental feature, might be removed at any time
* @returns {object[]} Object with information about the import.
* <code>
* {
* "errorCount": <number>,
* "log": [ logEntry1, logEntry2, ... ]
* }
* </code>
*
* Each log entry contains some or all of the following properties:
* <code>
* {
* "message" : "<error message>",
* "caption" : "<name of column/schema element>",
* "data" : "<data source value string>",
* "mapping" : "<name of element mapping>",
* "category" : "<error category>",
* "row:" "<row number>"
* }
* </code>
*
* @throws {$k.exception.MappingError} Unhandled error while importing from the data source (e.g. no connection to database, file not found).
**/
$k.Mapping.prototype.runImport = function() { };
/**
* Set a single mapping parameter value overriding this parameter in the mapping definition
*
* @function
* @since 4.1.0
* @version Experimental feature, might be removed at any time
* @param {string} name Name of the parameter to set
* @param value Value of the parameter
* @returns {$k.Mapping} This mapping
* @throws {$k.exception.TypeError} If the value does not match the expected type for the parameter
* @throws {$k.exception.InvalidValue} If the name is not a valid parameter for mappings
* @see $k.Mapping#setParameters
**/
$k.Mapping.prototype.setParameter = function(name, value) { };
/**
* Set a group of parameter values overriding the parameter in the mapping definition.<p>
* Possible parameters:
* <ul>
* <li>bindings: database bindings (object with name and value) to use to replace parameters in select statements (database and import only)</li>
* <li>caption: should the first row in the file be ignored, because it contains captions (CSV mappings only)</li>
* <li>captions: Table captions (table mappings only)</li>
* <li>dbEnvironment: database environment string (Oracle mappings only)</li>
* <li>dbHostname: database host name to connect to (MySQL mappings only</li>
* <li>dbPassword: database users password to use (databases only)</li>
* <li>dbUsername: database user name to use (databases only)</li>
* <li>disabledQueryParameters: List of disabled query parameters</li>
* <li>encoding: encoding to use</li>
* <li>importString: use this string instead of configured data source</li>
* <li>isJson: is the source a json file (XML mappings only)</li>
* <li>logTopicsToFolder: should the modified/created topics be logged to folders (false to switch off, true requires configured folder object in mapping) (import only)</li>
* <li>netEntity: use this NetEntity as file input or output. For output to text (CSV etc.) set the charset of the entity before export, the encoding of the mapping is ignored.</li>
* <li>queryParameters: Query parameters object ( e.g. {searchString: 'Goethe'}). Use disabledQueryParameters to deactivate parameters.</li>
* <li>quote: should the cell values should be enclosed with quotes (CSV mappings only)</li>
* <li>separator: separator to use in plain text files (CSV mappings only)</li>
* <li>triggers: should triggers be be activated during import (import only)</li>
*
* </ul>
*
* @function
* @since 4.1.0
* @version Experimental feature, might be removed at any time
* @param {object} object Object with parameter names and values
* @returns {$k.Mapping} This mapping
* @throws {$k.exception.TypeError} If the passed object or any value does not match the expected type for the parameter
* @throws {$k.exception.InvalidValue} If a name is not a valid parameter for mappings
**/
$k.Mapping.prototype.setParameters = function(object) { };
/*global $k*/
/**
* Creates a new MQTTClient
*
* @param {string} url URL of the broker
* @param {number} [qos] Default quality of service
*
* @class
**/
$k.MQTTClient = function(url, qos) { };
/**
* Publish the data in a background process. Returns immediately
*
* @function
* @param {object} payload
* @param {string} topic
* @param {number} qos
* @see MQQTClient#publish
* @since 5.2.2
**/
$k.MQTTClient.prototype.asyncPublish = function(payload, topic, qos) { };
/**
* Publish something (bytes, string, js-object) under the given topic with optional quality of service (default is 0).
*
* @function
* @param {object} payload payload to be published will be stringified and/or utf-8 encoded for transport
* @param {string} topic topic to be published to
* @param {number} qos quality of service (0,1,2) - default is 0
* @param {string} [url] deprecated, pass the URL in the constructor
* @returns {boolean} returns true if publish succesful, false otherwise
* @since 5.2.0
**/
$k.MQTTClient.prototype.publish = function(payload, topic, qos, url) { };
/*global $k*/
/**
* Built-in implemenation of Mustache.
* See https://mustache.github.io
* @class
**/
$k.Mustache = function() { };
/**
* Renders the template with the data
*
* @function
* @param {string} template The template string to be expanded
* @param {object} data The expansion data object
* @param {object} [partials] Optional partials
* @returns {string} The expanded output
* @throws {$k.exception.InvalidValue} If the mustache expansion runs into any error
**/
$k.Mustache.render = function(template, data, partials) { };
/*global $k*/
/**
* Abstract superclass of entities that are sent or received over the internet
* @class
**/
$k.NetEntity = function() { };
/**
* Attach a entity
*
* @function
* @param {$k.NetEntity} attachment
* @throws {$k.exception.TypeError} If the entity is not a valid attachment
**/
$k.NetEntity.prototype.attach = function(attachment) { };
/**
* Returns the attached entities
*
* @function
* @returns {$k.NetEntity[]}
**/
$k.NetEntity.prototype.attachments = function() { };
/**
* Get the binay contents as base64-encoded string. Returns undefined if the contents is not binary
*
* @function
* @returns {string}
**/
$k.NetEntity.prototype.base64String = function() { };
/**
* Returns the charset
*
* @function
* @returns {string}
**/
$k.NetEntity.prototype.charset = function() { };
/**
* Returns the content disposition
*
* @function
* @returns {string}
**/
$k.NetEntity.prototype.contentDisposition = function() { };
/**
* Returns the content length
*
* @function
* @returns {number}
**/
$k.NetEntity.prototype.contentLength = function() { };
/**
* Returns the content type (only the media type part)
*
* @function
* @returns {string}
**/
$k.NetEntity.prototype.contentType = function() { };
/**
* Returns the entity bytes as a data URL, or undefined if the entity is not binary
*
* @function
* @returns {string}
* @see http://dataurl.net/#about
**/
$k.NetEntity.prototype.dataUrl = function() { };
/**
* Prints the entity, except binary contents, for debugging purposes
*
* @function
* @returns {string}
**/
$k.NetEntity.prototype.debugString = function() { };
/**
* Returns the filename part of the content disposition field
*
* @function
* @returns {string}
**/
$k.NetEntity.prototype.filename = function() { };
/**
* Get all form fields (multipart/form-data or application/x-www-form-urlencoded).
* The property names correspond to the field names.
* The property values are either strings (if the form is of type application/x-www-form-urlencoded) or NetEntities (multipart/form-data)
*
* @function
* @returns {object}
* @see $k.NetEntity
**/
$k.NetEntity.prototype.formData = function() { };
/**
* Get the value of the field of the request header. Returns undefined if the field does not exist
*
* @function
* @param {string} fieldName
* @returns {string} The field value
**/
$k.NetEntity.prototype.headerField = function(fieldName) { };
/**
* Get all fields of the request header. Field names are always lower case
*
* @function
* @returns {object}
**/
$k.NetEntity.prototype.headerFields = function() { };
/**
* True if the entity has binary contents
*
* @function
* @returns {boolean}
**/
$k.NetEntity.prototype.isBinary = function() { };
/**
* Removes the field of the request heade
*
* @function
* @param {string} fieldName
* @since 5.0.3
**/
$k.NetEntity.prototype.removeHeaderField = function(fieldName) { };
/**
* Set the charset
*
* @function
* @param {string} charset
* @throws {$k.exception.InvalidValue} If the charset is unknown
**/
$k.NetEntity.prototype.setCharset = function(charset) { };
/**
* Set the content disposition
*
* @function
* @param {string} contentDisposition
**/
$k.NetEntity.prototype.setContentDisposition = function(contentDisposition) { };
/**
* Set the content length
*
* @function
* @param {number} length
**/
$k.NetEntity.prototype.setContentLength = function(length) { };
/**
* Set the contents of the entity. Also sets the content type and filename if known.
* The contents object can be a string, document ($k.TextDocument), a blob value ($k.Blob) or another NetEntity
*
* @function
* @param contents Contents object
* @see $k.Blob
* @see $k.TextDocument
**/
$k.NetEntity.prototype.setContents = function(contents) { };
/**
* Set the content type
*
* @function
* @param {string} mediaType Media type of the contents
* @param {string} [charset] Charset of the contents
**/
$k.NetEntity.prototype.setContentType = function(mediaType, charset) { };
/**
* Set the filename part of the content disposition field
*
* @function
* @param {string} filename
**/
$k.NetEntity.prototype.setFilename = function(filename) { };
/**
* Set the value of the field of the request header
*
* @function
* @param {string} fieldName
* @param fieldValue
* @throws {$k.exception.TypeError} If the value does not match the type of the field
**/
$k.NetEntity.prototype.setHeaderField = function(fieldName, fieldValue) { };
/**
* Set the text as the body
*
* @function
* @param {string} text
**/
$k.NetEntity.prototype.setText = function(text) { };
/**
* Get the contents as string
*
* @function
* @param {string} charset Charset of the characters. Required for binary entities. Optional for text entities.
* @returns {string}
**/
$k.NetEntity.prototype.text = function(charset) { };
/*global $k*/
/**
* Creates a new cookie
*
* @param {string} name
* @param {string} value
*
* Represents a new HTTP Cookie (RFC 2109) that can be added to a response
* @class
* @extends $k.Cookie
**/
$k.NewCookie = function(name, value) { };
/**
* Returns the comment of the cookie
*
* @function
* @returns {string}
**/
$k.NewCookie.prototype.comment = function() { };
/**
* Returns the domain of the cookie
*
* @function
* @returns {string}
**/
$k.NewCookie.prototype.domain = function() { };
/**
* Returns the expiry date of the cookie
*
* @function
* @returns {date}
**/
$k.NewCookie.prototype.expiry = function() { };
/**
* Returns true if the cookie contains the HttpOnly attribute
*
* @function
* @returns {boolean}
**/
$k.NewCookie.prototype.httpOnly = function() { };
/**
* Returns the maximum age of the the cookie in seconds
*
* @function
* @returns {number}
**/
$k.NewCookie.prototype.maxAge = function() { };
/**
* Returns the path of the cookie
*
* @function
* @returns {string}
**/
$k.NewCookie.prototype.path = function() { };
/**
* Returns the port of the cookie
*
* @function
* @returns {number}
**/
$k.NewCookie.prototype.port = function() { };
/**
* Returns true if the cookie will only be sent over a secure connection
*
* @function
* @returns {boolean}
**/
$k.NewCookie.prototype.secureOnly = function() { };
/**
* Sets the comment of the cookie
*
* @function
* @param {string} comment
**/
$k.NewCookie.prototype.setComment = function(comment) { };
/**
* Sets the domain of the cookie
*
* @function
* @param {string} domain
**/
$k.NewCookie.prototype.setDomain = function(domain) { };
/**
* Sets the expiry date of the cookie
*
* @function
* @param {date} expiryDate
**/
$k.NewCookie.prototype.setExpiry = function(expiryDate) { };
/**
* Set the HttpOnly attribute
*
* @function
* @param {boolean} [httpOnly] True if undefined
**/
$k.NewCookie.prototype.setHttpOnly = function(httpOnly) { };
/**
* Sets the maximum age of the the cookie in seconds
*
* @function
* @param {number} maxAge
**/
$k.NewCookie.prototype.setMaxAge = function(maxAge) { };
/**
* Sets the path of the cookie
*
* @function
* @param {string} path
**/
$k.NewCookie.prototype.setPath = function(path) { };
/**
* Sets the port of the cookie
*
* @function
* @param {number} port
**/
$k.NewCookie.prototype.setPort = function(port) { };
/**
* Set if the cookie will only be sent over a secure connection
*
* @function
* @param {boolean} [secureOnly] True if undefined
**/
$k.NewCookie.prototype.setSecureOnly = function(secureOnly) { };
/**
* Sets the version of the cookie
*
* @function
* @param {number} version
**/
$k.NewCookie.prototype.setVersion = function(version) { };
/**
* Returns the version of the cookie
*
* @function
* @returns {number}
**/
$k.NewCookie.prototype.version = function() { };
/*global $k*/
/**
* A document that writes to a null stream
* @class
* @extends $k.AbstractTextDocument
**/
$k.NullDocument = function() { };
/*global $k*/
/**
* Constructs an OAuth instance
*
* @param [consumerKey] Consumer key
* @param [accessToken] Access token
* @version Experimental feature, might be removed at any time
* @since 4.0.3
*
* OAuth 1.0 support
* @class
**/
$k.OAuth = function(consumerKey, accessToken) { };
/**
* Add OAuth authentication to the request
*
* @function
* @param {$k.HttpRequest} request
* @version Experimental feature, might be removed at any time
* @since 4.0.3
**/
$k.OAuth.prototype.authenticateRequest = function(request) { };
/**
* Obtain an access token
*
* @function
* @param {string} url Access token URL
* @param {string} token Request token
* @param {string} secret Request token secret
* @param {string} verifier Verification code
* @returns {object} OAuth access token information object
* <code>
* {
* token: "<access token value>",
* expires: <optional expires date>
* authorizationEpires: <optional authorization expires date>
* }
* </code>
* @version Experimental feature, might be removed at any time
* @since 4.0.3
**/
$k.OAuth.prototype.obtainAccessToken = function(url, token, secret, verifier) { };
/**
* Obtain a request token
*
* @function
* @param {string} url Request token URL
* @returns {object} OAuth token information object
* <code>
* {
* token: "<token value>",
* secret: "<token secret>"
* }
* </code>
* @version Experimental feature, might be removed at any time
* @since 4.0.3
**/
$k.OAuth.prototype.obtainRequestToken = function(url) { };
/**
* Set the access token
*
* @function
* @param {string} token
* @version Experimental feature, might be removed at any time
* @since 4.0.3
**/
$k.OAuth.prototype.setAccessToken = function(token) { };
/**
* Set the callback URL. If not set, "oob" is used
*
* @function
* @param {string} url
* @version Experimental feature, might be removed at any time
* @since 4.0.3
**/
$k.OAuth.prototype.setCallback = function(url) { };
/**
* Set the consumer key
*
* @function
* @param {string} key
* @version Experimental feature, might be removed at any time
* @since 4.0.3
**/
$k.OAuth.prototype.setConsumerKey = function(key) { };
/**
* Set the private RSA key
*
* @function
* @param {string} secret
* @version Experimental feature, might be removed at any time
* @since 4.0.3
**/
$k.OAuth.prototype.setPrivateKey = function(secret) { };
/*global $k*/
/**
* Operator of an attribute condition.
* @class
**/
$k.Operator = function() { };
/**
**/
$k.Operator.CONTAINS_PHRASE = "containsPhrase";
/**
**/
$k.Operator.CONTAINS_WORDS = "words";
/**
**/
$k.Operator.COVERS = "covers";
/**
**/
$k.Operator.DISTANCE = "distance";
/**
* Can be replaced by the string "=="
**/
$k.Operator.EQ = "equal";
/**
*
* Can be replaced by the string "=="
**/
$k.Operator.EQUAL = "equal";
/**
*
* Can be replaced by the string "=="
**/
$k.Operator.EQUAL_CARDINALITY = "equalCardinality";
/**
**/
$k.Operator.EQUAL_GEO = "equalGeo";
/**
**/
$k.Operator.EQUAL_REGEX = "regexEqual";
/**
**/
$k.Operator.EXACT_EQUAL = "unmodifiedEqual";
/**
*
* For query references only
**/
$k.Operator.FILTER = "equalsTopicOneWay";
/**
*
* Can be replaced by the string ">="
**/
$k.Operator.GE = "greaterOrEqual";
/**
*
* Can be replaced by the string ">"
**/
$k.Operator.GREATER = "greater";
/**
*
* Can be replaced by the string ">="
**/
$k.Operator.GREATER_OR_EQUAL = "greaterOrEqual";
/**
**/
$k.Operator.GREATER_OVERLAPS = "greaterOverlaps";
/**
*
* Can be replaced by the string ">"
**/
$k.Operator.GT = "greater";
/**
**/
$k.Operator.IS_COVERED_BY = "isCoveredBy";
/**
*
* Can be replaced by the string "<="
**/
$k.Operator.LE = "lessOrEqual";
/**
*
* Can be replaced by the string "<"
**/
$k.Operator.LESS = "less";
/**
*
* Can be replaced by the string "<="
**/
$k.Operator.LESS_OR_EQUAL = "lessOrEqual";
/**
**/
$k.Operator.LESS_OVERLAPS = "lessOverlaps";
/**
*
* Can be replaced by the string "<"
**/
$k.Operator.LT = "less";
/**
*
* Can be replaced by the string ">="
**/
$k.Operator.MAX_CARDINALITY = "equalMaxCardinality";
/**
*
* Can be replaced by the string "<="
**/
$k.Operator.MIN_CARDINALITY = "equalMinCardinality";
/**
*
* Can be replaced by the string "!="
**/
$k.Operator.NE = "notEqual";
/**
*
* Can be replaced by the string "!="
**/
$k.Operator.NOT_EQUAL = "notEqual";
/**
**/
$k.Operator.OVERLAPS = "overlaps";
/**
**/
$k.Operator.RANGE = "range";
/*global $k*/
/**
* A view built with/by panel configuration
* @class
* @extends $k.View
**/
$k.PanelView = function() { };
/**
* Get an array of semantic elements.
*
* @since 5.3.0
* @function
* @returns {Element[]}
**/
$k.PanelView.prototype.elements = function() { };
/**
* Get the current sub view of the panel if present.
*
* @since 5.3.0
* @function
* @returns {$k.View}
**/
$k.PanelView.prototype.subView = function() { };
/*global $k*/
/**
* Abstract persistent collection of elements. The collection can be registered or added to folders.
* @class
* @extends $k.FolderElement
**/
$k.PersistentCollection = function() { };
/**
* Returns the elements of the collection
*
* @function
* @returns {object[]}
**/
$k.PersistentCollection.prototype.elements = function() { };
/**
* Returns the name
*
* @function
* @returns {string}
**/
$k.PersistentCollection.prototype.name = function() { };
/*global $k*/
/**
* Represents a property.
* @class
* @extends $k.SemanticElement
**/
$k.Property = function() { };
/**
* Returns the domain of the property
*
* @function
* @returns {$k.Domain}
* @since 4.1.0
**/
$k.Property.prototype.domain = function() { };
/**
* Returns the semantic element that has this property
*
* @function
* @returns {$k.SemanticElement}
**/
$k.Property.prototype.source = function() { };
/*global $k*/
/**
* Creates a new PropertyFilter. If the constructer is called as a function, it will construct a new filter, too.
* <p> </p>
* The filter will be initialized from the optional filterDescriptor. The possible properties are: <pre><code>
* type (Type or internal name)
* abstract
* attributes
* exact
* oneWayRelations
* shortcutRelations
* systemRelations
* unconstrained
* userRelations
* </code></pre>
* <p> </p>
*
*
* @param {object} [filterDescriptor]
* @example
* // Returns a filter that returns properties with internal name "contains"
* $k.PropertyFilter({ exact: true, type: "contains" });
*
* Filters the possible properties of an element or domain.
* @class
**/
$k.PropertyFilter = function(filterDescriptor) { };
/**
* Returns true if abstract properties should be returned.
* Default is false.
*
* @function
* @returns {boolean}
**/
$k.PropertyFilter.prototype.includeAbstract = function() { };
/**
* Returns true if attributes should be returned
*
* @function
* @returns {boolean}
**/
$k.PropertyFilter.prototype.includeAttributes = function() { };
/**
* Returns true if inverse one way relations should be returned.
* Default is false.
*
* @function
* @returns {boolean}
**/
$k.PropertyFilter.prototype.includeOneWay = function() { };
/**
* Returns true if shortcut relations should be returned.
* Default is false.
*
* @function
* @returns {boolean}
**/
$k.PropertyFilter.prototype.includeShortcutRelations = function() { };
/**
* Returns true if system relations should be returned.
* Default is false.
*
* @function
* @returns {boolean}
**/
$k.PropertyFilter.prototype.includeSystemRelations = function() { };
/**
* Returns true if user relations should be returned
*
* @function
* @returns {boolean}
**/
$k.PropertyFilter.prototype.includeUserRelations = function() { };
/**
* Returns true if only properties of the specified type should be returned,
* false if also sub-properties should be included.
* Default is false.
*
* @function
* @returns {boolean}
**/
$k.PropertyFilter.prototype.isExact = function() { };
/**
* Returns the possible properties of the semantic element / domain
*
* @function
* @param {$k.SemanticElement} object Semantic element or domain
* @returns {$k.PropertyType[]}
**/
$k.PropertyFilter.prototype.possiblePropertiesOf = function(object) { };
/**
* Returns the properties of the semantic element
*
* @function
* @param {$k.SemanticElement} semanticElement
* @returns {$k.PropertyType[]}
**/
$k.PropertyFilter.prototype.propertiesOf = function(semanticElement) { };
/**
* Defines if abstract properties are returned.
*
* @function
* @param {boolean} abstract True if not defined
* @returns {$k.PropertyFilter} The filter
**/
$k.PropertyFilter.prototype.setAbstract = function(abstract) { };
/**
* Defines if attributes should be returned.
* Default is true
*
* @function
* @param {boolean} attributes True if not defined
* @returns {$k.PropertyFilter} The filter
**/
$k.PropertyFilter.prototype.setAttributes = function(attributes) { };
/**
* Defines if only properties of the specified type should be returned, or also sub-properties.
*
* @function
* @param {boolean} exact True if not defined
* @returns {$k.PropertyFilter} The filter
**/
$k.PropertyFilter.prototype.setExact = function(exact) { };
/**
* Defines if inverse one way relations should be returned.
*
* @function
* @param {boolean} oneWayRelations True if not defined
* @returns {$k.PropertyFilter} The filter
**/
$k.PropertyFilter.prototype.setOneWayRelations = function(oneWayRelations) { };
/**
* Defines if shortcut relations should be returned.
*
* @function
* @param {boolean} shortcutRelations True if not defined
* @returns {$k.PropertyFilter} The filter
**/
$k.PropertyFilter.prototype.setShortcutRelations = function(shortcutRelations) { };
/**
* Defines if shortcut relations should be returned.
*
* @function
* @param {boolean} systemRelations True if not defined
* @returns {$k.PropertyFilter} The filter
**/
$k.PropertyFilter.prototype.setSystemRelations = function(systemRelations) { };
/**
* Defines the type / internal name of the properties
*
* @function
* @param type Type or internal name
* @returns {$k.PropertyFilter} The filter
**/
$k.PropertyFilter.prototype.setType = function(type) { };
/**
* Defines if properties should be returned that cannot be created due to cardinality constrains.
* This setting only has an effect when quering the possible properties of a semantic element, not of a domain
*
* @function
* @param {boolean} additionalOnly True if not defined
* @returns {$k.PropertyFilter} The filter
**/
$k.PropertyFilter.prototype.setUnconstrained = function(additionalOnly) { };
/**
* Defines if user relations should be returned.
* Default is true
*
* @function
* @param {boolean} userRelations True if not defined
* @returns {$k.PropertyFilter} The filter
**/
$k.PropertyFilter.prototype.setUserRelations = function(userRelations) { };
/**
* Returns this filter.
* To define custom property filters, define an object with a function toPropertyFilter().
* If toPropertyFilter() does not return an object of kind $k.PropertyFilter, the object has to define the functions
* propertiesOf() and possiblePropertiesOf()
*
* @function
* @returns {$k.PropertyFilter}
**/
$k.PropertyFilter.prototype.toPropertyFilter = function() { };
/**
* Returns the type / internal name that should be used for filtering properties
*
* @function
* @returns {string|$k.Type}
**/
$k.PropertyFilter.prototype.type = function() { };
/**
* Returns true if properties should be returned that cannot be created due to cardinality constrains.
* This setting only has an effect when quering the possible properties of a semantic element, not of a domain.
* Default is false
*
* @function
* @returns {boolean}
**/
$k.PropertyFilter.prototype.unconstrained = function() { };
/*global $k*/
/**
* A condition that selects properties according to the property source subquery.
* @class
* @extends $k.LinkedQueryCondition
**/
$k.PropertySourceCondition = function() { };
/*global $k*/
/**
* Represents a type of properties
* @class
* @extends $k.Type
**/
$k.PropertyType = function() { };
/**
* Returns true if multiple occurrences per semantic element are possible
*
* @function
* @returns {boolean}
**/
$k.PropertyType.prototype.allowsMultipleOccurrences = function() { };
/**
* Returns the defined domains of the property.
*
* @function
* @returns {$k.Domain[]}
**/
$k.PropertyType.prototype.definedDomains = function() { };
/**
* Returns the effective domains of the property.
* <ul>
* <li>If the property is defined as mixin, extended domains are substituted by all possible extensions.</li>
* <li>Domains that are sub-domains of other domains are discarded.</li>
* <li>If the domain is a relation, and symmetric properties are enabled, all possible inverse relations are also included.</li>
* </ul>
*
* @function
* @returns {$k.Domain[]}
**/
$k.PropertyType.prototype.domains = function() { };
/*global $k*/
/**
* Represents a query
* @class
* @extends $k.FolderElement
**/
$k.Query = function() { };
/**
* Returns the parameters of the query
*
* @function
* @returns {$k.QueryParameter[]}
* @see $k.Query#setParameter
**/
$k.Query.prototype.definedParameters = function() { };
/**
* Returns elements involved in the query
*
* @function
* @param {$k.SemanticElement[]} elements Elements to explain. Elements that do not match the query are ignored.
* @param {object} [parameters]
* @returns {$k.SemanticElement[]}
* @throws {$k.exception.QueryError} When the query could not be solved, e.g. missing parameters
* @see $k.Query#setParameter
**/
$k.Query.prototype.explainElements = function(elements, parameters) { };
/**
* Returns all elements that match the query
*
* @function
* @param {$k.SemanticElement[]} elements
* @param {object} [parameters]
* @param {string} [searchString]
* @returns {$k.SemanticElement[]}
* @throws {$k.exception.QueryError} When the query could not be solved, e.g. missing parameters
* @example
* var hits = $k.Registry.query("experts").filterElements(persons);
* @see $k.Query#setParameter
**/
$k.Query.prototype.filterElements = function(elements, parameters, searchString) { };
/**
* Search and return all found semantic elements
*
* @function
* @param {object} [parameters]
* @param {string} [searchString]
* @returns {$k.SemanticElement[]}
* @throws {$k.exception.QueryError} When the query could not be solved, e.g. missing parameters
* @example
* var hits = $k.Registry.query("directSearch").findElements("Test");
* @example
* var hits = $k.Registry.query("compositeSearch").findElements("Test", { context: "portal" });
* @see $k.Query#setParameter
**/
$k.Query.prototype.findElements = function(parameters, searchString) { };
/**
* Search and return all found hits.
*
* @function
* @param {object} [parameters]
* @param {string} [searchString]
* @returns {$k.Hit[]}
* @throws {$k.exception.QueryError} When the query could not be solved, e.g. missing parameters
* @example
* var hits = $k.Registry.query("directSearch").findHits("Test*");
* @see $k.Query#setParameter
**/
$k.Query.prototype.findHits = function(parameters, searchString) { };
/**
* Returns all elements involved in the query
*
* @function
* @param {$k.SemanticElement[]} elements Elements to full explain. Elements that do not match the query are ignored.
* @param {object} [parameters]
* @returns {$k.SemanticElement[]}
* @throws {$k.exception.QueryError} When the query could not be solved, e.g. missing parameters
* @see $k.Query#setParameter
**/
$k.Query.prototype.fullExplainElements = function(elements, parameters) { };
/**
* Returns the name
*
* @function
* @returns {string}
**/
$k.Query.prototype.name = function() { };
/**
* Search and render found semantic elements using the given table configuration
*
* @function
* @since 4.1.0
* @param {$k.TableConfiguration} tableConfiguration
* @param {object} [keyFilter] Alternative 1: An array of strings defining a filter which property names to include.<br/>
* Alternative 2: An object with "include" and/or "exclude" keys<br/>
* <pre class="code">{"exclude": ["key1", ...]}</pre> includes all but the listed properties, while <pre class="code">{"include": ["key1", ...]}</pre> or <pre class="code">["key1", ...]</pre> includes only the listed properties.
* <br/>Non-optional properties are always included<br/>
* Alternative 3: A JSONRenderContext
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object[]} The rendered objects
* @throws {$k.exception.QueryError} When the query could not be solved, e.g. missing parameters
**/
$k.Query.prototype.renderElements = function(tableConfiguration, keyFilter, detailFilter) { };
/**
* Search and render found hits using the given table configuration
*
* @function
* @since 4.1.0
* @param {$k.TableConfiguration} tableConfiguration
* @param {object} [keyFilter] Alternative 1: An array of strings defining a filter which property names to include.<br/>
* Alternative 2: An object with "include" and/or "exclude" keys<br/>
* <pre class="code">{"exclude": ["key1", ...]}</pre> includes all but the listed properties, while <pre class="code">{"include": ["key1", ...]}</pre> or <pre class="code">["key1", ...]</pre> includes only the listed properties.
* <br/>Non-optional properties are always included<br/>
* Alternative 3: A JSONRenderContext
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object[]} The rendered objects
* @throws {$k.exception.QueryError} When the query could not be solved, e.g. missing parameters
**/
$k.Query.prototype.renderHits = function(tableConfiguration, keyFilter, detailFilter) { };
/**
* Returns the search string
*
* @function
* @returns {string}
**/
$k.Query.prototype.searchString = function() { };
/**
* Restrict the query results to objects/types of the domains
*
* @function
* @param {$k.Domain} domains The domain or internal name of a type
* @since 4.1.0
**/
$k.Query.prototype.setDomain = function(domains) { };
/**
* Restrict the query results to objects/types of the domains
*
* @function
* @param {$k.Domain[]} domains The domains or internal names of types
**/
$k.Query.prototype.setDomains = function(domains) { };
/**
* Set the selected facets and terms for the query
*
* @function
* @since 5.1.3
* @param {array} facetFiltersArray Array with selected facets and terms
**/
$k.Query.prototype.setFacetFilters = function(facetFiltersArray) { };
/**
* Sets the name of the query
*
* @function
* @param {string} name The name
* @since 5.3.2
* @version Experimental feature, might be removed at any time
**/
$k.Query.prototype.setName = function(name) { };
/**
* Set a parameter of the query.
*
* @function
* @param {string} parameterId The ID of the parameter
* @param value The value of the parameter. The type (string etc.) depends on the parameter. Arrays of values can be passed, too. The value undefined or null disables the parametrized condition.
* @throws {$k.exception.TypeError} When the value is not suitable for the parameter
**/
$k.Query.prototype.setParameter = function(parameterId, value) { };
/**
* Set the parameters of the query from the properties of the object
*
* @function
* @param parameters The parameters
* @throws {$k.exception.TypeError} When a value is not a suitable parameter
* @see $k.Query#setParameter
**/
$k.Query.prototype.setParameters = function(parameters) { };
/**
* Set the string to search for
*
* @function
* @param {string} searchString
**/
$k.Query.prototype.setSearchString = function(searchString) { };
/**
* Returns the query for all objects of the domain
*
* @function
* @since 4.1.0
* @param {$k.Domain} domain Domain or internal name of a type
* @param {boolean} [withoutInheritance] If true do not return objects of subdomains
* @returns {$k.StructuredQuery}
**/
$k.Query.forDomain = function(domain, withoutInheritance) { };
/**
* Returns the query for all objects of the domains
*
* @function
* @since 4.1.0
* @param {$k.Domain[]} domain Domains or internal names of types
* @param {boolean} [withoutInheritance] If true do not return objects of subdomains
* @returns {$k.StructuredQuery}
**/
$k.Query.forDomains = function(domain, withoutInheritance) { };
/*global $k*/
/**
* Parameter of a query
* @class
**/
$k.QueryParameter = function() { };
/**
* Returns the domains
*
* @function
* @returns {$k.Domain[]}
**/
$k.QueryParameter.prototype.domains = function() { };
/**
* Returns the name
*
* @function
* @returns {string}
**/
$k.QueryParameter.prototype.name = function() { };
/**
* Returns the type of the parameter
*
* @function
* @returns {string}
**/
$k.QueryParameter.prototype.type = function() { };
/*global $k*/
/**
* References another query that selects elements of this query according to the operator. If $k.Operator.EQUAL or NOT_EQUAL are selected, then the reference works in both directions. If $k.Operator.FILTER is selected, then the subquery is only applied to this query.
* @class
* @extends $k.LinkedQueryCondition
**/
$k.QueryReference = function() { };
/**
* Returns the comparison operator
*
* @function
* @since 4.1.0
* @returns {string}
**/
$k.QueryReference.prototype.operator = function() { };
/**
* Sets the comparison operator
*
* @function
* @since 4.1.0
* @param {string} operator
**/
$k.QueryReference.prototype.setOperator = function(operator) { };
/*global $k*/
/**
* Creates a new RDF Exporter
*
* @since 4.3.2
* @param {$k.AbstractTextDocument} [document] Document to write on. A new text document will be created if not specified
*
* @class
**/
$k.RDFExporter = function(document) { };
/**
* Export the elements as RDF
*
* @function
* @since 4.3.2
* @version Experimental feature, might be removed at any time
* @param {$k.SemanticElement[]} elements List of semantic elements to export
* @throws {$k.exception.RuntimeError} If any error occurs during the export
**/
$k.RDFExporter.prototype.exportElements = function(elements) { };
/**
* Set a parameter controlling the RDF export
*
* @function
* @since 4.3.2
* @version Experimental feature, might be removed at any time
* @param {string} name Name of the parameter to set
* @param value Value of the parameter
* @throws {$k.exception.TypeError} If the value does not match the expected type for the parameter
* @throws {$k.exception.InvalidValue} If the name / value is not a valid
* @see $k.RDFExporter#setParameters
**/
$k.RDFExporter.prototype.setParameter = function(name, value) { };
/**
* Set parameters controlling the RDF export<p>
* Possible parameters:
* <ul>
* <li>abbreviateURIs: Abbreviate URIs using rdf:ID and xml:base</li>
* <li>baseURI: Base URI</li>
* <li>blobHash: True if hash values of blobs should be exported</li>
* <li>exportFrameIDs: Export object frame IDs</li>
* <li>exportLabels: Export name as rdfs:label</li>
* <li>exportMeta: True if meta properties should be exported. They will be exported as reifications.</li>
* <li>exportPropertyIDs: Export IDs of properties</li>
* <li>exportReferencedTopics: True if external relation targets should be exported as stubs</li>
* <li>ignoreStoredIdentifier: If true, the RDF locator will always be generated. If false, the rdf:about/rdf:ID attribute will be used if present</li>
* <li>qualifier: XML qualifier bound to the base URI</li>
* <li>schemaNameSpace: Default schema XML namespace</li>
* <li>schemaOnly: True if only types should be exported</li>
* <li>updatePersistentIdentifier: True if the generated values for rdf:ID / rdf:about should be materialized as attribute values</li>
* <li>useFrameURIs: True if URIs constructed from the object ID should be used to identify objects</li>
* <li>useKRDF: True if KRDF properties (e.g. krdf:internalName) should be exported</li>
* <li>useOWL: True if OWL vocabulary should be used</li>
*
* </ul>
*
* @function
* @since 4.3.2
* @version Experimental feature, might be removed at any time
* @param {object} object Object with parameter names and values
* @throws {$k.exception.TypeError} If the passed object or any value does not match the expected type for the parameter
* @throws {$k.exception.InvalidValue} If a name / value is not a valid
**/
$k.RDFExporter.prototype.setParameters = function(object) { };
/**
* Filter the exported properties. The function receives a property and should return true if the property should be exported.
*
* @function
* @since 5.0.3
* @version Experimental feature, might be removed at any time
* @param {function} filterFunction Filter function
**/
$k.RDFExporter.prototype.setPropertyFilter = function(filterFunction) { };
/**
* Get the RDF contents as string
*
* @function
* @since 4.3.2
* @returns {string}
* @throws {$k.exception.TypeError} If the output document is based on an external stream (file etc.)
**/
$k.RDFExporter.prototype.text = function() { };
/*global $k*/
/**
* Creates a new RDFImporter
*
* @version Experimental feature, might be removed at any time
*
* @class
**/
$k.RDFImporter = function() { };
/**
* Import the RDF/XML string
*
* @since 4.3.3
* @function
* @param {string} rdf String containing RDF/XML
* @param {string} [baseURI] Base URI
* @returns {object[]} Object with information about the import.
* <code>
* {
* "errorCount": <number>,
* "log": [ logEntry1, logEntry2, ... ]
* }
* </code>
*
* Each log entry contains some or all of the following properties:
* <code>
* {
* "message" : "<error message>",
* "line" : "line number",
* "uri" : "URI of the RDF document"
* }
* </code>
**/
$k.RDFImporter.prototype.importFromString = function(rdf, baseURI) { };
/**
* import from URI
*
* @function
* @param {string} uri
* @returns {string[]} Object with information about the import.
* <code>
* {
* "errorCount": <number>,
* "log": [ logEntry1, logEntry2, ... ]
* }
* </code>
*
* Each log entry contains some or all of the following properties:
* <code>
* {
* "message" : "<error message>",
* "line" : "line number",
* "uri" : "URI of the RDF document"
* }
* </code>
**/
$k.RDFImporter.prototype.importFromURI = function(uri) { };
/**
* activate Triggers
*
* @function
* @param {boolean} bool
* @returns {$k.RDFImporter} The Importer
**/
$k.RDFImporter.prototype.setActivateTriggers = function(bool) { };
/**
* Avoid duplicate properties
*
* @function
* @param {boolean} bool
* @returns {$k.RDFImporter} The Importer
**/
$k.RDFImporter.prototype.setAvoidDuplicateProperties = function(bool) { };
/**
* Allow schema changes
*
* @function
* @param {boolean} bool
* @returns {$k.RDFImporter} The Importer
**/
$k.RDFImporter.prototype.setEnableCreateSchema = function(bool) { };
/**
* Create inverse relation types
*
* @function
* @param {boolean} bool
* @returns {$k.RDFImporter} The Importer
**/
$k.RDFImporter.prototype.setEnforceInverseRelationConcepts = function(bool) { };
/**
* Identify objects with global URI also by local ID
*
* @function
* @param {boolean} bool
* @returns {$k.RDFImporter} The Importer
**/
$k.RDFImporter.prototype.setIdentifyGlobalResourcesByID = function(bool) { };
/**
* Ignore HTTP errors
*
* @function
* @param {boolean} bool
* @returns {$k.RDFImporter} The Importer
**/
$k.RDFImporter.prototype.setIgnoreHTTPExceptions = function(bool) { };
/**
* Allow deferred relation creation
*
* @function
* @param {boolean} bool
* @returns {$k.RDFImporter} The Importer
**/
$k.RDFImporter.prototype.setImportInverseRelationTypes = function(bool) { };
/**
* Import referenced resources
*
* @function
* @param {boolean} bool
* @returns {$k.RDFImporter} The Importer
**/
$k.RDFImporter.prototype.setImportReferencedResources = function(bool) { };
/**
* import strategy
*
* @function
* @param {string} strategy "updateOrCreate": Update or create if not found
* "default": Default
* "update": Update
* "replace": Replace
* "supress": Do not import
* "locate": Locate
*
* @returns {$k.RDFImporter} The Importer
**/
$k.RDFImporter.prototype.setImportStrategy = function(strategy) { };
/**
* Avoid duplicate properties
*
* @function
* @param {boolean} bool
* @returns {$k.RDFImporter} The Importer
**/
$k.RDFImporter.prototype.setLogModifiedRelationTargets = function(bool) { };
/**
* Set the logging callback function
*
* @function
* @param {Function} callback Callback function that receives two arguments, the affected element and a change type string
* @returns {$k.RDFImporter} The Importer
* @since 5.3.2
* @version Experimental feature, might be removed at any time
**/
$k.RDFImporter.prototype.setModifiedElementCallback = function(callback) { };
/**
* Import in a single transaction
*
* @function
* @param {boolean} bool False if not defined
* @returns {$k.RDFImporter} The Importer
**/
$k.RDFImporter.prototype.setSingleTransaction = function(bool) { };
/**
* Add imported objects to a folder (will be created in the private folder)
*
* @function
* @param {boolean} bool
* @returns {$k.RDFImporter} The Importer
**/
$k.RDFImporter.prototype.setStoreInFolder = function(bool) { };
/*global $k*/
/**
* Represents a relation.
* @class
* @extends $k.Property
**/
$k.Relation = function() { };
/**
* Returns the inverse relation
*
* @function
* @returns {$k.Relation}
**/
$k.Relation.prototype.inverseRelation = function() { };
/**
* Changes the relation Target
*
* @function
* @param {$k.SemanticElement} newTarget The new relation target.
* @returns {$k.Relation}
* @throws {$k.exception.SchemaError} If the relation can not point to the new target (either because new target is of wrong type or because no additional relations can be created for new target).
* @throws {$k.exception.AccessDenied} If changing the relation's target is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.Relation.prototype.relocate = function(newTarget) { };
/**
* Returns the relation target
*
* @function
* @returns {$k.SemanticElement}
**/
$k.Relation.prototype.target = function() { };
/*global $k*/
/**
* @class
**/
$k.RelationTargetCondition = function() { };
/**
* @deprecated This function is not supported any more
* @function
* @since 4.1.0
* @returns {number}
**/
$k.RelationTargetCondition.prototype.alternativesId = function() { };
/**
* Returns the parameter name of the condition, if defined
*
* @function
* @since 4.1.0
* @returns {string}
**/
$k.RelationTargetCondition.prototype.parameter = function() { };
/**
* Returns the relation condition
*
* @function
* @since 4.1.0
* @returns {$k.HasRelationCondition}
**/
$k.RelationTargetCondition.prototype.relationCondition = function() { };
/**
* Sets the parameter name of the condition
*
* @function
* @since 4.1.0
* @param {string} parameter
**/
$k.RelationTargetCondition.prototype.setParameter = function(parameter) { };
/**
* Set the transitivity of the relation.
*
* @function
* @since 4.1.0
* @see $k.HasRelationCondition#setTransitivity
**/
$k.RelationTargetCondition.prototype.setTransitivity = function(min, max, shortestPath) { };
/**
* Returns the subquery for the relation target
*
* @function
* @since 4.1.0
* @returns {$k.StructuredQuery}
**/
$k.RelationTargetCondition.prototype.targetQuery = function() { };
/*global $k*/
/**
* Represents a type of relations
* @class
* @extends $k.PropertyType
**/
$k.RelationType = function() { };
/**
* Returns the inverse relation type
*
* @function
* @returns {$k.RelationType}
**/
$k.RelationType.prototype.inverseRelationType = function() { };
/**
* Returns true if this is the main direction for the relation type.
*
* @function
* @returns {boolean}
**/
$k.RelationType.prototype.isMainDirection = function() { };
/**
* Returns true if this is a single sided relation type (i.e. only the main direction of the relation is stored in the volume).
*
* @function
* @returns {boolean}
**/
$k.RelationType.prototype.isSingleSided = function() { };
/**
* Returns true if this is a symmetric relation.
*
* @function
* @returns {boolean}
**/
$k.RelationType.prototype.isSymmetric = function() { };
/**
* Returns the possible ranges of the relation, which are the domains of the inverse relation
*
* @function
* @returns {$k.Domain[]}
**/
$k.RelationType.prototype.ranges = function() { };
/**
* @function
* @param {string} [searchString] Search string for the target element
* @param {$k.SemanticElement} [context] Context of the relationTargetSearch
* @returns {$k.SemanticElement}
* @version Experimental feature, might be removed at any time
**/
$k.RelationType.prototype.relationTargetSearch = function(searchString, context) { };
/*global $k*/
/**
* Creates a new RuleSet
*
* @param {object} topic The rule set topic
*
* @class
**/
$k.RuleSet = function(topic) { };
/**
* Returns the corresponding composite search
*
* @function
* @since 5.3.0
**/
$k.RuleSet.prototype.compositeSearch = function() { };
/**
* Solves the rule set
*
* @function
* @param {object} topic The parameter
* @since 5.3.0
**/
$k.RuleSet.prototype.solve = function(topic) { };
/*global $k*/
/**
* Represents a script job
* @class
**/
$k.ScriptJob = function() { };
/**
* Add the job to the job queue
*
* @function
**/
$k.ScriptJob.prototype.insert = function() { };
/**
* Set the name of the function to call. The script will be run as global script if no function name is set.
*
* @function
* @param {string} functionName Name of the function to call
**/
$k.ScriptJob.prototype.setFunctionName = function(functionName) { };
/**
* Sets the parameters passed to the script. If a function is specified, then the parameters are passed as the first argument. If no function is specified, then the variables will be added to the global context
*
* @function
* @param {object} parameters Parameters object
**/
$k.ScriptJob.prototype.setParameters = function(parameters) { };
/**
* Sets the priority of the job. Default priority is 100. The lower the number the higher the priority.
*
* @function
* @param {integer} priorityNumber Priority
**/
$k.ScriptJob.prototype.setPriority = function(priorityNumber) { };
/**
* Set the script
*
* @function
* @param {string} scriptID Registered ID of the script
**/
$k.ScriptJob.prototype.setScript = function(scriptID) { };
/**
* Set the user. If not set, the current user will be set on insert().
* Note: setting a different user is allowed only if elevatedDo() is allowed in this context, otherwise an access denied exception is thrown
*
* @function
* @param User
**/
$k.ScriptJob.prototype.setUser = function(User) { };
/*global $k*/
/**
* A collection of topics
* @class
* @extends $k.PersistentCollection
**/
$k.SemanticCollection = function() { };
/**
* Returns the elements of the collection
*
* @function
* @returns {$k.SemanticElement[]}
**/
$k.SemanticCollection.prototype.elements = function() { };
/*global $k*/
/**
* Represents an element of the semantic network.
* @class
**/
$k.SemanticElement = function() { };
/**
* Returns the attribute of the type (including sub-attributes), or undefined if no attribute exists
*
* @function
* @param type AttributeType or internal name
* @throws {$k.exception.NotUnique} If there is more than one attribute of this type
* @returns {$k.Attribute}
**/
$k.SemanticElement.prototype.attribute = function(type) { };
/**
* Returns all attributes of the type (including sub-attributes).
* Returns all attributes if the type is undefined
*
* @function
* @param [type] AttributeType or internal name or undefined
* @throws {$k.exception.SchemaError} If type is not an attribute
* @returns {$k.Attribute[]}
**/
$k.SemanticElement.prototype.attributes = function(type) { };
/**
* Returns the value of the attribute, or undefined if there is no such attribute
*
* @function
* @param type AttributeType or internal name
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns The value of the attribute
* @throws {$k.exception.NotUnique} If there is more than one attribute of this type
**/
$k.SemanticElement.prototype.attributeValue = function(type, language) { };
/**
* Returns the value string of the attribute, or undefined if there is no such attribute
*
* @function
* @since 4.1.0
* @param type AttributeType or internal name
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {string} The value string of the attribute
* @throws {$k.exception.NotUnique} If there is more than one attribute of this type
**/
$k.SemanticElement.prototype.attributeValueString = function(type, language) { };
/**
* Calls an internal behavior method
*
* @function
* @param {string} method Name of the method
* @param {object[]} [args] Arguments of the call
* @throws {$k.exception.RuntimeError} When the behavior method raises an exception
**/
$k.SemanticElement.prototype.callBehaviour = function(method, args) { };
/**
* Get the change log object of this SemanticElement as object
*
* @function
* @returns {object[]} A list of change log entries, each an conforming the below schema.
* Null if no change log is present for the SemanticElement.
*
* {
* "$schema" : "http://json-schema.org/draft-04/schema#",
* "type" : "object",
* "properties" :
* {
* "tag" : {
* "type" : "string",
* "enum" : ["AttributeEvent", "RelationEvent"],
* "description" : "is this a change for an attribute or a relation"
* },
* "type" : {
* "type" : "string",
* "enum" : ["modify", "create", "delete", "executeMapping"],
* "description" : "what kind of change is logged in this event"
* },
* "timestamp" : {
* "type" : "string",
* "description" : "time of the change; format: ISO 8601 timestamp string without timezone",
* },
* "topic" : {
* "type" : "object",
* "description" : "id and label of the changed object",
* "properties" : {
* "label" : { "type" : "string" },
* "id" : { "type" : "string" }
* }
* },
* "user" : {
* "type" : "object",
* "description" : "id and name of the user object which performed the change",
* "properties" : {
* "label" : { "type" : "string" },
* "id" :{ "type" : "string" }
* }
* },
* "property" : {
* "type" : "object",
* "description" : "id and label of the changed property type",
* "properties" : {
* "conceptId" : { "type" : "string" },
* "label" : { "type" : "string" }
* }
* },
* "value" : {
* "type" : "string",
* "description" : "string representation of the new value"
* },
* "language" : {
* "type" : "string",
* "description" : "language of the changed value; format: ISO639 3-letter code"
* },
* "oldValue" : {
* "type" : "string",
* "description" : "string representation of the previous value"
* },
* "target" : {
* "type" : "object",
* "description" : "id and label of the relation target object",
* "properties" : {
* "id" : { "type" : "string" },
* "label" : { "type" : "string" }
* }
* },
* "required" : [ "type", "tag", "timestamp", "topic" ]
* }
* }
*
**/
$k.SemanticElement.prototype.changeLog = function() { };
/**
* Returns the extended element, if this is an extension.
* Returns the element itself otherwise
*
* @function
* @returns {$k.SemanticElement}
**/
$k.SemanticElement.prototype.core = function() { };
/**
* Creates a new attribute with the given value
*
* @function
* @param type AttributeType or internal name
* @param value Value of the attribute. Pass undefined for attribute types without value.
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {$k.Attribute}
* @throws {$k.exception.InvalidValue} If the value is not in the range of allowed values of the attribute
* @throws {$k.exception.SchemaError} If type is not a possible attribute of the element, or if no additional attributes can be created.
* @throws {$k.exception.NotUnique} If there is more than one attribute of this type
* @throws {$k.exception.AccessDenied} If creating an attribute is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
* @example
* person.createAttribute("alias", "Tester");
**/
$k.SemanticElement.prototype.createAttribute = function(type, value, language) { };
/**
* Creates a new attribute and set the value from the string representation
*
* @function
* @deprecated Use <code>setAttributeValue($k.ValueString(valueString), language)</code> instead
* @param type AttributeType or internal name
* @param {string} valueString String represantation of the value
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {$k.Attribute}
* @throws {$k.exception.InvalidValue} If the value is not in the range of allowed values of the attribute
* @throws {$k.exception.SchemaError} If type is not a possible attribute of the element, or if no additional attributes can be created.
* @throws {$k.exception.NotUnique} If there is more than one attribute of this type
* @throws {$k.exception.AccessDenied} If creating an attribute is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
* @example
* person.createAttributeFromString("dateOfBirth", "2.3.1968", "de");
**/
$k.SemanticElement.prototype.createAttributeFromString = function(type, valueString, language) { };
/**
* Creates a new relation
*
* @function
* @param type RelationType or internal name
* @param {$k.SemanticElement} target The relation target.
* @param [inverse] RelationType or internal name of the inverse Relation. The default inverse relation type will be used if this parameter is undefined.
* @returns {$k.Relation}
* @throws {$k.exception.SchemaError} If type is not a possible relation of the element, or if no additional relations can be created.
* @throws {$k.exception.AccessDenied} If creating a relation is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.SemanticElement.prototype.createRelation = function(type, target, inverse) { };
/**
* Returns this element. Allows to send element() either to a $k.Hit or a semantic element
*
* @since 4.3.0
* @function
* @returns {$k.SemanticElement}
**/
$k.SemanticElement.prototype.element = function() { };
/**
* Returns an existing attribute with the given value. Otherwise creates and returns an additional attribute with the given value, or returns an existing attribute with modified value if the schema does not allow multiple occurrences.
*
* @function
* @since 4.3.0
* @param type AttributeType or internal name
* @param value The value that should be set.
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {$k.Attribute}
* @throws {$k.exception.InvalidValue} If the value is not in the range of allowed values of the attribute
* @throws {$k.exception.SchemaError} If type is not a possible attribute of the element
* @throws {$k.exception.AccessDenied} If modifying is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.SemanticElement.prototype.ensureAttributeValue = function(type, value, language) { };
/**
* Returns a existing relation to the target. Otherwise creates and returns an additional relation to the target, or returns an existing relation relocateded to the target if the schema does not allow multiple occurrences
*
* @function
* @since 4.3.0
* @param type RelationType or internal name
* @param {$k.SemanticElement} target The relation target.
* @param [inverse] RelationType or internal name of the inverse Relation. Only applies, if a new relation will be created. The default inverse relation type will be used if this parameter is undefined.
* @returns {$k.Relation}
* @throws {$k.exception.SchemaError} If type is not a possible relation of the element, or if no additional relations can be created.
* @throws {$k.exception.AccessDenied} If creating a relation is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
* @throws {$k.exception.RemoveNotPossible} If deleting the existing relation is not possible
**/
$k.SemanticElement.prototype.ensureRelationTarget = function(type, target, inverse) { };
/**
* Returns true if the type is a possible attribute of this element
*
* @function
* @param type AttributeType or internal name
* @returns {boolean}
**/
$k.SemanticElement.prototype.hasPossibleAttribute = function(type) { };
/**
* Returns true if the type is a possible relation of this element
*
* @function
* @param type RelationType or internal name
* @returns {boolean}
**/
$k.SemanticElement.prototype.hasPossibleRelation = function(type) { };
/**
* Returns the icon of the element as blob
*
* @since 4.1.0
* @function
* @param {array} [size] Size of icon as array
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {blob}
**/
$k.SemanticElement.prototype.icon = function(size, language) { };
/**
* Returns the icon of the element as blob attribute
*
* @since 5.3.0
* @function
* @param {array} [size] Size of icon as array
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {attribute}
**/
$k.SemanticElement.prototype.iconAttribute = function(size, language) { };
/**
* Returns the element ID as 64 bit integer.
* Returns undefined for non-persistent elements (system relations etc.)
*
* @deprecated Do not use due to 64 bit representation problems for numbers larger than 2^53 in JavaScript
* @function
* @returns {number}
**/
$k.SemanticElement.prototype.idNumber = function() { };
/**
* Returns the element ID as string (ID123_456).
* Returns undefined for non-persistent elements (system relations etc.)
*
* @function
* @returns {string}
**/
$k.SemanticElement.prototype.idString = function() { };
/**
* Returns the own attribute or the inherited attribute of the supertype(s).
* If there is more than one supertype, the attribute must be unique.
* If this is not a type, then this function is equivalent to attribute().
*
* @function
* @param type AttributeType or internal name
* @returns {$k.Attribute} The inherited attribute, or undefined if there is no attribute
* @throws {$k.exception.NotUnique} If there is more than one value of this type
**/
$k.SemanticElement.prototype.inheritedAttribute = function(type) { };
/**
* Returns the value of the own attribute or of the inherited value of the supertype(s).
* If there is more than one supertype, the value must be unique.
* If this is not a type, then this function is equivalent to attribute(value).
*
* @function
* @param type AttributeType or internal name
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns The inherited value, or undefined if there is no attribute
* @throws {$k.exception.NotUnique} If there is more than one value of this type
**/
$k.SemanticElement.prototype.inheritedAttributeValue = function(type, language) { };
/**
* True if the semantic element was deleted (e.g. by a rollback or remove()
*
* @function
* @returns {boolean}
**/
$k.SemanticElement.prototype.isInvalid = function() { };
/**
*
*
* @function
* @param pathString
**/
$k.SemanticElement.prototype.kPathEvaluate = function(pathString) { };
/**
* Returns the element locator as string
*
* @since 4.0.2
* @function
* @param {array} [locatorTypes]
* @returns {string}
**/
$k.SemanticElement.prototype.locatorString = function(locatorTypes) { };
/**
* Returns the modification number for the cluster conatining as 64 bit integer.
* Returns 0 for newly created topics that are not yet assigned to a cluster.
* Returns undefined for non-persistent elements (system relations etc.).
* An unchanged modification number indicates that the element is unchanged.
* A changed modification number does not necessarily indicate that the topic changed,
* because there might have been changes in other objects contained in the same cluster.
*
* @function
* @returns {number}
**/
$k.SemanticElement.prototype.modificationNumber = function() { };
/**
* Returns the name of the element
*
* @function
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {string}
**/
$k.SemanticElement.prototype.name = function(language) { };
/**
* @version Experimental feature, might be removed at any time
* @function
* @param {$k.User} user
**/
$k.SemanticElement.prototype.openInKnowledgeBuilder = function(user) { };
/**
* Returns the possible properties of this element.
*
* @function
* @param {$k.PropertyFilter} [filter] Optional filter that defines which properties are returned
* @returns {$k.PropertyType[]}
* @see $k.PropertyFilter
* @example
* // Possible properties, excluding shortcut / system relations
* possibleProperties();
* @example
* // Possible properties, including system relations
* possibleProperties($k.PropertyFilter.setSystemRelations());
* @example
* // Same as above, using a literal object to define the filter
* possibleProperties({ systemRelations: true });
**/
$k.SemanticElement.prototype.possibleProperties = function(filter) { };
/**
* Returns the primary element.
* - if the receiver is an instance or type, then the receiver itself is returned.
* - if the receiver is an extension, then the extended instance is returned.
* - if the receiver is a property, then the primary core of the source is returned.
*
* @function
* @returns {$k.SemanticElement}
* @since 4.2.0
**/
$k.SemanticElement.prototype.primaryCore = function() { };
/**
* Returns all properties of the property type
*
* @function
* @param {$k.PropertyFilter} [filter] Filter that defines which properties are returned
* @returns {$k.Property[]}
* @example
* // All properties
* properties();
* @example
* // All relations with internal name "contains", including sub-relations
* properties(new $k.PropertyFilter().setType("contains"));
* @example
* // All relations with internal name "contains", without sub-relations
* properties(new $k.PropertyFilter().setExact().setType("contains"));
* @example
* // Same as above, using a literal object to define the filter
* properties({ exact: true, type: "contains" });
**/
$k.SemanticElement.prototype.properties = function(filter) { };
/**
* Returns the relation of the type (including sub-relations), or undefined if no relation exists
*
* @function
* @param type RelationType or internal name
* @throws {$k.exception.SchemaError} If type is not a possible relation of the topic
* @throws {$k.exception.TypeError} If type is not a relation type
* @throws {$k.exception.NotUnique} If there is more than one relation of this type
* @returns {$k.Relation}
**/
$k.SemanticElement.prototype.relation = function(type) { };
/**
* Returns all relations of the type (including sub-relations).
* If type is undefined, all user relations (excluding inverse one way relations) are returned.
*
* @function
* @param [type] RelationType or internal name or undefined
* @throws {$k.exception.TypeError} If type is not a relation type
* @returns {$k.Relation[]}
**/
$k.SemanticElement.prototype.relations = function(type) { };
/**
* Returns the target of the relation of the relation type, or undefined if there is no such relation
*
* @function
* @param type RelationType or internal name
* @returns {$k.SemanticElement}
* @throws {$k.exception.NotUnique} If there is more than one relation of this type
* @throws {$k.exception.TypeError} If type is not a relation type
**/
$k.SemanticElement.prototype.relationTarget = function(type) { };
/**
* Returns the targets of the relations of the relation type. Each target is only returned once, even if multiple relations point to the same target.
* Returns all relation targets if the type is undefined
*
* @function
* @param type RelationType or internal name or undefined
* @returns {$k.SemanticElement[]}
* @throws {$k.exception.NotUnique} If there is more than one relation of this type
* @throws {$k.exception.TypeError} If type is not a relation type
**/
$k.SemanticElement.prototype.relationTargets = function(type) { };
/**
* Deletes the element and all attached properties
*
* @function
* @throws {$k.exception.AccessDenied} If deleting the element or any property not allowed
* @throws {$k.exception.RemoveNotPossible} If deleting the element is not possible, e.g. when trying to delete a system element
**/
$k.SemanticElement.prototype.remove = function() { };
/**
* Renders the element as a literal object using the associated view configuration.
* Uses the optional context topic to detect a suitable configuration
*
* @function
* @param {object} [context] Element that defines the context.
* @param {object} [keyFilter] Alternative 1: An array of strings defining a filter which property names to include.<br/>
* Alternative 2: An object with "include" and/or "exclude" keys<br/>
* <pre class="code">{"exclude": ["key1", ...]}</pre> includes all but the listed properties, while <pre class="code">{"include": ["key1", ...]}</pre> or <pre class="code">["key1", ...]</pre> includes only the listed properties.
* <br/>Non-optional properties are always included<br/>
* Alternative 3: A JSONRenderContext
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object} The rendered object
**/
$k.SemanticElement.prototype.render = function(context, keyFilter, detailFilter) { };
/**
* Render the element as a JavaScript object using the associated view configuration.
* Uses the optional context topic to detect a suitable configuration
*
* @function
* @deprecated Use <code>render(context, {"exclude": excludedKeys})</code> instead
* @param {$k.SemanticElement} [context] Element that defines the context.
* @param {string[]} [excludedKeys] Collection of property names that are excluded
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object} The rendered JSON object
**/
$k.SemanticElement.prototype.renderJSON = function(context, excludedKeys, detailFilter) { };
/**
* Render a document based on a given printtemplate
*
* @since 4.4.0
* @function
* @param {$k.SemanticElement} template the template that will be applied
* @param {$k.NetEntity} entity The render target
* @param {$k.SemanticElement} [conversion] the semantic element representing the document conversion
* @param {object} [variables] additional variables to pass to the template
**/
$k.SemanticElement.prototype.renderTemplate = function(template, entity, conversion, variables) { };
/**
* Sets the value of the attribute from the string representation. Creates a new attribute if no such attribute exists
*
* @function
* @deprecated Use <code>setAttributeValue(type, $k.ValueString(valueString), language)</code> instead
* @param type AttributeType or internal name
* @param {string} valueString String represantation of the value
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @throws {$k.exception.InvalidValue} If the value is not in the range of allowed values of the attribute
* @throws {$k.exception.SchemaError} If type is not a possible attribute of the element
* @throws {$k.exception.NotUnique} If there is more than one attribute of this type
* @throws {$k.exception.AccessDenied} If modifying is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.SemanticElement.prototype.setAttributeFromString = function(type, valueString, language) { };
/**
* Sets the value of the attribute. Creates a new attribute if no such attribute exists
*
* @function
* @param type AttributeType or internal name
* @param value The value that should be set.
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @throws {$k.exception.InvalidValue} If the value is not in the range of allowed values of the attribute
* @throws {$k.exception.SchemaError} If type is not a possible attribute of the element
* @throws {$k.exception.NotUnique} If there is more than one attribute of this type
* @throws {$k.exception.AccessDenied} If modifying is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.SemanticElement.prototype.setAttributeValue = function(type, value, language) { };
/**
* Sets the name of the element
*
* @function
* @param {string} name The name
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @throws {$k.exception.TypeError} If the name is not a string
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.SemanticElement.prototype.setName = function(name, language) { };
/**
* Sets the target of the relation. Creates a new relation if no such relation exists
*
* @function
* @since 4.3.0
* @param type RelationType or internal name
* @param {$k.SemanticElement} target The relation target.
* @param [inverse] RelationType or internal name of the inverse Relation. Only applies, if a new relation will be created. The default inverse relation type will be used if this parameter is undefined.
* @throws {$k.exception.SchemaError} If type is not a possible relation of the element, or if no additional relations can be created.
* @throws {$k.exception.NotUnique} If there is more than one relation of this type
* @throws {$k.exception.AccessDenied} If creating a relation is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
* @throws {$k.exception.RemoveNotPossible} If deleting the existing relation is not possible
**/
$k.SemanticElement.prototype.setRelationTarget = function(type, target, inverse) { };
/**
* Returns the type of the element.
* If the topic is a type, the type itself is returned
*
* @function
* @returns {$k.Type}
**/
$k.SemanticElement.prototype.type = function() { };
/**
* Update the prototype after sending $k.mapInstances(). Only required if this element was referenced before setting the mapping.
*
* @function
**/
$k.SemanticElement.prototype.updateMapping = function() { };
/**
* Returns the elements sorted by the given properties and sort orders
*
* @since 4.1.0
* @function
* @param {$k.SemanticElement[]} semanticElements
* @param {object[]} sortDescriptions Property (type or internal name), optional language for attribute values and optional sort order (ascending)
* @returns {$k.SemanticElement[]} The sorted elements
* @example
* $k.SemanticElement.sort(elements, [ {property: "dateOfBirth", language: "eng", ascending: false }, {property: "givenName" }])
* @see $k.TableConfiguration#sort
**/
$k.SemanticElement.sort = function(semanticElements, sortDescriptions) { };
/*global $k*/
/**
* Session for visualizing/editing views
* @class
**/
$k.Session = function() { };
/**
* Abort the (long running) session transaction.
*
* @function
**/
$k.Session.prototype.abort = function() { };
/**
* get the domain model element of the session
*
* @function
**/
$k.Session.prototype.element = function() { };
/**
* get the value of the given variable
*
* @function
* @param {string} variable
* @returns (arrays of) SemanticElements and timestamps are auto-converted to native form
**/
$k.Session.prototype.getVariable = function(variable) { };
/**
* Returns the panel configuration topic.
*
* @function
**/
$k.Session.prototype.panelConfiguration = function() { };
/**
* get the parent session of the session, undefined if it has no parent
*
* @function
**/
$k.Session.prototype.parent = function() { };
/**
* set the value of the given variable
*
* @function
* @param {string} variable
* @param value supported variable types include all javascript base types as well as: timestamp, SemanticElement and arrays of the latter
**/
$k.Session.prototype.setVariable = function(variable, value) { };
/**
* @function
**/
$k.Session.prototype.toJSON = function() { };
/**
* Returns the actual session if set, undefined if not. The actual session may differ from initial session in render phase
*
* @function
* @since 5.3.2
**/
$k.Session.actual = function() { };
/**
* Returns the current session if set, undefined if not. The current session does not change throughout action execution and result rendering
*
* @function
* @since 5.3.0
* @deprecated Deprecated because of confusing/misleading naming. Use initial() instead.
**/
$k.Session.current = function() { };
/**
* Returns the session corresponding to the given panel if available, undefined if not. Searches starting from the current session.
*
* @function
* @param {string} panelName The configuration name of the panel
* @version Experimental feature, might be removed at any time
**/
$k.Session.forPanel = function(panelName) { };
/**
* Returns the top session on the session stack as found initially at the beginning of the execution of an action. The initial session does not change throughout action execution and result rendering.
*
* @function
* @since 5.3.2
**/
$k.Session.initial = function() { };
/**
* Returns the main session if set, undefined if not.
*
* @function
**/
$k.Session.main = function() { };
/*global $k*/
/**
* Creates a new client that authenticates as an app
*
* @version Experimental feature, might be removed at any time
* @param {object} settings
* @param {string} [authentication] App authentication (ID + secret)
*
* @class
* @extends $k.SharePointClient
**/
$k.SharePointAppClient = function(settings, authentication) { };
/*global $k*/
/**
* Creates a new client that authenticates as a user
*
* @version Experimental feature, might be removed at any time
* @param {object} settings
* @param {string} [authentication] User authentication
*
* @class
**/
$k.SharePointClient = function(settings, authentication) { };
/**
* @version Experimental feature, might be removed at any time
* @function
* @param {string} libraryID
**/
$k.SharePointClient.prototype.getColumns = function(libraryID) { };
/**
* @version Experimental feature, might be removed at any time
* @function
* @param {string} fileRef
**/
$k.SharePointClient.prototype.getFile = function(fileRef) { };
/**
* @version Experimental feature, might be removed at any time
* @function
* @param {string} documentId
* @param {string} libraryGuid
**/
$k.SharePointClient.prototype.getFileRef = function(documentId, libraryGuid) { };
/**
* @version Experimental feature, might be removed at any time
* @function
* @param {string} documentId
* @param {string} libraryGuid
**/
$k.SharePointClient.prototype.getItem = function(documentId, libraryGuid) { };
/**
* @version Experimental feature, might be removed at any time
* @function
* @param {string} libraryGuid
**/
$k.SharePointClient.prototype.getItems = function(libraryGuid) { };
/**
* @version Experimental feature, might be removed at any time
* @function
* @param {string} url
**/
$k.SharePointClient.prototype.getURL = function(url) { };
/**
* @version Experimental feature, might be removed at any time
* @function
**/
$k.SharePointClient.prototype.siteURL = function() { };
/**
* @version Experimental feature, might be removed at any time
* @function
* @param {object} columnData
* @param {string} documentId
* @param {string} libraryGuid
**/
$k.SharePointClient.prototype.writeColumns = function(columnData, documentId, libraryGuid) { };
/**
* @version Experimental feature, might be removed at any time
* @function
* @param {object} tags
* @param {string} column
* @param {string} documentId
* @param {string} libraryGuid
**/
$k.SharePointClient.prototype.writeTags = function(tags, column, documentId, libraryGuid) { };
/*global $k*/
/**
* Constructs structured query
*
* @param {$k.Domain} [domains] The domain or internal name of a type
* @since 4.1.0
*
* Represents a structured query
* @class
* @extends $k.Query
**/
$k.StructuredQuery = function(domain) { };
/**
* Add an empty alternative condition group (OR group)
*
* @function
* @since 4.2.0
* @returns {$k.AlternativeGroupCondition}
**/
$k.StructuredQuery.prototype.addAlternativeGroup = function() { };
/**
* Add an empty attribute condition without value/cardinality conditions
*
* @function
* @since 4.1.0
* @param type AttributeType or internal name
* @throws {$k.exception.ObjectNotFound} If the attribute cannot be found
* @throws {$k.exception.TypeError} If the type is not an attribute type
* @throws {$k.exception.QueryError} If the condition is not valid
* @returns {$k.HasAttributeCondition}
**/
$k.StructuredQuery.prototype.addAttribute = function(type) { };
/**
* Add an attribute value condition
*
* @function
* @since 4.1.0
* @param type AttributeType or internal name
* @param [parameter] Parameter name of the value
* @param {string} [operator] Name of operator
* @param [defaultValue] Default value if no parameter is specified
* @throws {$k.exception.ObjectNotFound} If the attribute cannot be found
* @throws {$k.exception.TypeError} If the type is not an attribute type
* @throws {$k.exception.QueryError} If the condition is not valid
* @returns {$k.AttributeValueCondition}
**/
$k.StructuredQuery.prototype.addAttributeValue = function(type, parameter, operator, defaultValue) { };
/**
* Add a cardinality condition
*
* @function
* @since 4.1.0
* @param type AttributeType or internal name
* @param {number} cardinality Cardinality. Must be an integer >= 0.
* @param {string} [operator] Name of cardinality operator. "Equal cardinality" if not specified
* @throws {$k.exception.ObjectNotFound} If the type cannot be found
* @throws {$k.exception.TypeError} If the type is not a property type
* @throws {$k.exception.QueryError} If the condition is not valid
* @returns HasAttribute or HasRelation condition
**/
$k.StructuredQuery.prototype.addCardinality = function(type, cardinality, operator) { };
/**
* Add an element condition. Only elements from the list / parameter are returned.
*
* @function
* @since 4.1.0
* @param parameter Element or array of elements or the name of a parameter to use its value
* @throws {$k.exception.TypeError} If neither elements or a parameter was passed
* @throws {$k.exception.QueryError} If the condition is not valid
* @returns {$k.ElementsCondition}
**/
$k.StructuredQuery.prototype.addElementsFilter = function(parameter) { };
/**
* Add a handle
*
* @function
* @since 4.1.0
* @version Experimental feature, might be removed at any time
* @param {string} parameter
* @returns {Condition}
**/
$k.StructuredQuery.prototype.addHandle = function(parameter) { };
/**
* References another query that selects elements of this query according to the operator. If $k.Operator.EQUAL or NOT_EQUAL are selected, then the reference works in both directions. If $k.Operator.FILTER is selected, then the subquery is only applied to this query.
*
* @function
* @since 4.1.0
* @param [query] Referenced query. A new empty query will be referenced if not defined
* @param {string} [operator] An operator that defines how the subquery is applied. One of $k.Operator.EQUAL, NOT_EQUAL, FILTER. Default is FILTER
* @throws {$k.exception.QueryError} If the condition is not valid
* @returns {QueryReferenceCondition} Condition for the subquery
**/
$k.StructuredQuery.prototype.addQueryReference = function(query, operator) { };
/**
* Add an empty relation condition without target/cardinality conditions
*
* @function
* @since 4.1.0
* @param type RelationType or internal name
* @throws {$k.exception.ObjectNotFound} If the relation cannot be found
* @throws {$k.exception.TypeError} If the type is not an relation type
* @throws {$k.exception.QueryError} If the condition is not valid
* @returns {$k.HasRelationCondition}
**/
$k.StructuredQuery.prototype.addRelation = function(type) { };
/**
* Add a relation target condition
*
* @function
* @since 4.1.0
* @param type RelationType or internal name
* @param [targetQuery] Target query. If not specified an empty subquery will be build
* @throws {$k.exception.ObjectNotFound} If the relation cannot be found
* @throws {$k.exception.TypeError} If the type is not an relation type
* @throws {$k.exception.QueryError} If the condition is not valid
* @returns {$k.RelationTargetCondition} Condition for the relation target
**/
$k.StructuredQuery.prototype.addRelationTarget = function(type, targetQuery) { };
/**
* Returns a copy of the query. The copy can be modified.
*
* @function
* @since 4.1.0
* @returns {$k.StructuredQuery}
* @throws {$k.exception.QueryError} If the query cannot be cloned
**/
$k.StructuredQuery.prototype.clone = function() { };
/**
* Returns the conditions of the query
*
* @function
* @since 4.1.0
* @returns {QueryConditon[]}
**/
$k.StructuredQuery.prototype.conditions = function() { };
/**
* Returns the domains of the query
*
* @function
* @since 4.1.0
* @returns {$k.Domain[]}
**/
$k.StructuredQuery.prototype.domains = function() { };
/**
* Returns all hits that match the query
*
* @function
* @param {$k.Hit[]} hits
* @param {object} [parameters]
* @param {string} [searchString]
* @returns {$k.Hit[]}
* @throws {$k.exception.QueryError} When the query could not be solved, e.g. missing parameters
* @example
* var hits = $k.Registry.query("experts").filterHits(hits);
* @see $k.Query#setParameter
* @since 5.3.0
**/
$k.StructuredQuery.prototype.filterHits = function(hits, parameters, searchString) { };
/**
* Search and return all solutions
*
* @since 5.2.2
* @function
* @param {object} [parameters]
* @param {array} [singleElementIdentifiers]
* @returns {object[]} Each solution is an object containing an element of the result set, and all elements at identifiers of the query, e.g. <code>{element: element1, identifiers: { someIdentifier1: [ element2, ... ], someIdentifier2: [ element3, ... ] }}</code>. Each identifier in singleElementIdentifiers will be distribute multiple elements to one separate solution each
* @throws {$k.exception.QueryError} When the query could not be solved, e.g. missing parameters
**/
$k.StructuredQuery.prototype.findSolutions = function(parameters, singleElementIdentifiers) { };
/**
* Returns true if elements of subdomains should be returned
*
* @function
* @since 4.1.0
* @returns {boolean}
**/
$k.StructuredQuery.prototype.inheritance = function() { };
/**
* Returns the conditions pointing to this query
*
* @function
* @since 4.1.0
* @returns {QueryConditon[]}
**/
$k.StructuredQuery.prototype.inverseConditions = function() { };
/**
* Set a parameter of the query.
*
* @function
* @param {string} accessParameter One of the access parameters ("topic", "property", "accessedObject", "concept", "user" etc)
* @param value The value of the parameter. The type (string etc.) depends on the parameter. Arrays of values can be passed, too. The value undefined or null disables the parametrized condition.
* @throws {$k.exception.TypeError} When the value is not suitable for the parameter
**/
$k.StructuredQuery.prototype.setAccessParameter = function(accessParameter, value) { };
/**
* Set the conditions as alternatives (OR group). If <= 1 conditions are passed this will be a no-op.
*
* @deprecated Use <code>addAlternativeGroup()</code> instead
* @function
* @since 4.1.0
* @param {QueryCondition[]} conditions Conditions of this query that should be alternatives
* @throws {$k.exception.QueryError} If the conditions cannot be alternatives of this query
* @throws {$k.exception.TypeError}
**/
$k.StructuredQuery.prototype.setAlternatives = function(conditions) { };
/**
* Set to false if elements of subdomains should not be returned
*
* @function
* @since 4.1.0
* @param {boolean} useInheritance
**/
$k.StructuredQuery.prototype.setInheritance = function(useInheritance) { };
/**
* Determines whether causes should be merged when filtering hits
*
* @function
* @param {boolean} mergeCauses
* @since 5.3.0
* @version Experimental feature, might be removed at any time
**/
$k.StructuredQuery.prototype.setMergeCauses = function(mergeCauses) { };
/*global $k*/
/**
* Configuration of a table
* @class
* @extends $k.AbstractEditorConfiguration
**/
$k.TableConfiguration = function() { };
/**
* Returns the columns of the table
*
* @since 4.1.0
* @function
* @param {$k.Domain} domain Domain or internal name of a type of the table
* @param {object} [contextObject] JSON render context object
* @returns {object}
**/
$k.TableConfiguration.prototype.columns = function(domain, contextObject) { };
/**
* @since 4.1.0
* @function
* @returns {$k.SemanticElement}
**/
$k.TableConfiguration.prototype.configElement = function() { };
/**
* Set context object
*
* @deprecated Use <code>setContext()</code>
* @function
* @param {object} contextObject Context object
* @returns {$k.TableConfiguration}
**/
$k.TableConfiguration.prototype.context = function(contextObject) { };
/**
* Create properties for each column with a filter value to the element
*
* @since 4.1.0
* @version Experimental feature, might be removed at any time
* @function
* @param {$k.SemanticElement} element
**/
$k.TableConfiguration.prototype.createFilterProperties = function(element) { };
/**
* Returns the filtered, sorted and paged elements of this table
*
* @since 4.2.0
* @function
* @param [elementsOrQuery] Filter, sort and page elements. Input value can be: elements (no search, only filter, sort and page), a search (search the elements to used) or undefined (Internally, a search with the context object built)
* @param {object} [keyFilter] Alternative 1: An array of strings defining a filter which property names to include.<br/>
* Alternative 2: An object with "include" and/or "exclude" keys<br/>
* <pre class="code">{"exclude": ["key1", ...]}</pre> includes all but the listed properties, while <pre class="code">{"include": ["key1", ...]}</pre> or <pre class="code">["key1", ...]</pre> includes only the listed properties.
* <br/>Non-optional properties are always included<br/>
* Alternative 3: A JSONRenderContext
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {$k.SemanticElement[]} The filtered, sorted and paged elements
**/
$k.TableConfiguration.prototype.elements = function(elementsOrQuery, keyFilter, detailFilter) { };
/**
* Filters the elements by the given column values
*
* @since 4.1.0
* @function
* @param {$k.SemanticElement[]} elements
* @param {object[]} filterDescriptions Column index/name and value: {column: indexOrName, value: "<valueString>", operator: "<operatorName>". <p/>
* Operator is one of: "containsPhrase", "covers", "distance", "equal" (or "=="), "equalBy", "equalCardinality", "equalGeo", "equalMaxCardinality", "equalMinCardinality", "equalPresentTime", "equalsTopicOneWay", "fulltext", "greater" (or ">"), "greaterOrEqual" (or ">="), "greaterOverlaps", "greaterPresentTime", "isCoveredBy", "less" (or "<"), "lessOrEqual" (or "<="), "lessOverlaps", "lessPresentTime", "notEqual" (or "!="), "overlaps", "range", "regexEqual", "regexFulltext", "unmodifiedEqual", "words"
* @param {boolean} [disableInheritance] True if the query should only match direct instances/subtypes
* @returns {$k.SemanticElement[]} The filtered elements
* @throws {$k.exception.InvalidValue} If the filter values are invalid
* @throws {$k.exception.MissingParameter} If the filter value for a column is missing
* @throws {$k.exception.QueryError} If filtering was not possible
* @example
* configuration.filter(elements, [ {column: "familyName", value: "Doe" }])
**/
$k.TableConfiguration.prototype.filter = function(elements, filterDescriptions, disableInheritance) { };
/**
* Renders the elements as literal objects
*
* @since 4.1.0
* @function
* @param [elements] Elements, query or undefined
* @param {object} [keyFilter] Alternative 1: An array of strings defining a filter which property names to include.<br/>
* Alternative 2: An object with "include" and/or "exclude" keys<br/>
* <pre class="code">{"exclude": ["key1", ...]}</pre> includes all but the listed properties, while <pre class="code">{"include": ["key1", ...]}</pre> or <pre class="code">["key1", ...]</pre> includes only the listed properties.
* <br/>Non-optional properties are always included<br/>
* Alternative 3: A JSONRenderContext
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object[]} The rendered objects
**/
$k.TableConfiguration.prototype.render = function(elements, keyFilter, detailFilter) { };
/**
* Renders the elements as an Excel file
*
* @since 4.1.0
* @version Experimental feature, might be removed at any time
* @function
* @param {$k.SemanticElement[]} elements The elements to render
* @param {$k.NetEntity} entity The render target
**/
$k.TableConfiguration.prototype.renderExcel = function(elements, entity) { };
/**
* Render the elements as a JSON object
*
* @function
* @deprecated Use <code>render(elements, {"exclude": excludedKeys})</code> instead
* @param {$k.SemanticElement[]} elements
* @param {string[]} [excludedKeys] Collection of property names that are excluded
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object} The rendered JSON object
**/
$k.TableConfiguration.prototype.renderJSON = function(elements, excludedKeys, detailFilter) { };
/**
* Find the elements by the given column values
*
* @since 4.1.0
* @function
* @param {$k.Domain} domain Domain or internal name of a type of the table
* @param {object[]} filterDescriptions Column index/name and value: {column: indexOrName, value: "<valueString>", operator: "<operatorName>". <p/>
* Operator is one of: "containsPhrase", "covers", "distance", "equal" (or "=="), "equalBy", "equalCardinality", "equalGeo", "equalMaxCardinality", "equalMinCardinality", "equalPresentTime", "equalsTopicOneWay", "fulltext", "greater" (or ">"), "greaterOrEqual" (or ">="), "greaterOverlaps", "greaterPresentTime", "isCoveredBy", "less" (or "<"), "lessOrEqual" (or "<="), "lessOverlaps", "lessPresentTime", "notEqual" (or "!="), "overlaps", "range", "regexEqual", "regexFulltext", "unmodifiedEqual", "words"
* @param {boolean} [disableInheritance] True if the query should only match direct instances/subtypes
* @returns {$k.SemanticElement[]}
* @throws {$k.exception.InvalidValue} If the filter values are invalid
* @throws {$k.exception.MissingParameter} If the filter value for a column is missing
* @throws {$k.exception.QueryError} If filtering was not possible
* @example
* configuration.search([ {column: "dateOfBirth", value: "1970", operator: "less" }])
**/
$k.TableConfiguration.prototype.search = function(domain, filterDescriptions, disableInheritance) { };
/**
* Set the context object
*
* @since 4.1.0
* @function
* @param {object} contextObject Context object
* @see [Table defintion in JSON-schema reference](http://documentation.i-views.com/5.3/javascript-api//viewconfig-json-schema/index.html#/definitions/table)
* @returns {$k.TableConfiguration}
**/
$k.TableConfiguration.prototype.setContext = function(contextObject) { };
/**
* Set the query that returns the table elements. Note that the query is part of the context and will be overwritten if the context is set with setContext()
*
* @since 4.1.0
* @function
* @param {$k.Query} query
**/
$k.TableConfiguration.prototype.setQuery = function(query) { };
/**
* Returns the elements sorted by the given columns and sort orders
*
* @since 4.1.0
* @function
* @param {$k.SemanticElement[]} semanticElements
* @param {object[]} [sortDescriptions] Column index/name and optional sort order (ascending). The configured sort order is used if this parameter is undefined.
* @returns {$k.SemanticElement[]} The sorted elements
* @example
* configuration.sort(elements, [ {column: "familyName", ascending: false }, {column: "givenName" }])
**/
$k.TableConfiguration.prototype.sort = function(semanticElements, sortDescriptions) { };
/**
* Returns the configured sort descriptions of the table
*
* @since 4.1.0
* @function
* @returns {object[]}
**/
$k.TableConfiguration.prototype.sortDescriptions = function() { };
/**
* @function
**/
$k.TableConfiguration.prototype.toJSON = function() { };
/**
* Returns the table confguration for the domain and the optional context)
*
* @since 4.1.0
* @function
* @param {$k.Domain} domain Domain or internal name of a type of the table
* @param {$k.SemanticElement} [context] Context of the configuration
* @returns {$k.TableConfiguration}
**/
$k.TableConfiguration.forDomain = function(domain, context) { };
/**
* Returns the confguration defined by the element
*
* @since 4.1.0
* @function
* @param {$k.SemanticElement} configurationElement The configuration element
* @returns {$k.TableConfiguration}
**/
$k.TableConfiguration.from = function(configurationElement) { };
/*global $k*/
/**
* Creates a new tag
*
* @param {string} canonicalText The canonical text
*
* Represents the result of a Tagger
* @class
**/
$k.Tag = function(canonicalText) { };
/**
* Returns the canonical text of the tag
*
* @function
* @returns {string}
* @since 5.2.0
**/
$k.Tag.prototype.canonicalText = function() { };
/**
* Returns optional custom properties of the tag
*
* @function
* @returns {object}
* @since 5.2.0
**/
$k.Tag.prototype.customProperties = function() { };
/**
* The semantic element associated with this tag
*
* @function
* @returns {$k.SemanticElement}
* @since 5.2.0
**/
$k.Tag.prototype.element = function() { };
/**
* Returns the tag type returned by the tagging interface
*
* @function
* @returns {string}
* @since 5.2.0
**/
$k.Tag.prototype.interfaceTagType = function() { };
/**
* Returns the language of the tag
*
* @function
* @returns {string}
* @since 5.2.0
**/
$k.Tag.prototype.language = function() { };
/**
* Returns the relation between the source object and the tagged object
*
* @function
* @returns {$k.SemanticElement}
* @since 5.2.0
**/
$k.Tag.prototype.linkingRelation = function() { };
/**
* Returns the quality of the tag as returned by the interface
*
* @function
* @returns {number}
* @since 5.2.0
**/
$k.Tag.prototype.quality = function() { };
/**
* Sets the canonical text of the tag
*
* @function
* @since 5.2.0
**/
$k.Tag.prototype.setCanonicalText = function(text) { };
/**
* Set the semantic element associated with this tag
*
* @function
* @since 5.2.0
**/
$k.Tag.prototype.setElement = function(semanticElement) { };
/**
* Set the interface tag type. This type can be used in the tagging configuration.
*
* @function
* @since 5.2.0
**/
$k.Tag.prototype.setInterfaceTagType = function() { };
/**
* Sets the language of the tag
*
* @function
* @since 5.2.0
**/
$k.Tag.prototype.setLanguage = function(language) { };
/**
* Sets the relation between the source object and the tagged object
*
* @function
* @since 5.2.0
**/
$k.Tag.prototype.setLinkingRelation = function() { };
/**
* Sets the quality of the tag
*
* @function
* @since 5.2.0
**/
$k.Tag.prototype.setQuality = function(quality) { };
/**
* Sets other text variants of the tag
*
* @function
* @since 5.2.0
**/
$k.Tag.prototype.setTextVariants = function(variants) { };
/**
* Returns the spans of the tag. A span is returned as <code>{ start: startIndex, end: endIndex }</code>
*
* @function
* @returns {$k.SemanticElement}
* @since 5.2.0
**/
$k.Tag.prototype.spans = function() { };
/**
* Returns the priority of the tag type, given by the order in the hierarchy
*
* @function
* @returns {number}
* @since 5.3.0
**/
$k.Tag.prototype.tagTypePriority = function() { };
/**
* Returns other text variants of the tag found in the text
*
* @function
* @returns {string[]}
* @since 5.2.0
**/
$k.Tag.prototype.textVariants = function() { };
/*global $k*/
/**
* Configuration of a Tagger
* @class
**/
$k.TaggingConfiguration = function() { };
/**
* Tags the document using the parameters defined by the context. The context is stateful and must be created for each call of this function.
*
* @function
* @param {$k.TaggingContext} taggingContext
* @since 5.2.0
**/
$k.TaggingConfiguration.prototype.tag = function(taggingContext) { };
/**
* Returns the tag type configurations defined for the element
*
* @function
* @since 5.2.0
**/
$k.TaggingConfiguration.prototype.tagTypeConfigurations = function() { };
/**
* Returns the tagging confguration defined by the element
*
* @function
* @param {$k.SemanticElement} configurationElement The tagging configuration element (semantic element, identifier oder element id)
* @returns {$k.TaggingConfiguration}
* @example
* // Build a tagger from an existing configuration
* var configElement = $k.Registry.elementAtValue("tagging.name", "opennlp tagger config");
* var tagger = $k.TaggingConfiguration.from(configElement);
* @since 5.2.0
**/
$k.TaggingConfiguration.from = function(configurationElement) { };
/*global $k*/
/**
* Hold parameters and results during tagging. Needs to be recreated with every call to tag().
* @class
**/
$k.TaggingContext = function() { };
/**
* Returns the language detected by the tagger
*
* @function
* @returns {string}
* @since 5.2.0
**/
$k.TaggingContext.prototype.detectedLanguage = function() { };
/**
* Returns the language used for tagging. Might be used by the tagger to improve tagging.
*
* @function
* @returns {string}
* @since 5.2.0
**/
$k.TaggingContext.prototype.language = function() { };
/**
* Sets the language used for tagging. Might be used by the tagger to improve tagging.
*
* @function
* @param {string} language Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng")
* @since 5.2.0
**/
$k.TaggingContext.prototype.setLanguage = function(language) { };
/**
* Set to true if new objects should be created for unknown tags automatically. Additionaly requires that the tag type specifies that objects should be created.
*
* @function
* @param {boolean} shouldCreateTags
* @since 5.2.0
**/
$k.TaggingContext.prototype.setShouldCreateTags = function(shouldCreateTags) { };
/**
* Set to true if the tag objects should be linked to the source object with a relation
*
* @function
* @param {boolean} shouldLink
* @since 5.2.0
**/
$k.TaggingContext.prototype.setShouldLinkTags = function(shouldLink) { };
/**
* Set to true if persistent tags should be preserved
*
* @function
* @param {boolean} shouldPreserveTags
* @since 5.2.0
**/
$k.TaggingContext.prototype.setShouldPreserveTags = function(shouldPreserveTags) { };
/**
* Set to true if obsolete tag relations should be deleted after tagging
*
* @function
* @param {boolean} shouldSyncRelations
* @since 5.2.0
**/
$k.TaggingContext.prototype.setShouldSyncRelations = function(shouldSyncRelations) { };
/**
* Sets the tagging source. Tagging relations will be created between this object and the tag objects. If no text is defined by this context, then the text will be extracted from the source by applying the text extraction configuration.
*
* @function
* @param {$k.SemanticElement} source
* @since 5.2.0
**/
$k.TaggingContext.prototype.setSource = function(source) { };
/**
* Sets the text to tag. If not defined then the text will be extracted from the source object.
*
* @function
* @returns {string}
* @since 5.2.0
**/
$k.TaggingContext.prototype.setText = function(text) { };
/**
* Returns true if new objects should be created for unknown tags automatically. Additionaly requires that the tag type specifies that objects should be created. The default value is true.
*
* @function
* @returns {boolean}
* @since 5.2.0
**/
$k.TaggingContext.prototype.shouldCreateTags = function() { };
/**
* Returns true if the tag objects should be linked to the source object with a relation. The default value is true.
*
* @function
* @returns {boolean}
* @since 5.2.0
**/
$k.TaggingContext.prototype.shouldLinkTags = function() { };
/**
* True if persistent tags should be preserved
*
* @function
* @returns {boolean}
* @since 5.2.0
**/
$k.TaggingContext.prototype.shouldPreserveTags = function() { };
/**
* True if obsolete tag relations should be deleted after tagging. The default value is true.
*
* @function
* @returns {boolean}
* @since 5.2.0
**/
$k.TaggingContext.prototype.shouldSyncRelations = function() { };
/**
* Returns the tagging source
*
* @function
* @returns {$k.SemanticElement}
* @since 5.2.0
**/
$k.TaggingContext.prototype.source = function() { };
/**
* Returns the tags found by the tagger
*
* @function
* @returns {$k.Tag[]}
* @since 5.2.0
**/
$k.TaggingContext.prototype.tags = function() { };
/**
* Returns the text to tag. If not defined then the text will be extracted from the source object.
*
* @function
* @returns {string}
* @since 5.2.0
**/
$k.TaggingContext.prototype.text = function() { };
/*global $k*/
/**
* This configuration is used to map tags to semantic elements.
* @class
**/
$k.TagTypeConfiguration = function() { };
/**
* Returns the tag list for this tag type in a format suitable for the Intrafind tagger
*
* @function
* @param {string} [language] Language identifier string or Undefined
* @param {boolean} [removeDuplicates] Remove duplicate strings in this list of tags
* @since 5.2.0
**/
$k.TagTypeConfiguration.prototype.intrafindTagList = function(language, removeDuplicates) { };
/**
* Returns the tag type configuration defined by the element
*
* @function
* @param {$k.SemanticElement} configurationElement The tag type configuration element (semantic element, identifier oder element id)
* @returns {$k.TagTypeConfiguration}
* @since 5.2.0
**/
$k.TagTypeConfiguration.from = function(configurationElement) { };
/*global $k*/
/**
* Represents a text document
* @class
* @extends $k.AbstractTextDocument
**/
$k.TextDocument = function() { };
/*global $k*/
/**
* Constructs a Time from the argument(s), which can be a Date object, undefined, milliseconds (UTC) or component values.
* If undefined, the current time is returned
*
* @param [hours] Date or hours
* @param [minutes] Minutes
* @param [seconds] Seconds
*
* Represents a time without timezone
* @class
**/
$k.Time = function(varargs) { };
/**
* Returns true if the values are equal
*
* @function
* @returns {boolean}
**/
$k.Time.prototype.equals = function(value) { };
/**
* Returns the hours
*
* @function
* @returns {number}
**/
$k.Time.prototype.getHours = function() { };
/**
* Returns the minutes
*
* @function
* @returns {number}
**/
$k.Time.prototype.getMinutes = function() { };
/**
* Returns the seconds
*
* @function
* @returns {number}
**/
$k.Time.prototype.getSeconds = function() { };
/**
* Returns the latest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T23:59:59.999 for the date 2007-03-01.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.Time.prototype.maxDate = function() { };
/**
* Returns the latest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T23:59:59.999 for the date 2007-03-01.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.Time.prototype.maxUTCDate = function() { };
/**
* Returns the earliest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T0:00:00.0 for the date 2007-03-01.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.Time.prototype.minDate = function() { };
/**
* Returns the earliest exact Javascript date that is within the range of this date/time, e.g. 2007-03-01T0:00:00.0 for the date 2007-03-01.
* Assumes that this is an UTC date/time
*
* @function
* @returns {Date}
**/
$k.Time.prototype.minUTCDate = function() { };
/**
* Sets the hours
*
* @function
* @param {number} hours
**/
$k.Time.prototype.setHours = function(hours) { };
/**
* Sets the minutes.
*
* @function
* @param {number} minutes
**/
$k.Time.prototype.setMinutes = function(minutes) { };
/**
* Sets the seconds.
*
* @function
* @param {number} seconds
**/
$k.Time.prototype.setSeconds = function(seconds) { };
/**
* Returns the date/time as a Javascript date object.
* Assumes that this is a date/time of the local timezone
*
* @function
* @returns {Date}
**/
$k.Time.prototype.toDate = function() { };
/**
* Returns an ISO 8601 representation of the date/time
*
* @function
* @since 4.1.0
**/
$k.Time.prototype.toISOString = function() { };
/**
* Returns a string representing the date/time, similar to Date.prototype.toJSON ( key )
*
* @function
* @see $k.Date#toJSON
**/
$k.Time.prototype.toJSON = function(key) { };
/**
* Returns the string representation. Equivalent to valueString()
*
* @function
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {string}
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
**/
$k.Time.prototype.toString = function(language) { };
/**
* Returns the date/time as a Javascript date object.
* Assumes that this is an UTC date/time
*
* @function
* @returns {Date}
**/
$k.Time.prototype.toUTCDate = function() { };
/**
* Returns the internal millisecond value. Allows comparing date/time values, since the comparision operators call valueOf()
*
* @function
* @returns {number}
**/
$k.Time.prototype.valueOf = function() { };
/**
* Returns the string representation
*
* @function
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {string}
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
**/
$k.Time.prototype.valueString = function(language) { };
/**
* Parse the date/time string. Both ISO 8601 and localized strings are supported.
*
* @function
* @param {string} string The string representation
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns The parsed date/time
* @throws {$k.exception.InvalidLanguage} If an invalid language was specified
* @throws {$k.exception.InvalidValue} If value is invalid
**/
$k.Time.parse = function(string, language) { };
/*global $k*/
/**
* Represents a type
* @class
* @extends $k.SemanticElement
**/
$k.Type = function() { };
/**
* Add a supertype
*
* @function
* @param type Type or internal name
* @throws {$k.exception.TypeError} If the argument is not a valid supertype
* @throws {$k.exception.SchemaError} If the argument cannot be added as supertype
* @throws {$k.exception.AccessDenied} If adding the type is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.Type.prototype.addSupertype = function(type) { };
/**
* Returns all instances of this type and all subtypes.
* Avoid using this function if possible, use queries instead
*
* @function
* @returns {$k.Instance[]}
**/
$k.Type.prototype.allInstances = function() { };
/**
* Returns all subtypes
*
* @function
* @returns {$k.Type[]}
**/
$k.Type.prototype.allSubtypes = function() { };
/**
* Returns all supertypes
*
* @function
* @returns {$k.Type[]}
**/
$k.Type.prototype.allSupertypes = function() { };
/**
* Returns true if instances of this type can be created as extensions of instances.
* Only either canCreateExtensions() or canCreateInstances() can be true.
* isAbstract() is true if neither canCreateExtensions() nor canCreateInstances() is true.
*
* @function
* @returns {boolean}
* @see $k.Instance#createExtension
* @see $k.Type#canCreateInstances
* @see $k.Type#isAbstract
**/
$k.Type.prototype.canCreateExtensions = function() { };
/**
* Returns true if instances / properties of this type can be created.
* Only either canCreateExtensions() or canCreateInstances() can be true.
* isAbstract() is true if neither canCreateExtensions() nor canCreateInstances() is true.
*
* @function
* @returns {boolean}
* @see $k.Type#canCreateExtensions
* @see $k.Type#isAbstract
**/
$k.Type.prototype.canCreateInstances = function() { };
/**
* Returns the domain of the instances of this type
*
* @function
* @returns {$k.Domain}
**/
$k.Type.prototype.domain = function() { };
/**
* Returns the estimated number of instances of this type
*
* @function
* @returns {number}
**/
$k.Type.prototype.estimatedNumberOfInstances = function() { };
/**
* Returns the value of the counter associated with this type.
*
* @function
* @returns {number}
**/
$k.Type.prototype.getCounter = function() { };
/**
* Increases and returns the value of the counter associated with this type. The counter can be increased concurrently.
*
* @function
* @returns {number}
**/
$k.Type.prototype.increaseCounter = function() { };
/**
* Returns all direct instances of this type.
* Avoid using this function if possible, use queries instead
*
* @function
* @returns {$k.Instance[]}
**/
$k.Type.prototype.instances = function() { };
/**
* Returns the internal name
*
* @function
* @returns {string}
**/
$k.Type.prototype.internalName = function() { };
/**
* Returns true if this is an abstract type (cannot create properties/instances/extensions).
* isAbstract() is true if neither canCreateExtensions() nor canCreateInstances() is true.
*
* @function
* @returns {boolean}
**/
$k.Type.prototype.isAbstract = function() { };
/**
* Returns true if this is equal to or a direct or indirect type of the other type
*
* @function
* @param type Type or internal name
* @returns {boolean}
* @throws {$k.exception.TypeError} If the argument is not a type
* @throws {$k.exception.SchemaError} If the argument is an unknown internal name
**/
$k.Type.prototype.isKindOf = function(type) { };
/**
* Returns the exact number of instances of this type
*
* @function
* @returns {number}
**/
$k.Type.prototype.numberOfInstances = function() { };
/**
* Remove a supertype
*
* @function
* @throws {$k.exception.TypeError} If the argument is not a valid supertype
* @throws {$k.exception.AccessDenied} If removing the type is not allowed
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.Type.prototype.removeSupertype = function(supertype) { };
/**
* @function
**/
$k.Type.prototype.schemaReportOn = function(context) { };
/**
* Set to true if it should be possible to extend other instances with instances of this tyoe.
* The flag cannot be set to false if extensions exist.
* Only either canCreateExtensions() or canCreateInstances() can be true.
*
* @function
* @param {boolean} canCreate
* @throws {$k.exception.SchemaError} If it is not possible to change the schema, e.g. when the type already allows to create instances
* @see $k.Type#canCreateExtensions
* @see $k.Type#setCanCreateInstances
**/
$k.Type.prototype.setCanCreateExtensions = function(canCreate) { };
/**
* Set to true if it should be possible to create instances / properties this type.
* The flag cannot be set to false if instances exist.
* Only either canCreateExtensions() or canCreateInstances() can be true.
*
* @function
* @param {boolean} canCreate
* @throws {$k.exception.SchemaError} If it is not possible to change the schema, e.g. when the type already allows to create extensions
* @see $k.Type#canCreateInstances
* @see $k.Type#setCanCreateExtensions
**/
$k.Type.prototype.setCanCreateInstances = function(canCreate) { };
/**
* Set the initial value of the counter associated with this type. Note: this cannot be done concurrently. Use increaseCounter() instead.
*
* @function
* @param {number} counterValue Must be an integer
* @returns {number} The counter value
* @see $k.Type#increaseCounter
**/
$k.Type.prototype.setCounter = function(counterValue) { };
/**
* Sets the internal name, or removes the internal name if null is passed
*
* @function
* @param name New internal name or null
* @throws {$k.exception.TypeError} If the argument is not a valid internal name
* @throws {$k.exception.AccessDenied} If modifying the type is not allowed
* @throws {$k.exception.NotUnique} If the internal name is not unique
* @throws {$k.exception.TransactionError} If no write transaction is active
**/
$k.Type.prototype.setInternalName = function(name) { };
/**
* Returns the direct subtypes
*
* @function
* @returns {$k.Type[]}
**/
$k.Type.prototype.subtypes = function() { };
/**
* Returns the direct supertypes
*
* @function
* @returns {$k.Type[]}
**/
$k.Type.prototype.supertypes = function() { };
/**
* Returns the domain that represents this type and its subtype
*
* @function
* @returns {$k.Domain}
**/
$k.Type.prototype.typeDomain = function() { };
/*global $k*/
/**
* Provides UI interaction in action scripts
* @class
**/
$k.UI = function() { };
/**
* Show a notification dialog
*
* @function
* @function
* @param {string} message
* @param {string} [windowTitle]
**/
$k.UI.prototype.alert = function(message, windowTitle) { };
/**
* Let the user choose an object from a list
*
* @function
* @function
* @param {object[]} objects
* @param {string} message
* @param {string} [windowTitle]
* @param {function} [stringFunction] Function that returns a string that should be displayed for an element
* @returns {object} Returns undefined if no UI is available
**/
$k.UI.prototype.choose = function(objects, message, windowTitle, stringFunction) { };
/**
* Let the user choose some objects from a list. Shows details of the objects.
*
* @function
* @function
* @param {object[]} objects
* @param {string} [message]
* @returns {objects} Returns undefined if no UI is available
**/
$k.UI.prototype.chooseExpanded = function(objects, message) { };
/**
* Let the user choose some objects from a list.
*
* @function
* @function
* @param {object[]} objects
* @param {string} message
* @param {string} [windowTitle]
* @param {function} [stringFunction] Function that returns a string that should be displayed for an element
* @returns {objects} Returns undefined if no UI is available
**/
$k.UI.prototype.chooseMultiple = function(objects, message, windowTitle, stringFunction) { };
/**
* Show a confirmation dialog
*
* @function
* @function
* @param {string} message
* @param {string} [windowTitle]
* @returns {boolean} True if confirmed, false if not. Returns undefined if no UI is available.
**/
$k.UI.prototype.confirm = function(message, windowTitle) { };
/**
* True if UI interaction is possible
*
* @since 5.2.1
* @function
* @function
* @returns {boolean}
**/
$k.UI.prototype.hasUI = function() { };
/**
* Open a notification dialog that stays open while the notification function is evaluated
*
* @function
* @function
* @param {Function} notificationFunction Notification function
* @param {boolean[]} [parameters]
* @param {string} [windowTitle]
* @see UIObject#raiseNotification
* @since 4.1.0
**/
$k.UI.prototype.notificationDialog = function(notificationFunction, parameters, windowTitle) { };
/**
* Opens an editor on the element
*
* @function
* @function
* @param {$k.SemanticElement} element
* @param [context] Context that should be used to detect the view configuration, or a view configuration
* @param [options] Possible key in option object: #isNew
**/
$k.UI.prototype.openEditor = function(element, context, options) { };
/**
* Opens a graph on the elements
*
* @since 5.3.2
* @function
* @function
* @param {$k.SemanticElement[]} elements Graph elements or hits
* @param [graphConfig] Graph configuration
**/
$k.UI.prototype.openGraph = function(elements, graphConfig) { };
/**
* Opens a table on the elements
*
* @since 4.2.1
* @function
* @function
* @param {$k.SemanticElement[]} elements Table elements or hits
* @param {$k.Domain} [domain] Domain or internal name of a type of the table
* @param [context] Context that should be used to detect the table configuration, or a table configuration
**/
$k.UI.prototype.openTable = function(elements, domain, context) { };
/**
* Opens the URL with the associated application
*
* @function
* @function
* @param {string} url
* @since 5.2.2
**/
$k.UI.prototype.openURL = function(url) { };
/**
* Raise message notification (to use in function #notificationDialog)
*
* @function
* @function
* @param {string} jseString
* @see UIObject#notificationDialog
* @since 4.1.0
**/
$k.UI.prototype.raiseNotification = function(jseString) { };
/**
* Let the user enter a string in a single-line input field
*
* @function
* @function
* @param {string} message
* @param {string} [windowTitle]
* @param {string} [initialAnswer]
* @returns {string} Returns undefined if no UI is available
**/
$k.UI.prototype.requestString = function(message, windowTitle, initialAnswer) { };
/**
* Requests a filename and writes the given blob or net entity to the file.
*
* @function
* @function
* @param {$k.NetEntity} blobOrNetEntity
* @param {string} [windowTitle]
* @since 5.3.2
* @version Experimental feature, might be removed at any time
**/
$k.UI.prototype.saveFile = function(blobOrNetEntity, windowTitle) { };
/**
* Show a notification dialog
*
* @function
* @function
* @param {string} message
* @param {string} [windowTitle]
**/
$k.UI.alert = function(message, windowTitle) { };
/**
* Let the user choose an object from a list
*
* @function
* @function
* @param {object[]} objects
* @param {string} message
* @param {string} [windowTitle]
* @param {function} [stringFunction] Function that returns a string that should be displayed for an element
* @returns {object} Returns undefined if no UI is available
**/
$k.UI.choose = function(objects, message, windowTitle, stringFunction) { };
/**
* Let the user choose some objects from a list. Shows details of the objects.
*
* @function
* @function
* @param {object[]} objects
* @param {string} [message]
* @returns {objects} Returns undefined if no UI is available
**/
$k.UI.chooseExpanded = function(objects, message) { };
/**
* Let the user choose some objects from a list.
*
* @function
* @function
* @param {object[]} objects
* @param {string} message
* @param {string} [windowTitle]
* @param {function} [stringFunction] Function that returns a string that should be displayed for an element
* @returns {objects} Returns undefined if no UI is available
**/
$k.UI.chooseMultiple = function(objects, message, windowTitle, stringFunction) { };
/**
* Show a confirmation dialog
*
* @function
* @function
* @param {string} message
* @param {string} [windowTitle]
* @returns {boolean} True if confirmed, false if not. Returns undefined if no UI is available.
**/
$k.UI.confirm = function(message, windowTitle) { };
/**
* True if UI interaction is possible
*
* @since 5.2.1
* @function
* @function
* @returns {boolean}
**/
$k.UI.hasUI = function() { };
/**
* Open a notification dialog that stays open while the notification function is evaluated
*
* @function
* @function
* @param {Function} notificationFunction Notification function
* @param {boolean[]} [parameters]
* @param {string} [windowTitle]
* @see UIObject#raiseNotification
* @since 4.1.0
**/
$k.UI.notificationDialog = function(notificationFunction, parameters, windowTitle) { };
/**
* Opens an editor on the element
*
* @function
* @function
* @param {$k.SemanticElement} element
* @param [context] Context that should be used to detect the view configuration, or a view configuration
* @param [options] Possible key in option object: #isNew
**/
$k.UI.openEditor = function(element, context, options) { };
/**
* Opens a graph on the elements
*
* @since 5.3.2
* @function
* @function
* @param {$k.SemanticElement[]} elements Graph elements or hits
* @param [graphConfig] Graph configuration
**/
$k.UI.openGraph = function(elements, graphConfig) { };
/**
* Opens a table on the elements
*
* @since 4.2.1
* @function
* @function
* @param {$k.SemanticElement[]} elements Table elements or hits
* @param {$k.Domain} [domain] Domain or internal name of a type of the table
* @param [context] Context that should be used to detect the table configuration, or a table configuration
**/
$k.UI.openTable = function(elements, domain, context) { };
/**
* Opens the URL with the associated application
*
* @function
* @function
* @param {string} url
* @since 5.2.2
**/
$k.UI.openURL = function(url) { };
/**
* Raise message notification (to use in function #notificationDialog)
*
* @function
* @function
* @param {string} jseString
* @see UIObject#notificationDialog
* @since 4.1.0
**/
$k.UI.raiseNotification = function(jseString) { };
/**
* Let the user enter a string in a single-line input field
*
* @function
* @function
* @param {string} message
* @param {string} [windowTitle]
* @param {string} [initialAnswer]
* @returns {string} Returns undefined if no UI is available
**/
$k.UI.requestString = function(message, windowTitle, initialAnswer) { };
/**
* Requests a filename and writes the given blob or net entity to the file.
*
* @function
* @function
* @param {$k.NetEntity} blobOrNetEntity
* @param {string} [windowTitle]
* @since 5.3.2
* @version Experimental feature, might be removed at any time
**/
$k.UI.saveFile = function(blobOrNetEntity, windowTitle) { };
/*global $k*/
/**
* Action on a view
* @class
* @extends $k.Action
**/
$k.UpdateAction = function() { };
/**
* add a validation error message
*
* @function
* @param {string} errorMessage
**/
$k.UpdateAction.prototype.addValidationError = function(errorMessage) { };
/*global $k*/
/**
* Constructs a user from the user instance
*
* @param {$k.Instance} userInstance User instance
*
* Represents a user.
* @class
**/
$k.User = function(userInstance) { };
/**
* Changes the current users password
*
* @function
* @param {string} oldPassword The old password to be verified
* @param {string} newPassword The new password to set
* @throws {$k.exception.AccessDenied} If the user object and transaction-user mismatch
* @throws {$k.exception.InvalidValue} If one of the provided passwords is undefined/null
* @throws {$k.exception.ObjectNotFound} If there is no current user set or no password attribute available
* @returns {boolean} Return true if the password change was successful
* @example
* try { result = $k.user().changePassword("oldsecret", "newsecret") }
* catch(e) { error = e.toString() }
**/
$k.User.prototype.changePassword = function(oldPassword, newPassword) { };
/**
* Returns the instance associated with the user, or undefined if there is none
*
* @function
* @returns {$k.Instance}
**/
$k.User.prototype.instance = function() { };
/**
* Returns true if the user has administration rights
*
* @since 5.3.0
* @function
* @returns {boolean}
**/
$k.User.prototype.isAdmin = function() { };
/**
* Returns the name of the user
*
* @function
* @returns {string}
**/
$k.User.prototype.name = function() { };
/**
* Finds, authenticates and returns the user.
* Returns undefined if thre is either no such user, or if the password does not match.
* <p/>
* Requires a transaction.
*
* @function
* @returns {$k.User} The authenticated used, or undefined
* @version Experimental feature, might be removed at any time
* @since 5.0.1
**/
$k.User.getAuthenticatedUser = function(username, password) { };
/*global $k*/
/**
* Represents the value range of an attribute type
* @class
**/
$k.ValueRange = function() { };
/**
* Parse the string representation and returns the converted value
*
* @function
* @param {string} string The string represantation of the value that should be set.
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @throws {$k.exception.InvalidValue} If the string is not in the range of allowed values of the attribute
* @returns The converted value
**/
$k.ValueRange.prototype.parse = function(string, language) { };
/**
* Returns the string representation of the value
*
* @function
* @param {string} value The value that should be converted
* @param {string} [language] Language of the value. Either ISO 639-1 (2-letter code, e.g. "en") or ISO 639-2B (3-letter code, e.g. "eng"). If not defined, the current language will be used.
* Ignored if the attribute is not translated
* @returns {string}
* @throws {$k.exception.InvalidValue} If the value is not in the range of allowed values of the attribute
**/
$k.ValueRange.prototype.valueToString = function(value, language) { };
/**
* Returns a string describing the value type.<p>One of
* <ul>
* <li>blob</li>
* <li>boolean</li>
* <li>choice</li>
* <li>color</li>
* <li>container</li>
* <li>date</li>
* <li>dateAndTime</li>
* <li>flexTime</li>
* <li>float</li>
* <li>geoPosition</li>
* <li>integer</li>
* <li>interval</li>
* <li>password</li>
* <li>registyEntry</li>
* <li>string</li>
* <li>time</li>
* <li>translatedAttribute</li>
* <li>translation</li>
* <li>url</li>
*
* </ul>
*
*
* @function
* @returns {string}
**/
$k.ValueRange.prototype.valueType = function() { };
/*global $k*/
/**
* Returns an object that can be used in API calls that expect an attribute value
*
* @param {string} valueString A value string
*
* An attribute value string that has not been parsed.
* @class
**/
$k.ValueString = function(valueString) { };
/**
* Returns true if the values are equal
*
* @function
* @returns {boolean}
**/
$k.ValueString.prototype.equals = function(value) { };
/**
* Sets the string representation
*
* @function
* @param {string} string The string represantation of a value
**/
$k.ValueString.prototype.setValueString = function(string) { };
/**
* Returns the string representation
*
* @function
* @returns {string}
**/
$k.ValueString.prototype.valueString = function() { };
/*global $k*/
/**
* A view built with/by view configuration
* @class
**/
$k.View = function() { };
/**
* Get configuration element
*
* @since 5.2.0
* @function
* @returns {$k.SemanticElement}
**/
$k.View.prototype.configurationElement = function() { };
/**
* Get this view's parent view
*
* @since 5.3.2
* @function
* @returns {$k.View}
**/
$k.View.prototype.parentView = function() { };
/**
* Get render context
*
* @since 5.0.0
* @function
* @returns {RenderContext}
**/
$k.View.prototype.renderContext = function() { };
/**
* Get semantic element
*
* @since 5.2.0
* @function
* @returns {$k.SemanticElement}
**/
$k.View.prototype.semanticElement = function() { };
/**
* Get the current session
*
* @since 5.2.0
* @function
* @returns {$k.Session}
**/
$k.View.prototype.session = function() { };
/**
* Not supported anymore. Use the session
*
* @since 5.0.0
* @deprecated This function is deprecated and might be removed in future releases
* @function
**/
$k.View.prototype.viewContext = function() { };
/*global $k*/
/**
* Configuration of a semantic element editor
* @class
* @extends $k.AbstractEditorConfiguration
**/
$k.ViewConfiguration = function() { };
/**
* @since 4.1.0
* @function
* @returns {$k.SemanticElement}
**/
$k.ViewConfiguration.prototype.configElement = function() { };
/**
* @since 4.1.0
* @function
* @param {string} [searchString] Search string for the target element
* @returns {$k.SemanticElement[]} The rendered object
* @version Experimental feature, might be removed at any time
**/
$k.ViewConfiguration.prototype.relationTargetSearch = function(searchString) { };
/**
* Render the element as a literal object
*
* @since 4.1.0
* @function
* @param {$k.SemanticElement} [semanticElement]
* @param {object} [keyFilter] Alternative 1: An array of strings defining a filter which property names to include.<br/>
* Alternative 2: An object with "include" and/or "exclude" keys<br/>
* <pre class="code">{"exclude": ["key1", ...]}</pre> includes all but the listed properties, while <pre class="code">{"include": ["key1", ...]}</pre> or <pre class="code">["key1", ...]</pre> includes only the listed properties.
* <br/>Non-optional properties are always included<br/>
* Alternative 3: A JSONRenderContext
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object} The rendered object
* @see $k.ViewConfiguration#synchronize
**/
$k.ViewConfiguration.prototype.render = function(semanticElement, keyFilter, detailFilter) { };
/**
* Render the facets for the elements
*
* @since 5.1.3
* @version Experimental feature, might be removed at any time
* @function
* @param {$k.SemanticElement[]} [semanticElements]
* @param {object} [keyFilter] Alternative 1: An array of strings defining a filter which property names to include.<br/>
* Alternative 2: An object with "include" and/or "exclude" keys<br/>
* <pre class="code">{"exclude": ["key1", ...]}</pre> includes all but the listed properties, while <pre class="code">{"include": ["key1", ...]}</pre> or <pre class="code">["key1", ...]</pre> includes only the listed properties.
* <br/>Non-optional properties are always included<br/>
* Alternative 3: A JSONRenderContext
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object} The rendered object
**/
$k.ViewConfiguration.prototype.renderFacets = function(semanticElements, keyFilter, detailFilter) { };
/**
* Render the element as a JavaScript object
*
* @function
* @deprecated Use <code>render(semanticElement, {"exclude": excludedKeys})</code> instead
* @param {$k.SemanticElement} semanticElement
* @param {string[]} [excludeKeys] Collection of property names that are excluded
* @param {object} [detailFilter] A filter to define the granularity of the JSON structure
* <pre class="code">[ "schema" ]</pre> includes json with schema information
* @returns {object} The rendered JSON object
**/
$k.ViewConfiguration.prototype.renderJSON = function(semanticElement, excludeKeys, detailFilter) { };
/**
* @function
**/
$k.ViewConfiguration.prototype.toJSON = function() { };
/**
* Returns the configuration for the semantic element
*
* @since 4.1.0
* @function
* @param {$k.SemanticElement} semanticElement
* @param {$k.SemanticElement} [context] Context of the configuration
* @returns {object} The rendered JSON object
**/
$k.ViewConfiguration.forElement = function(semanticElement, context) { };
/**
* Returns the confguration defined by the element
*
* @since 4.1.0
* @function
* @param {$k.SemanticElement} configurationElement The configuration element
* @returns {$k.ViewConfiguration}
**/
$k.ViewConfiguration.from = function(configurationElement) { };
/**
* Update the semantic element from the JSON string / literal object
*
* @since 4.1.0
* @function
* @param {object} object JSON string or literal object
* @returns {$k.ViewConfiguration}
* @throws {$k.exception.SchemaError} Got an synchronisation error
* @see $k.ViewConfiguration#render
**/
$k.ViewConfiguration.synchronize = function(object) { };
/**
* Update the semantic element from the JSON string / literal object
*
* @function
* @deprecated Use <code>synchronize(jsonObject)</code>
* @param {object} jsonObject JSON string or literal object
* @returns {$k.ViewConfiguration}
* @throws {$k.exception.SchemaError} Got an synchronisation error
**/
$k.ViewConfiguration.synchronizeJSON = function(jsonObject) { };
/*global $k*/
/**
* Creates a new XML writer
*
* @since 4.3.1
* @version Experimental feature, might be removed at any time
* @param {$k.AbstractTextDocument} [document] Document to write on. A new text document will be created if not specified
* @param {object} [options] Options
* <ul>
* <li>invalidCharacters: {boolean} True if invalid characters should be exported as numeric entities. False if invalid characters should be skipped.</li>
* <li>indent {boolean} Enable/disable automatic indentation of the XML tags</li>
* <li>charMap {object} Map of characters (string of length 1) to replacement strings. When writing text, all matching characters will be replaced with these strings.</li>
* </ul>
*
* SAX interface for writing XML. An XMLWriter is created by sending xmlWriter() to a document.
* @class
**/
$k.XMLWriter = function(document, options) { };
/**
* Writes an attribute of a tag to the document
*
* @function
* @param {string} localName Local name of the attribute
* @param {string} value Value of the attribute
* @param {string} [prefix] Namespace prefix. The writer does not check if it is bound to a namespace
* @throws {$k.exception.XMLError} If writing the attribute is not possible
**/
$k.XMLWriter.prototype.attribute = function(localName, value, prefix) { };
/**
* Writes a CDATA section to the document
*
* @function
* @param {string} characters
* @throws {$k.exception.XMLError} If writing the CData is not possible
**/
$k.XMLWriter.prototype.cdata = function(characters) { };
/**
* Writes a string to the document
*
* @function
* @param {string} characters
* @throws {$k.exception.XMLError} If writing the string is not possible
**/
$k.XMLWriter.prototype.characters = function(characters) { };
/**
* Writes a comment to the document
*
* @function
* @param {string} comment
* @throws {$k.exception.XMLError} If writing the comment is not possible
**/
$k.XMLWriter.prototype.comment = function(comment) { };
/**
* Write the default namespace of the current tag and its children
*
* @function
* @param {string} namespace
* @throws {$k.exception.XMLError} If writing the namespace is not possible
**/
$k.XMLWriter.prototype.defaultNamespace = function(namespace) { };
/**
* Returns the document
*
* @since 4.3.1
* @version Experimental feature, might be removed at any time
* @function
* @returns {$k.AbstractTextDocument}
**/
$k.XMLWriter.prototype.document = function() { };
/**
* Closes the currently opened tag
*
* @function
* @throws {$k.exception.XMLError} If closing the tag is not possible
**/
$k.XMLWriter.prototype.endElement = function() { };
/**
* Writes a string to the document without any escaping
*
* @function
* @param {string} characters
* @throws {$k.exception.XMLError} If writing the string is not possible
**/
$k.XMLWriter.prototype.print = function(characters) { };
/**
* Writes a processing instruction to the document
*
* @function
* @param {string} target
* @param {string} data
* @throws {$k.exception.XMLError} If writing the comment is not possible
**/
$k.XMLWriter.prototype.processingInstruction = function(target, data) { };
/**
* Enable/disable automatic indentation of the XML tags.
* Default is true
*
* @function
* @param {boolean} enableIndentation
**/
$k.XMLWriter.prototype.setIndent = function(enableIndentation) { };
/**
* Sets the prefix the uri is bound to
*
* @function
* @param {string} prefix
* @param {string} namespace
**/
$k.XMLWriter.prototype.setPrefix = function(prefix, namespace) { };
/**
* Writes a start tag to the document
*
* @function
* @param {string} localName Local name of the tag
* @param {string} [prefix] Namespace prefix. The writer does not check if it is bound to a namespace
* @throws {$k.exception.XMLError} If writing the tag is not possible
**/
$k.XMLWriter.prototype.startElement = function(localName, prefix) { };
/*global $k*/
/**
* Creates a new ZIP Archive
*
* @since 5.0.1
* @version Experimental feature, might be removed at any time
* @param {string} [archiveName] The name of archive
*
* Creates a zipped entity from all entities passed to the archive
* @class
* @extends $k.ZipContainer
**/
$k.Zip = function(archiveName) { };
/**
* close the archive and return a zip entity
*
* @function
* @param {string} archiveName The filename of the NetEntity
* @returns {$k.NetEntity} The zip-file as NetEntity
**/
$k.Zip.prototype.build = function(archiveName) { };
/*global $k*/
/**
* Represents an archive and its directories
* @class
**/
$k.ZipContainer = function() { };
/**
* Add entity to archive
*
* @function
* @param {$k.Blob|$k.NetEntity} entity The new zip-entry
* @throws {$k.exception.RuntimeError} If the archive is already closed
**/
$k.ZipContainer.prototype.addEntry = function(entity) { };
/**
* Add folder to archive
*
* @function
* @param {string} foldername Name of the subfolder
* @returns {$k.ZipDirectory} The new folder
**/
$k.ZipContainer.prototype.addFolder = function(foldername) { };
/*global $k*/
/**
* Represents the directories in the archive
* @class
* @extends $k.ZipContainer
**/
$k.ZipDirectory = function() { };