CollectionBase

CollectionBase()

CommandObject

CommandObject([eventHandlers])

CommandObject.create([eventHandlers], callback)

CommandObject#$modelName

CommandObject#checkRules()

CommandObject#event:postExecute

CommandObject#event:preExecute

CommandObject#execute([method][, isTransaction], callback)

CommandObject#getBrokenRules([namespace])

CommandObject#getResponse([message][, namespace])

CommandObject#isValid()

CommandObjectSync

CommandObjectSync([eventHandlers])

CommandObjectSync.create([eventHandlers])

CommandObjectSync#$modelName

CommandObjectSync#checkRules()

CommandObjectSync#event:postExecute

CommandObjectSync#event:preExecute

CommandObjectSync#execute([method][, isTransaction])

CommandObjectSync#getBrokenRules([namespace])

CommandObjectSync#getResponse([message][, namespace])

CommandObjectSync#isValid()

EditableChildCollection

EditableChildCollection(parent[, eventHandlers])

EditableChildCollection#$modelName

EditableChildCollection#at(index)

EditableChildCollection#checkRules()

EditableChildCollection#count

EditableChildCollection#create(index, callback)

EditableChildCollection#every(callback)

EditableChildCollection#fetch([data], callback)

EditableChildCollection#filter(callback)

EditableChildCollection#forEach(callback)

EditableChildCollection#fromCto(data, callback)

EditableChildCollection#getBrokenRules([namespace])

EditableChildCollection#isValid()

EditableChildCollection#map(callback)

EditableChildCollection#remove()

EditableChildCollection#save(connection, callback)

EditableChildCollection#some(callback)

EditableChildCollection#sort([fnCompare])

EditableChildCollection#toCto()

EditableChildCollectionSync

EditableChildCollectionSync(parent[, eventHandlers])

EditableChildCollectionSync#$modelName

EditableChildCollectionSync#at(index)

EditableChildCollectionSync#checkRules()

EditableChildCollectionSync#count

EditableChildCollectionSync#create(index)

EditableChildCollectionSync#every(callback)

EditableChildCollectionSync#fetch([data])

EditableChildCollectionSync#filter(callback)

EditableChildCollectionSync#forEach(callback)

EditableChildCollectionSync#fromCto(data)

EditableChildCollectionSync#getBrokenRules([namespace])

EditableChildCollectionSync#isValid()

EditableChildCollectionSync#map(callback)

EditableChildCollectionSync#remove()

EditableChildCollectionSync#save(connection)

EditableChildCollectionSync#some(callback)

EditableChildCollectionSync#sort([fnCompare])

EditableChildCollectionSync#toCto()

EditableChildModel

EditableChildModel(parent[, eventHandlers])

EditableChildModel.create(parent[, eventHandlers], callback)

EditableChildModel.load(parent, data[, eventHandlers], callback)

EditableChildModel#$modelName

EditableChildModel#checkRules()

EditableChildModel#childHasChanged()

EditableChildModel#create(callback)

EditableChildModel#event:postCreate

EditableChildModel#event:postFetch

EditableChildModel#event:postInsert

EditableChildModel#event:postRemove

EditableChildModel#event:postUpdate

EditableChildModel#event:preCreate

EditableChildModel#event:preFetch

EditableChildModel#event:preInsert

EditableChildModel#event:preRemove

EditableChildModel#event:preUpdate

EditableChildModel#fetch([data][, method], callback)

EditableChildModel#fromCto(cto, callback)

EditableChildModel#getBrokenRules([namespace])

EditableChildModel#getModelState()

EditableChildModel#isDeleted()

EditableChildModel#isDirty()

EditableChildModel#isNew()

EditableChildModel#isSelfDirty()

EditableChildModel#isValid()

EditableChildModel#keyEquals(data, getPropertyValue)

EditableChildModel#remove()

EditableChildModel#save(connection, callback)

EditableChildModel#toCto()

EditableChildModelSync

EditableChildModelSync(parent[, eventHandlers])

EditableChildModelSync.create(parent[, eventHandlers])

EditableChildModelSync.load(parent, data[, eventHandlers])

EditableChildModelSync#$modelName

EditableChildModelSync#checkRules()

EditableChildModelSync#childHasChanged()

EditableChildModelSync#create()

EditableChildModelSync#event:postCreate

EditableChildModelSync#event:postFetch

EditableChildModelSync#event:postInsert

EditableChildModelSync#event:postRemove

EditableChildModelSync#event:postUpdate

EditableChildModelSync#event:preCreate

EditableChildModelSync#event:preFetch

EditableChildModelSync#event:preInsert

EditableChildModelSync#event:preRemove

EditableChildModelSync#event:preUpdate

EditableChildModelSync#fetch([data][, method])

EditableChildModelSync#fromCto(cto)

EditableChildModelSync#getBrokenRules([namespace])

EditableChildModelSync#getModelState()

EditableChildModelSync#isDeleted()

EditableChildModelSync#isDirty()

EditableChildModelSync#isNew()

EditableChildModelSync#isSelfDirty()

EditableChildModelSync#isValid()

EditableChildModelSync#keyEquals(data, getPropertyValue)

EditableChildModelSync#remove()

EditableChildModelSync#save(connection)

EditableChildModelSync#toCto()

EditableRootCollection

EditableRootCollection([eventHandlers])

EditableRootCollection.create([eventHandlers], callback)

EditableRootCollection.fetch([filter][, method][, eventHandlers], callback)

EditableRootCollection#$modelName

EditableRootCollection#at(index)

EditableRootCollection#checkRules()

EditableRootCollection#childHasChanged()

EditableRootCollection#count

EditableRootCollection#create(callback)

EditableRootCollection#event:postCreate

EditableRootCollection#event:postFetch

EditableRootCollection#event:postInsert

EditableRootCollection#event:postRemove

EditableRootCollection#event:postSave

EditableRootCollection#event:postUpdate

EditableRootCollection#event:preCreate

EditableRootCollection#event:preFetch

EditableRootCollection#event:preInsert

EditableRootCollection#event:preRemove

EditableRootCollection#event:preSave

EditableRootCollection#event:preUpdate

EditableRootCollection#every(callback)

EditableRootCollection#fetch([filter][, method], callback)

EditableRootCollection#filter(callback)

EditableRootCollection#forEach(callback)

EditableRootCollection#fromCto(cto, callback)

EditableRootCollection#getBrokenRules([namespace])

EditableRootCollection#getModelState()

EditableRootCollection#getResponse([message][, namespace])

EditableRootCollection#isDeleted()

EditableRootCollection#isDirty()

