Core
API v1.x
1
APIAPI v1.x

You are currently looking at the documentation of a previous version of Kuzzle. We strongly recommend that you use the latest version. You can also use the version selector in the top menu.

Error codes #

0x00: core #

Subdomain: 0x0000: fatal #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | core.fatal.unexpected_error

0x00000001
| InternalError 
(500)
| Caught an unexpected error. Please contact your support. | | core.fatal.service_unavailable
0x00000002
| ExternalServiceError 
(500)
| An external service is unavailable | | core.fatal.service_timeout
0x00000003
| InternalError 
(500)
| Service initialization timeout | | core.fatal.unreadable_log_dir
0x00000004
| InternalError 
(500)
| Cannot read the content of the log directory | | core.fatal.assertion_failed
0x00000005
| InternalError 
(500)
| A runtime assertion has failed. Please contact support. |

Subdomain: 0x0001: realtime #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | core.realtime.room_not_found

0x00010001
| NotFoundError 
(404)
| The provided room identifier doesn't exist | | core.realtime.invalid_rooms
0x00010002
| BadRequestError 
(400)
| The provided "rooms" argument is invalid | | core.realtime.invalid_state
0x00010003
| BadRequestError 
(400)
| An invalid value has been provided to the "state" argument | | core.realtime.invalid_scope
0x00010004
| BadRequestError 
(400)
| An invalid value has been provided to the "scope" argument | | core.realtime.invalid_users
0x00010005
| BadRequestError 
(400)
| An invalid value has been provided to the "users" argument | | core.realtime.too_many_terms
0x00010006
| SizeLimitError 
(413)
| The number of filter terms exceeds the configured server limit | | core.realtime.too_many_rooms
0x00010007
| SizeLimitError 
(413)
| The configured number of unique rooms has been reached | | core.realtime.not_subscribed
0x00010008
| PreconditionError 
(412)
| Tried to manage a room while not having subscribed to it |

Subdomain: 0x0002: vault #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | core.vault.cannot_decrypt

0x00020001
| InternalError 
(500)
| Decryption of a vault file failed | | core.vault.key_not_found
0x00020002
| InternalError 
(500)
| A vault file has been provided without a vault key |

Subdomain: 0x0003: configuration #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | core.configuration.invalid_type

0x00030001
| InternalError 
(500)
| Wrong configuration parameter type | | core.configuration.out_of_range
0x00030002
| InternalError 
(500)
| A configuration value exceeds the allowed range |

Subdomain: 0x0004: sandbox #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | core.sandbox.process_already_running

0x00040001
| InternalError 
(500)
| A process is already running for this sandbox | | core.sandbox.timeout
0x00040002
| GatewayTimeoutError 
(504)
| Sandbox execution timed out |

0x01: services #

Subdomain: 0x0101: storage #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | services.storage.unknown_index