EditableRootCollection#isNew()

EditableRootCollection#isSavable()

EditableRootCollection#isSelfDirty()

EditableRootCollection#isValid()

EditableRootCollection#map(callback)

EditableRootCollection#remove()

EditableRootCollection#save(callback)

EditableRootCollection#some(callback)

EditableRootCollection#sort([fnCompare])

EditableRootCollection#toCto()

EditableRootCollectionSync

EditableRootCollectionSync([eventHandlers])

EditableRootCollectionSync.create([eventHandlers])

EditableRootCollectionSync.fetch([filter][, method][, eventHandlers])

EditableRootCollectionSync#$modelName

EditableRootCollectionSync#at(index)

EditableRootCollectionSync#checkRules()

EditableRootCollectionSync#childHasChanged()

EditableRootCollectionSync#count

EditableRootCollectionSync#create()

EditableRootCollectionSync#event:postCreate

EditableRootCollectionSync#event:postFetch

EditableRootCollectionSync#event:postInsert

EditableRootCollectionSync#event:postRemove

EditableRootCollectionSync#event:postSave

EditableRootCollectionSync#event:postUpdate

EditableRootCollectionSync#event:preCreate

EditableRootCollectionSync#event:preFetch

EditableRootCollectionSync#event:preInsert

EditableRootCollectionSync#event:preRemove

EditableRootCollectionSync#event:preSave

EditableRootCollectionSync#event:preUpdate

EditableRootCollectionSync#every(callback)

EditableRootCollectionSync#fetch([filter][, method])

EditableRootCollectionSync#filter(callback)

EditableRootCollectionSync#forEach(callback)

EditableRootCollectionSync#fromCto(cto)

EditableRootCollectionSync#getBrokenRules([namespace])

EditableRootCollectionSync#getModelState()

EditableRootCollectionSync#getResponse([message][, namespace])

EditableRootCollectionSync#isDeleted()

EditableRootCollectionSync#isDirty()

EditableRootCollectionSync#isNew()

EditableRootCollectionSync#isSavable()

EditableRootCollectionSync#isSelfDirty()

EditableRootCollectionSync#isValid()

EditableRootCollectionSync#map(callback)

EditableRootCollectionSync#remove()

EditableRootCollectionSync#save()

EditableRootCollectionSync#some(callback)

EditableRootCollectionSync#sort([fnCompare])

EditableRootCollectionSync#toCto()

EditableRootModel

EditableRootModel([eventHandlers])

EditableRootModel.create([eventHandlers], callback)

EditableRootModel.fetch([filter][, method][, eventHandlers], callback)

EditableRootModel#$modelName

EditableRootModel#checkRules()

EditableRootModel#childHasChanged()

EditableRootModel#create(callback)

EditableRootModel#event:postCreate

EditableRootModel#event:postFetch

EditableRootModel#event:postInsert

EditableRootModel#event:postRemove

EditableRootModel#event:postSave

EditableRootModel#event:postUpdate

EditableRootModel#event:preCreate

EditableRootModel#event:preFetch

EditableRootModel#event:preInsert

EditableRootModel#event:preRemove

EditableRootModel#event:preSave

EditableRootModel#event:preUpdate

EditableRootModel#fetch([filter][, method], callback)

EditableRootModel#fromCto(cto, callback)

EditableRootModel#getBrokenRules([namespace])

EditableRootModel#getModelState()

EditableRootModel#getResponse([message][, namespace])

EditableRootModel#isDeleted()

EditableRootModel#isDirty()

EditableRootModel#isNew()

EditableRootModel#isSavable()

EditableRootModel#isSelfDirty()

EditableRootModel#isValid()

EditableRootModel#remove()

EditableRootModel#save(callback)

EditableRootModel#toCto()

EditableRootModelSync

EditableRootModelSync([eventHandlers])

EditableRootModelSync.create([eventHandlers])

EditableRootModelSync.fetch([filter][, method][, eventHandlers])

EditableRootModelSync#$modelName

EditableRootModelSync#checkRules()

EditableRootModelSync#childHasChanged()

EditableRootModelSync#create()

EditableRootModelSync#event:postCreate

EditableRootModelSync#event:postFetch

EditableRootModelSync#event:postInsert

EditableRootModelSync#event:postRemove

EditableRootModelSync#event:postSave

EditableRootModelSync#event:postUpdate

EditableRootModelSync#event:preCreate

EditableRootModelSync#event:preFetch

EditableRootModelSync#event:preInsert

EditableRootModelSync#event:preRemove

EditableRootModelSync#event:preSave

EditableRootModelSync#event:preUpdate

EditableRootModelSync#fetch([filter][, method])

EditableRootModelSync#fromCto(cto)

EditableRootModelSync#getBrokenRules([namespace])

EditableRootModelSync#getModelState()

EditableRootModelSync#getResponse([message][, namespace])

EditableRootModelSync#isDeleted()

EditableRootModelSync#isDirty()

EditableRootModelSync#isNew()

EditableRootModelSync#isSavable()

EditableRootModelSync#isSelfDirty()

EditableRootModelSync#isValid()

EditableRootModelSync#remove()

EditableRootModelSync#save()

EditableRootModelSync#toCto()

ModelBase

ModelBase()

ReadOnlyChildCollection

ReadOnlyChildCollection(parent[, eventHandlers])

ReadOnlyChildCollection#$modelName

ReadOnlyChildCollection#at(index)

ReadOnlyChildCollection#checkRules()

ReadOnlyChildCollection#count

ReadOnlyChildCollection#every(callback)

ReadOnlyChildCollection#fetch([data], callback)

ReadOnlyChildCollection#filter(callback)

ReadOnlyChildCollection#forEach(callback)

ReadOnlyChildCollection#getBrokenRules([namespace])

ReadOnlyChildCollection#isValid()

ReadOnlyChildCollection#map(callback)

ReadOnlyChildCollection#some(callback)

ReadOnlyChildCollection#sort([fnCompare])

ReadOnlyChildCollection#toCto()

ReadOnlyChildCollectionSync

ReadOnlyChildCollectionSync(parent[, eventHandlers])

ReadOnlyChildCollectionSync#$modelName

ReadOnlyChildCollectionSync#at(index)

ReadOnlyChildCollectionSync#checkRules()

ReadOnlyChildCollectionSync#count

ReadOnlyChildCollectionSync#every(callback)

ReadOnlyChildCollectionSync#fetch([data])

ReadOnlyChildCollectionSync#filter(callback)

ReadOnlyChildCollectionSync#forEach(callback)

ReadOnlyChildCollectionSync#getBrokenRules([namespace])

ReadOnlyChildCollectionSync#isValid()

ReadOnlyChildCollectionSync#map(callback)

ReadOnlyChildCollectionSync#some(callback)

ReadOnlyChildCollectionSync#sort([fnCompare])

ReadOnlyChildCollectionSync#toCto()

ReadOnlyChildModel

ReadOnlyChildModel(parent[, eventHandlers])

ReadOnlyChildModel.create(parent[, eventHandlers], callback)

ReadOnlyChildModel.load(parent, data[, eventHandlers], callback)

ReadOnlyChildModel#$modelName

ReadOnlyChildModel#checkRules()

ReadOnlyChildModel#event:postFetch

ReadOnlyChildModel#event:preFetch

ReadOnlyChildModel#fetch([data][, method], callback)

ReadOnlyChildModel#getBrokenRules([namespace])

ReadOnlyChildModel#isValid()

ReadOnlyChildModel#toCto()

ReadOnlyChildModelSync

ReadOnlyChildModelSync(parent[, eventHandlers])

ReadOnlyChildModelSync.create(parent[, eventHandlers])

ReadOnlyChildModelSync.load(parent, data[, eventHandlers])

ReadOnlyChildModelSync#$modelName

ReadOnlyChildModelSync#checkRules()

ReadOnlyChildModelSync#event:postFetch

ReadOnlyChildModelSync#event:preFetch

ReadOnlyChildModelSync#fetch([data][, method])

ReadOnlyChildModelSync#getBrokenRules([namespace])

ReadOnlyChildModelSync#isValid()

ReadOnlyChildModelSync#toCto()

ReadOnlyRootCollection

ReadOnlyRootCollection([eventHandlers])

ReadOnlyRootCollection.fetch([filter][, method][, eventHandlers], callback)

ReadOnlyRootCollection#$modelName

ReadOnlyRootCollection#at(index)

ReadOnlyRootCollection#checkRules()

ReadOnlyRootCollection#count

ReadOnlyRootCollection#event:postFetch

ReadOnlyRootCollection#event:preFetch

ReadOnlyRootCollection#every(callback)

ReadOnlyRootCollection#fetch([filter][, method], callback)

ReadOnlyRootCollection#filter(callback)

ReadOnlyRootCollection#forEach(callback)

ReadOnlyRootCollection#getBrokenRules([namespace])

ReadOnlyRootCollection#getResponse([message][, namespace])

ReadOnlyRootCollection#isValid()

ReadOnlyRootCollection#map(callback)

ReadOnlyRootCollection#some(callback)

ReadOnlyRootCollection#sort([fnCompare])

ReadOnlyRootCollection#toCto()

ReadOnlyRootCollection#totalItems

ReadOnlyRootCollectionSync

ReadOnlyRootCollectionSync([eventHandlers])

ReadOnlyRootCollectionSync.fetch([filter][, method][, eventHandlers])

ReadOnlyRootCollectionSync#$modelName

ReadOnlyRootCollectionSync#at(index)

ReadOnlyRootCollectionSync#checkRules()

ReadOnlyRootCollectionSync#count

ReadOnlyRootCollectionSync#event:postFetch

ReadOnlyRootCollectionSync#event:preFetch

ReadOnlyRootCollectionSync#every(callback)

ReadOnlyRootCollectionSync#fetch([filter][, method])

ReadOnlyRootCollectionSync#filter(callback)

ReadOnlyRootCollectionSync#forEach(callback)

ReadOnlyRootCollectionSync#getBrokenRules([namespace])

ReadOnlyRootCollectionSync#getResponse([message][, namespace])

ReadOnlyRootCollectionSync#isValid()

ReadOnlyRootCollectionSync#map(callback)

ReadOnlyRootCollectionSync#some(callback)

ReadOnlyRootCollectionSync#sort([fnCompare])

ReadOnlyRootCollectionSync#toCto()

ReadOnlyRootCollectionSync#totalItems

ReadOnlyRootModel

ReadOnlyRootModel([eventHandlers])

ReadOnlyRootModel.fetch([filter][, method][, eventHandlers], callback)

ReadOnlyRootModel#$modelName

ReadOnlyRootModel#checkRules()

ReadOnlyRootModel#event:postFetch

ReadOnlyRootModel#event:preFetch

ReadOnlyRootModel#fetch([filter][, method], callback)

ReadOnlyRootModel#getBrokenRules([namespace])

ReadOnlyRootModel#getResponse([message][, namespace])

ReadOnlyRootModel#isValid()

ReadOnlyRootModel#toCto()

ReadOnlyRootModelSync

ReadOnlyRootModelSync([eventHandlers])

ReadOnlyRootModelSync.fetch([filter][, method][, eventHandlers])

ReadOnlyRootModelSync#$modelName

ReadOnlyRootModelSync#checkRules()

ReadOnlyRootModelSync#event:postFetch

ReadOnlyRootModelSync#event:preFetch

ReadOnlyRootModelSync#fetch([filter][, method])

ReadOnlyRootModelSync#getBrokenRules([namespace])

ReadOnlyRootModelSync#getResponse([message][, namespace])

ReadOnlyRootModelSync#isValid()

ReadOnlyRootModelSync#toCto()

bo

bo

bo.CommandObject(properties, rules, extensions)

bo.CommandObjectSync(properties, rules, extensions)

bo.EditableChildCollection(name, itemType)

bo.EditableChildCollectionSync(name, itemType)

bo.EditableChildModel(properties, rules, extensions)

bo.EditableChildModelSync(properties, rules, extensions)

bo.EditableRootCollection(name, itemType, rules, extensions)

bo.EditableRootCollectionSync(name, itemType, rules, extensions)

bo.EditableRootModel(properties, rules, extensions)

bo.EditableRootModelSync(properties, rules, extensions)

bo.initialize(cfgPath)

bo.ReadOnlyChildCollection(name, itemType)

bo.ReadOnlyChildCollectionSync(name, itemType)

bo.ReadOnlyChildModel(properties, rules, extensions)

bo.ReadOnlyChildModelSync(properties, rules, extensions)

bo.ReadOnlyRootCollection(name, itemType, rules, extensions)

bo.ReadOnlyRootCollectionSync(name, itemType, rules, extensions)

bo.ReadOnlyRootModel(properties, rules, extensions)

bo.ReadOnlyRootModelSync(properties, rules, extensions)

bo.I18nError

bo.I18nError([message][, ...messageParams])

bo.I18nError#message

bo.I18nError#name

bo.commonRules

bo.commonRules