0x01010001
| PreconditionError 
(412)
| The provided data index does not exist | | services.storage.unknown_collection
0x01010002
| PreconditionError 
(412)
| The provided data collection does not exist | | services.storage.get_limit_exceeded
0x01010003
| SizeLimitError 
(413)
| The number of documents returned by this request exceeds the configured server limit | | services.storage.write_limit_exceeded
0x01010004
| SizeLimitError 
(413)
| The number of documents edited by this request exceeds the configured server limit | | services.storage.import_failed
0x01010005
| PartialError 
(206)
| Failed to import some or all documents | | services.storage.no_multi_indexes
0x01010006
| BadRequestError 
(400)
| Cannot be run on multiple indexes | | services.storage.no_multi_collections
0x01010007
| BadRequestError 
(400)
| Cannot be run on multiple collections | | services.storage.incomplete_fetch
0x01010008
| PartialError 
(206)
| Couldn't retrieve all the requested documents | | services.storage.incomplete_delete
0x01010009
| PartialError 
(206)
| Couldn't delete all the requested documents | | services.storage.incomplete_create
0x0101000a
| PartialError 
(206)
| Couldn't create all the requested documents | | services.storage.not_found
0x0101000b
| NotFoundError 
(404)
| Document not found | | services.storage.bootstrap_timeout
0x0101000c
| InternalError 
(500)
| Bootstrap of a storage instance failed because it has been locked for too much time | | services.storage.version_mismatch
0x0101000d
| InternalError 
(500)
| The version of the target Elasticsearch is not compatible with this version of Kuzzle | | services.storage.unknown_scroll_id
0x0101000e
| NotFoundError 
(404)
| The scroll identifier does not exist or has expired | | services.storage.search_as_an_id
0x0101000f
| BadRequestError 
(400)
| Used "_search" as a document identifier, which conflicts with the _search HTTP route | | services.storage.unknown_index_collection
0x01010010
| PreconditionError 
(412)
| The provided index and/or collection doesn't exist | | services.storage.document_already_exists
0x01010011
| BadRequestError 
(400)
| A document with the same identifier already exists | | services.storage.missing_argument
0x01010012
| BadRequestError 
(400)
| A required argument is missing or is empty | | services.storage.invalid_argument
0x01010013
| BadRequestError 
(400)
| Invalid argument provided | | services.storage.index_protected
0x01010014
| BadRequestError 
(400)
| The content of a protected index cannot be modified with generic API routes | | services.storage.invalid_mapping
0x01010015
| BadRequestError 
(400)
| The provided mapping is invalid | | services.storage.index_reserved
0x01010016
| BadRequestError 
(400)
| Index names starting with a "%" are reserved and cannot be used | | services.storage.no_routing
0x01010017
| BadRequestError 
(400)
| The "_routing" keyword is forbidden | | services.storage.not_connected
0x01010018
| ExternalServiceError 
(500)
| Unable to connect to the storage instance | | services.storage.too_many_operations
0x01010019
| ExternalServiceError 
(500)
| Too many operations received | | services.storage.cannot_change_mapping
0x0101001a
| BadRequestError 
(400)
| Cannot change the mapping of a field (once set, a field mapping cannot be changed) | | services.storage.duplicate_field_mapping
0x0101001b
| BadRequestError 
(400)
| A same field cannot have different mappings within the same index (fields are shared to all of an index collections) | | services.storage.unexpected_properties
0x0101001c
| BadRequestError 
(400)
| Unexpected properties found | | services.storage.invalid_mapping_type
0x0101001d
| BadRequestError 
(400)
| Unrecognized mapping data type | | services.storage.wrong_mapping_property
0x0101001e
| BadRequestError 
(400)
| A mapping property cannot be parsed | | services.storage.invalid_mapping_argument
0x0101001f
| BadRequestError 
(400)
| Invalid mapping property | | services.storage.too_many_changes
0x01010020
| ExternalServiceError 
(500)
| Too many changes occured on the same resource in a small amount of time. Try with the "retryOnConflict" option | | services.storage.unexpected_bad_request
0x01010021
| BadRequestError 
(400)
| Embeds an unexpected bad request error from Elasticsearch | | services.storage.unexpected_not_found
0x01010022
| NotFoundError 
(404)
| Embeds an unexpected notfound error from Elasticsearch | | services.storage.unexpected_error
0x01010023
| ExternalServiceError 
(500)
| Embeds an unexpected error from Elasticsearch | | services.storage.no_mapping_found
0x01010025
| NotFoundError 
(404)
| Attempted to read a non-existent mapping |

Subdomain: 0x0103: cache #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | services.cache.database_not_found

0x01030001
| NotFoundError 
(404)
| Unknown cache database name | | services.cache.read_failed
0x01030002
| InternalError 
(500)
| An attempt to read from the cache failed | | services.cache.not_connected
0x01030003
| ServiceUnavailableError 
(503)
| Unable to connect to the cache server | | services.cache.write_failed
0x01030004
| InternalError 
(500)
| An attempt to write to the cache failed |

0x02: api #

Subdomain: 0x0201: assert #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | api.assert.invalid_type