bo.commonRules.DependencyRule(primaryProperty, dependencies, message[, priority][, stopsProcessing])

bo.commonRules.DependencyRule#addAffectedProperty(property)

bo.commonRules.DependencyRule#addInputProperty(property)

bo.commonRules.DependencyRule#execute(inputs)

bo.commonRules.DependencyRule#getInputValues(getValue)

bo.commonRules.DependencyRule#initialize(primaryProperty, message[, priority][, stopsProcessing])

bo.commonRules.DependencyRule#result([message], severity)

bo.commonRules.DependencyRule#ruleName

bo.commonRules.ExpressionRule

bo.commonRules.ExpressionRule(primaryProperty, regex, option, message[, priority][, stopsProcessing])

bo.commonRules.ExpressionRule#addAffectedProperty(property)

bo.commonRules.ExpressionRule#addInputProperty(property)

bo.commonRules.ExpressionRule#execute(inputs)

bo.commonRules.ExpressionRule#getInputValues(getValue)

bo.commonRules.ExpressionRule#initialize(primaryProperty, message[, priority][, stopsProcessing])

bo.commonRules.ExpressionRule#option

bo.commonRules.ExpressionRule#regex

bo.commonRules.ExpressionRule#result([message], severity)

bo.commonRules.ExpressionRule#ruleName

bo.commonRules.InformationRule

bo.commonRules.InformationRule(primaryProperty, message[, priority][, stopsProcessing])

bo.commonRules.InformationRule#addAffectedProperty(property)

bo.commonRules.InformationRule#addInputProperty(property)

bo.commonRules.InformationRule#execute(inputs)

bo.commonRules.InformationRule#getInputValues(getValue)

bo.commonRules.InformationRule#initialize(primaryProperty, message[, priority][, stopsProcessing])

bo.commonRules.InformationRule#result([message], severity)

bo.commonRules.InformationRule#ruleName

bo.commonRules.IsInAllRolesRule

bo.commonRules.IsInAllRolesRule(action[, target], roles, message[, priority][, stopsProcessing])

bo.commonRules.IsInAllRolesRule#execute(userInfo)

bo.commonRules.IsInAllRolesRule#initialize(action[, target], message[, priority][, stopsProcessing])

bo.commonRules.IsInAllRolesRule#noAccessBehavior

bo.commonRules.IsInAllRolesRule#result([message], severity)

bo.commonRules.IsInAllRolesRule#roles

bo.commonRules.IsInAllRolesRule#ruleName

bo.commonRules.IsInAnyRoleRule

bo.commonRules.IsInAnyRoleRule(action[, target], roles, message[, priority][, stopsProcessing])

bo.commonRules.IsInAnyRoleRule#execute(userInfo)

bo.commonRules.IsInAnyRoleRule#initialize(action[, target], message[, priority][, stopsProcessing])

bo.commonRules.IsInAnyRoleRule#noAccessBehavior

bo.commonRules.IsInAnyRoleRule#result([message], severity)

bo.commonRules.IsInAnyRoleRule#roles

bo.commonRules.IsInAnyRoleRule#ruleName

bo.commonRules.IsInRoleRule

bo.commonRules.IsInRoleRule(action[, target], role, message[, priority][, stopsProcessing])

bo.commonRules.IsInRoleRule#execute(userInfo)

bo.commonRules.IsInRoleRule#initialize(action[, target], message[, priority][, stopsProcessing])

bo.commonRules.IsInRoleRule#noAccessBehavior

bo.commonRules.IsInRoleRule#result([message], severity)

bo.commonRules.IsInRoleRule#role

bo.commonRules.IsInRoleRule#ruleName

bo.commonRules.IsNotInAnyRoleRule

bo.commonRules.IsNotInAnyRoleRule(action[, target], roles, message[, priority][, stopsProcessing])

bo.commonRules.IsNotInAnyRoleRule#execute(userInfo)

bo.commonRules.IsNotInAnyRoleRule#initialize(action[, target], message[, priority][, stopsProcessing])

bo.commonRules.IsNotInAnyRoleRule#noAccessBehavior

bo.commonRules.IsNotInAnyRoleRule#result([message], severity)

bo.commonRules.IsNotInAnyRoleRule#roles

bo.commonRules.IsNotInAnyRoleRule#ruleName

bo.commonRules.IsNotInRoleRule

bo.commonRules.IsNotInRoleRule(action[, target], role, message[, priority][, stopsProcessing])

bo.commonRules.IsNotInRoleRule#execute(userInfo)

bo.commonRules.IsNotInRoleRule#initialize(action[, target], message[, priority][, stopsProcessing])

bo.commonRules.IsNotInRoleRule#noAccessBehavior

bo.commonRules.IsNotInRoleRule#result([message], severity)

bo.commonRules.IsNotInRoleRule#role

bo.commonRules.IsNotInRoleRule#ruleName

bo.commonRules.LengthIsRule

bo.commonRules.LengthIsRule(primaryProperty, length, message[, priority][, stopsProcessing])

bo.commonRules.LengthIsRule#addAffectedProperty(property)

bo.commonRules.LengthIsRule#addInputProperty(property)

bo.commonRules.LengthIsRule#execute(inputs)

bo.commonRules.LengthIsRule#getInputValues(getValue)

bo.commonRules.LengthIsRule#initialize(primaryProperty, message[, priority][, stopsProcessing])

bo.commonRules.LengthIsRule#length

bo.commonRules.LengthIsRule#result([message], severity)

bo.commonRules.LengthIsRule#ruleName

bo.commonRules.MaxLengthRule

bo.commonRules.MaxLengthRule(primaryProperty, maxLength, message[, priority][, stopsProcessing])

bo.commonRules.MaxLengthRule#addAffectedProperty(property)

bo.commonRules.MaxLengthRule#addInputProperty(property)

bo.commonRules.MaxLengthRule#execute(inputs)

bo.commonRules.MaxLengthRule#getInputValues(getValue)

bo.commonRules.MaxLengthRule#initialize(primaryProperty, message[, priority][, stopsProcessing])

bo.commonRules.MaxLengthRule#maxLength

bo.commonRules.MaxLengthRule#result([message], severity)

bo.commonRules.MaxLengthRule#ruleName

bo.commonRules.MaxValueRule

bo.commonRules.MaxValueRule(primaryProperty, maxValue, message[, priority][, stopsProcessing])

bo.commonRules.MaxValueRule#addAffectedProperty(property)

bo.commonRules.MaxValueRule#addInputProperty(property)

bo.commonRules.MaxValueRule#execute(inputs)

bo.commonRules.MaxValueRule#getInputValues(getValue)

bo.commonRules.MaxValueRule#initialize(primaryProperty, message[, priority][, stopsProcessing])

bo.commonRules.MaxValueRule#maxValue

bo.commonRules.MaxValueRule#result([message], severity)

bo.commonRules.MaxValueRule#ruleName

bo.commonRules.MinLengthRule

bo.commonRules.MinLengthRule(primaryProperty, minLength, message[, priority][, stopsProcessing])

bo.commonRules.MinLengthRule#addAffectedProperty(property)

bo.commonRules.MinLengthRule#addInputProperty(property)

bo.commonRules.MinLengthRule#execute(inputs)

bo.commonRules.MinLengthRule#getInputValues(getValue)

bo.commonRules.MinLengthRule#initialize(primaryProperty, message[, priority][, stopsProcessing])

bo.commonRules.MinLengthRule#minLength

bo.commonRules.MinLengthRule#result([message], severity)

bo.commonRules.MinLengthRule#ruleName

bo.commonRules.MinValueRule

bo.commonRules.MinValueRule(primaryProperty, minValue, message[, priority][, stopsProcessing])

bo.commonRules.MinValueRule#addAffectedProperty(property)

bo.commonRules.MinValueRule#addInputProperty(property)

bo.commonRules.MinValueRule#execute(inputs)

bo.commonRules.MinValueRule#getInputValues(getValue)

bo.commonRules.MinValueRule#initialize(primaryProperty, message[, priority][, stopsProcessing])

bo.commonRules.MinValueRule#minValue

bo.commonRules.MinValueRule#result([message], severity)

bo.commonRules.MinValueRule#ruleName

bo.commonRules.NullResultOption

bo.commonRules.NullResultOption()

bo.commonRules.NullResultOption#$name

bo.commonRules.NullResultOption#convertToEmptyString

bo.commonRules.NullResultOption#hasValue(name)

bo.commonRules.NullResultOption#returnFalse

bo.commonRules.NullResultOption#returnTrue

bo.commonRules.RequiredRule

bo.commonRules.RequiredRule(primaryProperty, message[, priority][, stopsProcessing])

bo.commonRules.RequiredRule#addAffectedProperty(property)

bo.commonRules.RequiredRule#addInputProperty(property)

bo.commonRules.RequiredRule#execute(inputs)

bo.commonRules.RequiredRule#getInputValues(getValue)

bo.commonRules.RequiredRule#initialize(primaryProperty, message[, priority][, stopsProcessing])

bo.commonRules.RequiredRule#result([message], severity)

bo.commonRules.RequiredRule#ruleName

bo.dataAccess.daoBuilder

bo.dataAccess.daoBuilder(dataSource, modelPath, modelName)

bo.dataAccess

bo.dataAccess

bo.dataAccess.ConnectionManagerBase()

bo.dataAccess.ConnectionManagerBase#beginTransaction(dataSource, callback)

bo.dataAccess.ConnectionManagerBase#commitTransaction(dataSource, connection, callback)

bo.dataAccess.ConnectionManagerBase#openConnection(dataSource, connection, callback)

bo.dataAccess.ConnectionManagerBase#rollbackTransaction(dataSource, connection, callback)

bo.dataAccess.DaoBase

bo.dataAccess.DaoBase(name)

bo.dataAccess.DaoBase#$hasCreate()

bo.dataAccess.DaoBase#$runMethod(methodName[, ...methodArg])

bo.dataAccess.DaoBase#name

bo.dataAccess.DaoError

bo.dataAccess.DaoError([message][, ...messageParams])

bo.dataAccess.DaoError#message

bo.dataAccess.DaoError#name

bo.dataTypes

bo.dataTypes

bo.dataTypes.Boolean()

bo.dataTypes.Boolean#hasValue(value)

bo.dataTypes.Boolean#isValid([value])

bo.dataTypes.Boolean#name

bo.dataTypes.Boolean#parse([value])

bo.dataTypes.DataType

bo.dataTypes.DataType()

bo.dataTypes.DataType#hasValue(value)

bo.dataTypes.DataType#isValid([value])

bo.dataTypes.DataType#name

bo.dataTypes.DateTime

bo.dataTypes.DateTime()

bo.dataTypes.DateTime#hasValue(value)

bo.dataTypes.DateTime#isValid([value])

bo.dataTypes.DateTime#name

bo.dataTypes.DateTime#parse([value])

bo.dataTypes.Decimal

bo.dataTypes.Decimal()

bo.dataTypes.Decimal#hasValue(value)

bo.dataTypes.Decimal#isValid([value])

bo.dataTypes.Decimal#name

bo.dataTypes.Decimal#parse([value])

bo.dataTypes.Email

bo.dataTypes.Email()

bo.dataTypes.Email#hasValue(value)

bo.dataTypes.Email#isValid([value])

bo.dataTypes.Email#name

bo.dataTypes.Email#parse([value])

bo.dataTypes.Enum

bo.dataTypes.Enum(enumType)

bo.dataTypes.Enum#hasValue(value)

bo.dataTypes.Enum#isValid([value])

bo.dataTypes.Enum#name

bo.dataTypes.Enum#parse(value)

bo.dataTypes.Enum#type

bo.dataTypes.Integer

bo.dataTypes.Integer()

bo.dataTypes.Integer#hasValue(value)

bo.dataTypes.Integer#isValid([value])

bo.dataTypes.Integer#name

bo.dataTypes.Integer#parse([value])

bo.dataTypes.Text

bo.dataTypes.Text()

bo.dataTypes.Text#hasValue(value)

bo.dataTypes.Text#isValid([value])

bo.dataTypes.Text#name

bo.dataTypes.Text#parse([value])

bo.i18n

bo.i18n([namespace][, keyRoot])

bo.i18n.initialize(pathOfLocales[, getLocale])

bo.i18n#get(messageId[, ...messageParams])

bo.rules

bo.rules

bo.rules.AuthorizationAction()

bo.rules.AuthorizationAction#$name

bo.rules.AuthorizationAction#createObject

bo.rules.AuthorizationAction#executeCommand

bo.rules.AuthorizationAction#executeMethod

bo.rules.AuthorizationAction#fetchObject

bo.rules.AuthorizationAction#hasValue(name)

bo.rules.AuthorizationAction#readProperty

bo.rules.AuthorizationAction#removeObject

bo.rules.AuthorizationAction#updateObject

bo.rules.AuthorizationAction#writeProperty

bo.rules.AuthorizationContext

bo.rules.AuthorizationContext(action[, targetName], brokenRules)

bo.rules.AuthorizationContext#brokenRules