0x02010001
| BadRequestError 
(400)
| Wrong argument type | | api.assert.invalid_argument
0x02010002
| BadRequestError 
(400)
| A request argument holds an invalid value | | api.assert.missing_argument
0x02010003
| BadRequestError 
(400)
| A required argument is missing | | api.assert.empty_argument
0x02010004
| BadRequestError 
(400)
| The argument cannot be empty | | api.assert.mutually_exclusive
0x02010005
| BadRequestError 
(400)
| Mutually exclusive parameters have been provided | | api.assert.too_many_arguments
0x02010006
| BadRequestError 
(400)
| An argument contains too many keys or values | | api.assert.unexpected_argument
0x02010007
| BadRequestError 
(400)
| An unexpected argument has been provided | | api.assert.body_required
0x02010008
| BadRequestError 
(400)
| A request body is required | | api.assert.unexpected_type_assertion
0x02010009
| InternalError 
(500)
| Unexpected type assertion | | api.assert.invalid_id
0x0201000a
| BadRequestError 
(400)
| _id values cannot start with an underscore | | api.assert.forbidden_argument
0x0201000b
| BadRequestError 
(400)
| A forbidden argument has been provided |

Subdomain: 0x0202: process #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | api.process.action_locked

0x02020001
| PreconditionError 
(412)
| Cannot execute the requested action because it's already executing | | api.process.overloaded
0x02020002
| ServiceUnavailableError 
(503)
| The request has been discarded because the server is overloaded | | api.process.connection_dropped
0x02020003
| BadRequestError 
(400)
| The request has been discarded because its linked client connection has dropped | | api.process.controller_not_found
0x02020004
| NotFoundError 
(404)
| API controller not found | | api.process.action_not_found
0x02020005
| NotFoundError 
(404)
| API controller action not found | | api.process.incompatible_sdk_version
0x02020006
| BadRequestError 
(400)
| SDK is incompatible with the current Kuzzle version |

0x03: network #

Subdomain: 0x0301: http #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | network.http.request_too_large

0x03010001
| SizeLimitError 
(413)
| The size of the request exceeds the server configured limit | | network.http.unexpected_error
0x03010002
| BadRequestError 
(400)
| Caught an unexpected HTTP parsing error | | network.http.too_many_encodings
0x03010003
| BadRequestError 
(400)
| The number of encodings exceeds the server configured limit | | network.http.unsupported_compression
0x03010004
| BadRequestError 
(400)
| The request has been compressed using an unsupported compression algorithm | | network.http.compression_disabled
0x03010005
| BadRequestError 
(400)
| The server has been configured to refuse compressed requests | | network.http.unsupported_verb
0x03010006
| BadRequestError 
(400)
| An HTTP request has been submitted using an unsupported verb | | network.http.url_not_found
0x03010007
| NotFoundError 
(404)
| API URL not found | | network.http.unsupported_content
0x03010008
| BadRequestError 
(400)
| The content described in the content-type header is not supported | | network.http.unsupported_charset
0x03010009
| BadRequestError 
(400)
| Unsupported content charset | | network.http.duplicate_url
0x0301000a
| InternalError 
(500)
| Triggered when an attempt is made to register a duplicate URL in the HTTP router | | network.http.volatile_parse_failed
0x0301000b
| BadRequestError 
(400)
| The x-kuzzle-volatile header received is not in JSON format | | network.http.body_parse_failed
0x0301000c
| BadRequestError 
(400)
| The request body is not in JSON format | | network.http.file_too_large
0x0301000d
| SizeLimitError 
(413)
| The submitted file exceeds the server configured limit |

Subdomain: 0x0302: mqtt #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | network.mqtt.unexpected_error

0x03020001
| BadRequestError 
(400)
| Caught an unexpected MQTT error |

Subdomain: 0x0303: websocket #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | network.websocket.unexpected_error

0x03030001
| BadRequestError 
(400)
| Caught an unexpected WebSocket error |

Subdomain: 0x0304: entrypoint #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | network.entrypoint.unexpected_event

0x03040001
| InternalError 
(500)
| Received an erroneous network event | | network.entrypoint.invalid_port
0x03040002
| InternalError 
(500)
| Invalid network port |

0x04: plugin #

Subdomain: 0x0401: assert #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | plugin.assert.invalid_plugins_dir

0x04010001
| InternalError 
(500)
| The enabled plugins directory cannot be opened | | plugin.assert.cannot_load
0x04010002
| PluginImplementationError 
(500)
| Kuzzle is unable to load a plugin | | plugin.assert.invalid_hook
0x04010003
| PluginImplementationError 
(500)
| A hook must point to either a function named directly exposed by the plugin, or a function. This error is thrown when a hook property is configured with neither of these values | | plugin.assert.invalid_pipe
0x04010004
| PluginImplementationError 
(500)
| A pipe must point to either a function named directly exposed by the plugin, or a function. This error is thrown when a hook property is configured with neither of these values | | plugin.assert.init_not_found
0x04010005
| PluginImplementationError 
(500)
| The plugin does not have an 'init' function | | plugin.assert.privileged_not_supported
0x04010006
| PluginImplementationError 
(500)
| The 'privileged' flag has been set in Kuzzle's configuration for that plugin, but not in the plugin's manifest | | plugin.assert.privileged_not_set
0x04010007
| PluginImplementationError 
(500)
| The 'privileged' flag has been set in the plugin's manifest file, but it needs also to be added in Kuzzle's configuration | | plugin.assert.not_a_constructor
0x04010008
| PluginImplementationError 
(500)
| The exposed plugin is not a constructor | | plugin.assert.name_already_exists
0x04010009
| PluginImplementationError 
(500)
| Another plugin with the same name has already been loaded |

Subdomain: 0x0402: runtime #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | plugin.runtime.failed_init

0x04020001
| PluginImplementationError 
(500)
| An exception was thrown by a plugin's init function | | plugin.runtime.unexpected_error
0x04020002
| PluginImplementationError 
(500)
| Embeds an unexpected plugin error into a standardized KuzzleError object | | plugin.runtime.pipe_timeout
0x04020003
| GatewayTimeoutError 
(504)
| A pipe function execution took more than the configured server limit |

Subdomain: 0x0403: strategy #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | plugin.strategy.invalid_description

0x04030001
| PluginImplementationError 
(500)
| The strategy.description field must be an object | | plugin.strategy.invalid_methods
0x04030002
| PluginImplementationError 
(500)
| The strategy.methods field must be an object | | plugin.strategy.invalid_method_type
0x04030003
| PluginImplementationError 
(500)
| Method definitions in the strategy.methods configuration must be of type string | | plugin.strategy.missing_method_function
0x04030004
| PluginImplementationError 
(500)
| A required strategy method is missing | | plugin.strategy.invalid_config
0x04030005
| PluginImplementationError 
(500)
| The strategy.config field must be an object | | plugin.strategy.unexpected_constructor
0x04030006
| PluginImplementationError 
(500)
| The (deprecated) constructor property can only be set if there is no authenticator defined | | plugin.strategy.invalid_constructor
0x04030007
| PluginImplementationError 
(500)
| The strategy.constructor field must be a constructor | | plugin.strategy.invalid_authenticator
0x04030008
| PluginImplementationError 
(500)
| The strategy.authenticator field must be a string | | plugin.strategy.unknown_authenticator
0x04030009
| PluginImplementationError 
(500)
| This strategy uses an authenticator that hasn't been declared in this.authenticators | | plugin.strategy.invalid_option
0x0403000a
| PluginImplementationError 
(500)
| If defined, the "strategy.config.strategyOptions" and "strategy.config.authenticateOptions" properties must be objects | | plugin.strategy.invalid_fields
0x0403000b
| PluginImplementationError 
(500)
| The field strategy.config.fields must be an array or null | | plugin.strategy.invalid_definition
0x0403000c
| PluginImplementationError 
(500)
| The strategies property must be a non-empty object | | plugin.strategy.failed_registration
0x0403000d
| PluginImplementationError 
(500)
| Passportjs rejected this strategy (see the message for more information) | | plugin.strategy.invalid_verify_return
0x0403000e
| PluginImplementationError 
(500)
| The "verify" method must return a promise | | plugin.strategy.invalid_verify_resolve
0x0403000f
| PluginImplementationError 
(500)
| The "verify" strategy method resolved to a non-object return value | | plugin.strategy.invalid_kuid
0x04030010
| PluginImplementationError 
(500)
| The "verify" method returned an invalid kuid | | plugin.strategy.unknown_kuid
0x04030011
| PluginImplementationError 
(500)
| The "verify" method returned an unknown kuid | | plugin.strategy.unauthorized_removal
0x04030012
| PluginImplementationError 
(500)
| Tried to remove a strategy owned by another plugin | | plugin.strategy.strategy_not_found
0x04030013
| NotFoundError 
(404)
| Attempted to remove a non-existent authentication strategy | | plugin.strategy.missing_user
0x04030014
| UnauthorizedError 
(401)
| A strategy plugin approved credentials without providing a user object to Kuzzle |