bo.rules.AuthorizationContext#locale

bo.rules.AuthorizationContext#ruleId

bo.rules.AuthorizationContext#user

bo.rules.AuthorizationError

bo.rules.AuthorizationError([message][, ...messageParams])

bo.rules.AuthorizationError#message

bo.rules.AuthorizationError#name

bo.rules.AuthorizationResult

bo.rules.AuthorizationResult(ruleName[, targetName], message)

bo.rules.AuthorizationResult#isPreserved

bo.rules.AuthorizationResult#message

bo.rules.AuthorizationResult#propertyName

bo.rules.AuthorizationResult#ruleName

bo.rules.AuthorizationResult#severity

bo.rules.AuthorizationResult#stopsProcessing

bo.rules.AuthorizationRule

bo.rules.AuthorizationRule(ruleName)

bo.rules.AuthorizationRule#initialize(action[, target], message[, priority][, stopsProcessing])

bo.rules.AuthorizationRule#noAccessBehavior

bo.rules.AuthorizationRule#result([message], severity)

bo.rules.AuthorizationRule#ruleId

bo.rules.AuthorizationRule#ruleName

bo.rules.BrokenRule

bo.rules.BrokenRule(ruleName, isPreserved[, propertyName], message, severity)

bo.rules.BrokenRule#isPreserved

bo.rules.BrokenRule#message

bo.rules.BrokenRule#propertyName

bo.rules.BrokenRule#ruleName

bo.rules.BrokenRule#severity

bo.rules.BrokenRuleList

bo.rules.BrokenRuleList(modelName)

bo.rules.BrokenRuleList#add(brokenRule)

bo.rules.BrokenRuleList#clear([property])

bo.rules.BrokenRuleList#clearAll(property)

bo.rules.BrokenRuleList#isValid()

bo.rules.BrokenRuleList#output([namespace])

bo.rules.BrokenRuleList~clearFor(propertyName)

bo.rules.BrokenRulesOutput

bo.rules.BrokenRulesOutput()

bo.rules.BrokenRulesOutput#$count

bo.rules.BrokenRulesOutput#$length

bo.rules.BrokenRulesOutput#add(propertyName, notice)

bo.rules.BrokenRulesOutput#addChild(propertyName, output)

bo.rules.BrokenRulesOutput#addChildren(propertyName, outputs)

bo.rules.BrokenRulesResponse

bo.rules.BrokenRulesResponse(brokenRules[, message])

bo.rules.BrokenRulesResponse#count

bo.rules.BrokenRulesResponse#data

bo.rules.BrokenRulesResponse#message

bo.rules.BrokenRulesResponse#name

bo.rules.BrokenRulesResponse#status

bo.rules.DataTypeRule

bo.rules.DataTypeRule(primaryProperty)

bo.rules.DataTypeRule#addAffectedProperty(property)

bo.rules.DataTypeRule#addInputProperty(property)

bo.rules.DataTypeRule#execute(inputs)

bo.rules.DataTypeRule#getInputValues(getValue)

bo.rules.DataTypeRule#initialize(primaryProperty, message[, priority][, stopsProcessing])

bo.rules.DataTypeRule#result([message], severity)

bo.rules.DataTypeRule#ruleName

bo.rules.NoAccessBehavior

bo.rules.NoAccessBehavior()

bo.rules.NoAccessBehavior#$name

bo.rules.NoAccessBehavior#hasValue(name)

bo.rules.NoAccessBehavior#showError

bo.rules.NoAccessBehavior#showInformation

bo.rules.NoAccessBehavior#showWarning

bo.rules.NoAccessBehavior#throwError

bo.rules.ResultBase

bo.rules.ResultBase(ruleName, propertyName, message)

bo.rules.ResultBase#isPreserved

bo.rules.ResultBase#message

bo.rules.ResultBase#propertyName

bo.rules.ResultBase#ruleName

bo.rules.ResultBase#severity

bo.rules.ResultBase#stopsProcessing

bo.rules.ResultBase#toBrokenRule()

bo.rules.RuleBase

bo.rules.RuleBase(ruleName)

bo.rules.RuleBase#execute(inputs)

bo.rules.RuleBase#initialize(message[, priority][, stopsProcessing])

bo.rules.RuleBase#message

bo.rules.RuleBase#priority

bo.rules.RuleBase#result([message][, severity])

bo.rules.RuleBase#ruleName

bo.rules.RuleBase#stopsProcessing

bo.rules.RuleList

bo.rules.RuleList()

bo.rules.RuleList#add(id, rule)

bo.rules.RuleList#sort()

bo.rules.RuleManager

bo.rules.RuleManager()

bo.rules.RuleManager#add(rule)

bo.rules.RuleManager#hasPermission(context)

bo.rules.RuleManager#initialize(defaultBehavior)

bo.rules.RuleManager#noAccessBehavior

bo.rules.RuleManager#validate(property, context)

bo.rules.RuleNotice

bo.rules.RuleNotice(message[, severity])

bo.rules.RuleNotice#message

bo.rules.RuleNotice#severity

bo.rules.RuleSeverity

bo.rules.RuleSeverity()

bo.rules.RuleSeverity#$name

bo.rules.RuleSeverity#error

bo.rules.RuleSeverity#hasValue(name)

bo.rules.RuleSeverity#information

bo.rules.RuleSeverity#success

bo.rules.RuleSeverity#warning

bo.rules.ValidationContext

bo.rules.ValidationContext(dataStore, brokenRules)

bo.rules.ValidationContext#brokenRules

bo.rules.ValidationContext#getValue()

bo.rules.ValidationResult

bo.rules.ValidationResult(ruleName, propertyName, message)

bo.rules.ValidationResult#affectedProperties

bo.rules.ValidationResult#isPreserved

bo.rules.ValidationResult#message

bo.rules.ValidationResult#propertyName

bo.rules.ValidationResult#ruleName

bo.rules.ValidationResult#severity

bo.rules.ValidationResult#stopsProcessing

bo.rules.ValidationRule

bo.rules.ValidationRule(ruleName)

bo.rules.ValidationRule#addAffectedProperty(property)

bo.rules.ValidationRule#addInputProperty(property)

bo.rules.ValidationRule#getInputValues(getValue)

bo.rules.ValidationRule#initialize(primaryProperty, message[, priority][, stopsProcessing])

bo.rules.ValidationRule#primaryProperty

bo.rules.ValidationRule#result([message], severity)

bo.rules.ValidationRule#ruleName

bo.shared~configuration

bo.shared~configuration

bo.shared

bo.shared

bo.shared.ConfigurationError([message][, ...messageParams])