Subdomain: 0x0404: controller #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | plugin.controller.invalid_description

0x04040001
| PluginImplementationError 
(500)
| The controller description must be an object | | plugin.controller.invalid_action
0x04040002
| PluginImplementationError 
(500)
| A controller action must be a function name, or a function | | plugin.controller.unexpected_route_property
0x04040003
| PluginImplementationError 
(500)
| An unexpected property has been found in a controller route definition | | plugin.controller.invalid_route_property
0x04040004
| PluginImplementationError 
(500)
| Invalid route property format (must be a non-empty string) | | plugin.controller.undefined_controller
0x04040005
| PluginImplementationError 
(500)
| A HTTP route points to an non-existent controller | | plugin.controller.undefined_action
0x04040006
| PluginImplementationError 
(500)
| A HTTP route points to an non-existent controller action | | plugin.controller.unsupported_verb
0x04040007
| PluginImplementationError 
(500)
| A HTTP route is using an unsupported HTTP verb | | plugin.controller.unserializable_response
0x04040008
| PluginImplementationError 
(500)
| A plugin controller action returned a non-serializable response | | plugin.controller.invalid_action_response
0x04040009
| PluginImplementationError 
(500)
| API actions added by plugins must return a promise |

Subdomain: 0x0405: manifest #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | plugin.manifest.cannot_load

0x04050001
| PluginImplementationError 
(500)
| Unable to load the plugin's manifest file | | plugin.manifest.version_mismatch
0x04050002
| PluginImplementationError 
(500)
| Current Kuzzle's version does not match the plugin's requirements | | plugin.manifest.invalid_name_type
0x04050003
| PluginImplementationError 
(500)
| Invalid plugin's name | | plugin.manifest.invalid_name
0x04050004
| PluginImplementationError 
(500)
| Invalid characters in a plugin's name | | plugin.manifest.missing_name
0x04050005
| PluginImplementationError 
(500)
| A plugin name is required | | plugin.manifest.invalid_errors
0x04050006
| PluginImplementationError 
(500)
| The 'errors' property format is invalid | | plugin.manifest.invalid_privileged
0x04050007
| PluginImplementationError 
(500)
| The "privileged" property is invalid | | plugin.manifest.missing_package
0x04050008
| PluginImplementationError 
(500)
| The plugin is missing a 'package.json' file (run 'npm init' to create one) | | plugin.manifest.missing_package_name
0x04050009
| PluginImplementationError 
(500)
| A 'name' property in the 'package.json' file is required by Kuzzle, as it is used as the plugin's unique name |

Subdomain: 0x0406: context #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | plugin.context.missing_collection

0x04060001
| PluginImplementationError 
(500)
| The 'collection' argument is required, but none was provided | | plugin.context.unavailable_realtime
0x04060002
| PluginImplementationError 
(500)
| Due to technical limitations, plugins have limited access to the realtime API controller | | plugin.context.invalid_user
0x04060003
| PluginImplementationError 
(500)
| The user object provided to the sdk.as() method is not of type User | | plugin.context.invalid_callback
0x04060004
| PluginImplementationError 
(500)
| A non-function callback has been provided | | plugin.context.missing_request
0x04060005
| PluginImplementationError 
(500)
| A Request object is required, but none was supplied | | plugin.context.missing_request_data
0x04060006
| PluginImplementationError 
(500)
| A Request object and/or request data must be provided | | plugin.context.invalid_event
0x04060007
| PluginImplementationError 
(500)
| Invalid event name (colons are not allowed in event names) | | plugin.context.missing_authenticator
0x04060008
| PluginImplementationError 
(500)
| Missing "strategy.config.authenticator" property |

Subdomain: 0x0407: authenticators #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | plugin.authenticators.not_an_object

0x04070001
| PluginImplementationError 
(500)
| The "authenticators" property must be an object | | plugin.authenticators.invalid_authenticator
0x04070002
| PluginImplementationError 
(500)
| Authenticators exposed in the "authenticators" object must be constructors |

0x05: validation #

Subdomain: 0x0501: assert #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | validation.assert.missing_nested_spec

0x05010001
| PreconditionError 
(412)
| All levels of an object have to be defined in the specification | | validation.assert.unexpected_children
0x05010002
| PreconditionError 
(412)
| The field configuration does not allow children fields | | validation.assert.missing_parent
0x05010003
| PreconditionError 
(412)
| Missing parent field | | validation.assert.unexpected_properties
0x05010004
| PreconditionError 
(412)
| Unexpected properties found | | validation.assert.missing_type
0x05010005
| PreconditionError 
(412)
| The property "type" is required | | validation.assert.unknown_type
0x05010006
| PreconditionError 
(412)
| Unknown "type" defined | | validation.assert.missing_value
0x05010007
| PreconditionError 
(412)
| The "value" field is required | | validation.assert.invalid_type
0x05010008
| PreconditionError 
(412)
| Wrong parameter type | | validation.assert.not_multivalued
0x05010009
| PreconditionError 
(412)
| Expected the field to be multivalued | | validation.assert.invalid_range
0x0501000a
| PreconditionError 
(412)
| A range has been defined with its lower bound greater than its upper one | | validation.assert.invalid_specifications
0x0501000b
| BadRequestError 
(400)
| The provided specifications are invalid | | validation.assert.not_found
0x0501000c
| NotFoundError 
(404)
| Attempted to access to a non-existent collection specifications | | validation.assert.invalid_filters
0x0501000d
| BadRequestError 
(400)
| The Koncorde filters provided as a validator are invalid |

Subdomain: 0x0502: types #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | validation.types.invalid_date_format

0x05020001
| PreconditionError 
(412)
| One or multiple date format types are invalid | | validation.types.invalid_date
0x05020002
| PreconditionError 
(412)
| The date value is invalid and cannot be parsed | | validation.types.missing_enum_values
0x05020003
| PreconditionError 
(412)
| The "enum" type requires a "values" property holding the list of the enum values | | validation.types.invalid_geoshape
0x05020004
| PreconditionError 
(412)
| One or multiple geoshape types are invalid | | validation.types.missing_type_name
0x05020005
| PluginImplementationError 
(500)
| Type definitions must have a "typeName" defined | | validation.types.missing_function
0x05020006
| PluginImplementationError 
(500)
| A required function is missing from the new validation data type | | validation.types.already_exists
0x05020007
| PluginImplementationError 
(500)
| Duplicate data type definition |

Subdomain: 0x0503: check #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | validation.check.failed_document

0x05030001
| BadRequestError 
(400)
| Document rejected because it does not validate the collection specifications | | validation.check.failed_field
0x05030002
| BadRequestError 
(400)
| Document rejected because one of its field does not validate the collection specifications |

0x06: protocol #

Subdomain: 0x0601: runtime #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | protocol.runtime.invalid_connection

0x06010001
| PluginImplementationError 
(500)
| Connection objects must have both their id and protocol set | | protocol.runtime.unknown_connection
0x06010002
| PluginImplementationError 
(500)
| The provided connection identifier is unknown | | protocol.runtime.already_exists
0x06010003
| PluginImplementationError 
(500)
| A protocol of the same name already exists |