bo.shared.ConfigurationError#message

bo.shared.ConfigurationError#name

bo.shared.DataPortalAction

bo.shared.DataPortalAction()

bo.shared.DataPortalAction#$name

bo.shared.DataPortalAction#create

bo.shared.DataPortalAction#execute

bo.shared.DataPortalAction#fetch

bo.shared.DataPortalAction#hasValue(name)

bo.shared.DataPortalAction#insert

bo.shared.DataPortalAction#remove

bo.shared.DataPortalAction#update

bo.shared.DataPortalContext

bo.shared.DataPortalContext(dao, properties[, getValue][, setValue])

bo.shared.DataPortalContext#connection

bo.shared.DataPortalContext#dao

bo.shared.DataPortalContext#getValue(propertyName)

bo.shared.DataPortalContext#isSelfDirty

bo.shared.DataPortalContext#locale

bo.shared.DataPortalContext#properties

bo.shared.DataPortalContext#setState([connection][, isSelfDirty])

bo.shared.DataPortalContext#setValue(propertyName, value)

bo.shared.DataPortalContext#user

bo.shared.DataPortalError

bo.shared.DataPortalError(modeltype, modelName, action, interceptedError)

bo.shared.DataPortalError#action

bo.shared.DataPortalError#innerError

bo.shared.DataPortalError#message

bo.shared.DataPortalError#modelName

bo.shared.DataPortalError#modelType

bo.shared.DataPortalError#name

bo.shared.DataPortalEvent

bo.shared.DataPortalEvent()

bo.shared.DataPortalEvent#$name

bo.shared.DataPortalEvent#hasValue(name)

bo.shared.DataPortalEvent#postCreate

bo.shared.DataPortalEvent#postExecute

bo.shared.DataPortalEvent#postFetch

bo.shared.DataPortalEvent#postInsert

bo.shared.DataPortalEvent#postRemove

bo.shared.DataPortalEvent#postSave

bo.shared.DataPortalEvent#postUpdate

bo.shared.DataPortalEvent#preCreate

bo.shared.DataPortalEvent#preExecute

bo.shared.DataPortalEvent#preFetch

bo.shared.DataPortalEvent#preInsert

bo.shared.DataPortalEvent#preRemove

bo.shared.DataPortalEvent#preSave

bo.shared.DataPortalEvent#preUpdate

bo.shared.DataPortalEventArgs

bo.shared.DataPortalEventArgs(event, modelName[, action][, methodName][, error])

bo.shared.DataPortalEventArgs#action

bo.shared.DataPortalEventArgs#error

bo.shared.DataPortalEventArgs#eventName

bo.shared.DataPortalEventArgs#locale

bo.shared.DataPortalEventArgs#methodName

bo.shared.DataPortalEventArgs#modelName

bo.shared.DataPortalEventArgs#user

bo.shared.DataStore

bo.shared.DataStore()

bo.shared.DataStore#getValue(property)

bo.shared.DataStore#hasValidValue(property)

bo.shared.DataStore#initValue(property, value)

bo.shared.DataStore#setValue(property, value)

bo.shared.EventHandlerList

bo.shared.EventHandlerList()

bo.shared.EventHandlerList#add(modelName, event, handler)

bo.shared.EventHandlerList#setup(target)

bo.shared.ExtensionManager

bo.shared.ExtensionManager(dataSource, modelPath)

bo.shared.ExtensionManager#daoBuilder

bo.shared.ExtensionManager#dataCreate

bo.shared.ExtensionManager#dataExecute

bo.shared.ExtensionManager#dataFetch

bo.shared.ExtensionManager#dataInsert

bo.shared.ExtensionManager#dataRemove

bo.shared.ExtensionManager#dataSource

bo.shared.ExtensionManager#dataUpdate

bo.shared.ExtensionManager#fromCto

bo.shared.ExtensionManager#fromDto

bo.shared.ExtensionManager#modelPath

bo.shared.ExtensionManager#toCto

bo.shared.ExtensionManager#toDto

bo.shared.ExtensionManagerBase

bo.shared.ExtensionManagerBase(dataSource, modelPath, addArgs)

bo.shared.ExtensionManagerBase#addOtherMethod(methodName)

bo.shared.ExtensionManagerBase#buildOtherMethods(instance, isSync)

bo.shared.ExtensionManagerBase#daoBuilder

bo.shared.ExtensionManagerBase#dataCreate

bo.shared.ExtensionManagerBase#dataExecute

bo.shared.ExtensionManagerBase#dataFetch

bo.shared.ExtensionManagerBase#dataInsert

bo.shared.ExtensionManagerBase#dataRemove

bo.shared.ExtensionManagerBase#dataSource

bo.shared.ExtensionManagerBase#dataUpdate

bo.shared.ExtensionManagerBase#fromCto

bo.shared.ExtensionManagerBase#fromDto

bo.shared.ExtensionManagerBase#getDataAccessObject(modelName)

bo.shared.ExtensionManagerBase#modelPath

bo.shared.ExtensionManagerBase#toCto

bo.shared.ExtensionManagerBase#toDto

bo.shared.ExtensionManagerSync

bo.shared.ExtensionManagerSync(dataSource, modelPath)

bo.shared.ExtensionManagerSync#daoBuilder

bo.shared.ExtensionManagerSync#dataCreate

bo.shared.ExtensionManagerSync#dataExecute

bo.shared.ExtensionManagerSync#dataFetch

bo.shared.ExtensionManagerSync#dataInsert

bo.shared.ExtensionManagerSync#dataRemove

bo.shared.ExtensionManagerSync#dataSource

bo.shared.ExtensionManagerSync#dataUpdate

bo.shared.ExtensionManagerSync#fromCto

bo.shared.ExtensionManagerSync#fromDto

bo.shared.ExtensionManagerSync#modelPath

bo.shared.ExtensionManagerSync#toCto

bo.shared.ExtensionManagerSync#toDto

bo.shared.ModelError

bo.shared.ModelError([message][, ...messageParams])

bo.shared.ModelError#message

bo.shared.ModelError#name

bo.shared.ModelState

bo.shared.ModelState()

bo.shared.ModelState#$name

bo.shared.ModelState#changed

bo.shared.ModelState#created

bo.shared.ModelState#hasValue(name)

bo.shared.ModelState#markedForRemoval

bo.shared.ModelState#pristine

bo.shared.ModelState#removed

bo.shared.PropertyContext

bo.shared.PropertyContext(properties[, getValue][, setValue])

bo.shared.PropertyContext#getValue(propertyName)

bo.shared.PropertyContext#primaryProperty