0x07: security #

Subdomain: 0x0701: token #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | security.token.invalid

0x07010001
| UnauthorizedError 
(401)
| Invalid authentication token. | | security.token.unknown_user
0x07010002
| InternalError 
(500)
| Missing user or missing user identifier | | security.token.unknown_connection
0x07010003
| InternalError 
(500)
| Missing connection identifier | | security.token.ttl_exceeded
0x07010004
| BadRequestError 
(400)
| An authentication token was requested with a TTL larger than the configured maximum value | | security.token.generation_failed
0x07010005
| InternalError 
(500)
| Unable to generate the requested authentication token | | security.token.expired
0x07010006
| UnauthorizedError 
(401)
| The provided authentication token has expired | | security.token.verification_error
0x07010007
| InternalError 
(500)
| An unexpected error occured while verifying an authentication token |

Subdomain: 0x0702: credentials #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | security.credentials.unknown_strategy

0x07020001
| BadRequestError 
(400)
| Unknown authentication strategy | | security.credentials.database_inconsistency
0x07020002
| PluginImplementationError 
(500)
| Inconsistency detected: credentials were found on a non-existing user | | security.credentials.rejected
0x07020003
| BadRequestError 
(400)
| User's credentials were rejected during |

Subdomain: 0x0703: rights #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | security.rights.unauthorized

0x07030001
| UnauthorizedError 
(401)
| Authentication required | | security.rights.forbidden
0x07030002
| ForbiddenError 
(403)
| Insufficient permissions to execute this action |

Subdomain: 0x0704: user #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | security.user.already_exists

0x07040001
| PreconditionError 
(412)
| Cannot create the user as it already exists | | security.user.not_found
0x07040002
| NotFoundError 
(404)
| Attempted to access to a non-existing user | | security.user.anonymous_profile_required
0x07040003
| BadRequestError 
(400)
| The anonymous user must be assigned to the anonymous profile | | security.user.cannot_hydrate
0x07040004
| InternalError 
(500)
| Database inconsistency error: a user is referencing non-existing profiles | | security.user.uninitialized
0x07040005
| InternalError 
(500)
| Attempted to access to an unitialized User object |

Subdomain: 0x0705: role #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | security.role.not_found

0x07050001
| NotFoundError 
(404)
| Attempted to access to a non-existing role | | security.role.login_required
0x07050002
| BadRequestError 
(400)
| Cannot remove the "login" action from the anonymous role | | security.role.cannot_delete
0x07050003
| BadRequestError 
(400)
| Attempted to delete a base role (anonymous, default, admin) | | security.role.in_use
0x07050004
| PreconditionError 
(412)
| A role still assigned to profiles cannot be deleted | | security.role.uninitialized
0x07050005
| InternalError 
(500)
| Attempted to access to an unitialized Role object | | security.role.invalid_rights
0x07050006
| BadRequestError 
(400)
| Invalid rights | | security.role.closure_exec_failed
0x07050007
| BadRequestError 
(400)
| Execution failed on the provided closure | | security.role.closure_missing_test
0x07050008
| BadRequestError 
(400)
| Closures must specify a "test" attribute |

Subdomain: 0x0706: profile #

| Id | Error Type (Status Code) | Message | | ------ | -----------------| ------------------ | ------------------ | | security.profile.not_found

0x07060001
| NotFoundError 
(404)
| Attempted to access to a non-existing profile | | security.profile.cannot_delete
0x07060002
| BadRequestError 
(400)
| Attempted to delete a base profile (anonymous, default, admin) | | security.profile.in_use
0x07060003
| PreconditionError 
(412)
| A profile still assigned to users cannot be deleted | | security.profile.cannot_hydrate
0x07060004
| InternalError 
(500)
| Database inconsistency error: a profile is referencing non-existing roles | | security.profile.missing_anonymous_role
0x07060005
| BadRequestError 
(400)
| The anonymous profile must include the anonymous role | | security.profile.uninitialized
0x07060006
| InternalError 
(500)
| Attempted to access to an unitialized Profile object |

Edit this page on Github(opens new window)