bo.shared.PropertyContext#properties

bo.shared.PropertyContext#setValue(propertyName, value)

bo.shared.PropertyContext#with(property)

bo.shared.PropertyFlag

bo.shared.PropertyFlag()

bo.shared.PropertyFlag#$name

bo.shared.PropertyFlag#hasValue(name)

bo.shared.PropertyFlag#key

bo.shared.PropertyFlag#none

bo.shared.PropertyFlag#notOnCto

bo.shared.PropertyFlag#notOnDto

bo.shared.PropertyFlag#onCtoOnly

bo.shared.PropertyFlag#onDtoOnly

bo.shared.PropertyFlag#parentKey

bo.shared.PropertyFlag#readOnly

bo.shared.PropertyInfo

bo.shared.PropertyInfo(name, type[, flags][, getter][, setter])

bo.shared.PropertyInfo#getter

bo.shared.PropertyInfo#hasValue(value)

bo.shared.PropertyInfo#isKey

bo.shared.PropertyInfo#isOnCto

bo.shared.PropertyInfo#isOnDto

bo.shared.PropertyInfo#isParentKey

bo.shared.PropertyInfo#isReadOnly

bo.shared.PropertyInfo#name

bo.shared.PropertyInfo#setter

bo.shared.PropertyInfo#type

bo.shared.PropertyManager

bo.shared.PropertyManager(name[, ...property])

bo.shared.PropertyManager#add(property)

bo.shared.PropertyManager#childCount()

bo.shared.PropertyManager#children()

bo.shared.PropertyManager#contains(property)

bo.shared.PropertyManager#create(name, type[, flags])

bo.shared.PropertyManager#filter(callback)

bo.shared.PropertyManager#forEach(callback)

bo.shared.PropertyManager#getByName(name[, message][, ...messageParams])

bo.shared.PropertyManager#getKey(getPropertyValue)

bo.shared.PropertyManager#keyEquals(data, getPropertyValue)

bo.shared.PropertyManager#map(callback)

bo.shared.PropertyManager#name

bo.shared.PropertyManager#toArray()

bo.shared.PropertyManager#verifyChildTypes(allowedTypes)

bo.shared.TransferContext

bo.shared.TransferContext([properties][, getValue][, setValue])

bo.shared.TransferContext#getValue(propertyName)

bo.shared.TransferContext#properties

bo.shared.TransferContext#setValue(propertyName, value)

bo.system

bo.system

bo.system.Argument()

bo.system.Argument.check(value)

bo.system.Argument.inConstructor(className)

bo.system.Argument.inMethod(className, methodName)

bo.system.Argument.inProperty(className, propertyName, propertyName)

bo.system.ArgumentCheck

bo.system.ArgumentCheck([value])

bo.system.ArgumentCheck.asArray(type[, message][, ...messageParams])

bo.system.ArgumentCheck.asBoolean([message][, ...messageParams])

bo.system.ArgumentCheck.asDefined([message][, ...messageParams])

bo.system.ArgumentCheck.asEnumMember(type[, defaultValue][, message][, ...messageParams])

bo.system.ArgumentCheck.asFunction([message][, ...messageParams])

bo.system.ArgumentCheck.asInteger([message][, ...messageParams])

bo.system.ArgumentCheck.asModelType(model[, message][, ...messageParams])

bo.system.ArgumentCheck.asNumber([message][, ...messageParams])

bo.system.ArgumentCheck.asObject([message][, ...messageParams])

bo.system.ArgumentCheck.asString([message][, ...messageParams])

bo.system.ArgumentCheck.asType(type[, message][, ...messageParams])

bo.system.ArgumentCheck.for([argumentName])

bo.system.ArgumentCheck.forMandatory([argumentName])

bo.system.ArgumentCheck.forOptional([argumentName])

bo.system.ArgumentCheck.hasValue([message][, ...messageParams])

bo.system.ArgumentError

bo.system.ArgumentError([message][, ...messageParams])

bo.system.ArgumentError#message

bo.system.ArgumentError#name

bo.system.ConstructorError

bo.system.ConstructorError([message][, ...messageParams])

bo.system.ConstructorError#message

bo.system.ConstructorError#name

bo.system.Enumeration

bo.system.Enumeration()

bo.system.Enumeration#$name

bo.system.Enumeration#check(value[, message][, ...messageParams])

bo.system.Enumeration#count()

bo.system.Enumeration#getName(value)

bo.system.Enumeration#getValue(name)

bo.system.Enumeration#hasMember(value)

bo.system.Enumeration#hasValue(name)

bo.system.EnumerationError

bo.system.EnumerationError([message][, ...messageParams])

bo.system.EnumerationError#message

bo.system.EnumerationError#name

bo.system.MethodError

bo.system.MethodError([message][, ...messageParams])

bo.system.MethodError#message

bo.system.MethodError#name

bo.system.NotImplementedError

bo.system.NotImplementedError([message][, ...messageParams])

bo.system.NotImplementedError#message

bo.system.NotImplementedError#name

bo.system.PropertyError

bo.system.PropertyError([message][, ...messageParams])

bo.system.PropertyError#message

bo.system.PropertyError#name

bo.system.UserInfo

bo.system.UserInfo([userCode])

bo.system.UserInfo#isInRole(role)

bo.system.UserInfo#userCode

bo.system.Utility

bo.system.Utility()

bo.system.Utility.getDirectory(relativePath, name, errorType)

bo.system.Utility.getFunction(relativePath, name, errorType)

bo.system.Utility.isEnumMember(value, enumType, name, errorType)

bo.system.Utility.isMandatoryString([value], name, errorType)

bo.system.Utility.isOptionalString([value], name, errorType)

external

external

external.cbCollectionItem(currentValue, index, collection)

external.cbCompare(a, b)

external.cbConnectionManager(err, connection)

external.cbDataPortal(err, result)

external.cbFromCto(err)

external.configurationFile

external.daoBuilder(dataSource, modelPath, modelName)

external.dataCreate(context, callback)

external.dataExecute(context, method, callback)

external.dataFetch(context, filter, method, callback)

external.dataInsert(context, callback)

external.dataRemove(context, callback)

external.dataUpdate(context, callback)

external.eventHandler(context)

external.fromCto(context, cto)

external.fromDto(context, dto)

external.getLocale()

external.getUser()

external.propertyGetter(context)

external.propertySetter(context, value)

external.toCto(context)

external.toDto(context)

internal

internal

internal#i18nBO([keyRoot])

internal~getValue(property)

internal~initializeCfg(cfgPath)

internal~setValue(property, value)