@twin.org/node 0.0.3-next.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +201 -0
- package/README.md +43 -0
- package/bin/index.js +4 -0
- package/dist/locales/en.json +1885 -0
- package/docs/changelog.md +742 -0
- package/docs/configuration.md +223 -0
- package/docs/deployment-docker.md +189 -0
- package/docs/deployment-ec2.md +193 -0
- package/docs/deployment.md +4 -0
- package/docs/examples.md +149 -0
- package/docs/open-api/spec.json +19808 -0
- package/locales/en.json +1 -0
- package/package.json +40 -0
- package/src/index.js +12 -0
|
@@ -0,0 +1,1885 @@
|
|
|
1
|
+
{
|
|
2
|
+
"error": {
|
|
3
|
+
"node": {
|
|
4
|
+
"nodeIdentityNotSet": "The node identity is enabled in config but is not set, please set it using the \"node-set-identity\" CLI command.",
|
|
5
|
+
"nodeTenantNotSet": "Multi-tenancy is enabled but node tenant is not set, please set it using the \"node-set-tenant\" CLI command.",
|
|
6
|
+
"storageFileRootNotSet": "{storageFileRoot} is not set, the server will not start without it, please set it in the shell or create a .env file",
|
|
7
|
+
"extensionLoadingError": "Failed to load extension \"{extension}\"",
|
|
8
|
+
"insecureProtocol": "Cannot load extension from insecure protocol: {protocol}. Only HTTPS is allowed for remote extensions.",
|
|
9
|
+
"extensionDownloadFailed": "Failed to download extension from {url}",
|
|
10
|
+
"extensionNpmInstallFailed": "Failed to install npm extension: {package}",
|
|
11
|
+
"extensionSizeLimitExceeded": "Extension download size exceeds limit: {size} bytes > {limit} bytes",
|
|
12
|
+
"cliCommandMissing": "CLI command \"{command}\" is not recognised",
|
|
13
|
+
"cliCommandParamMissing": "Parameter \"{param}\" is required for command \"{command}\"",
|
|
14
|
+
"cliCommandParamExtra": "Parameter(s) \"{params}\" are not recognised for command \"{command}\"",
|
|
15
|
+
"cliEnvVarMissing": "Environment variable \"{envVar}\" does not exist"
|
|
16
|
+
},
|
|
17
|
+
"bootstrapLegacy": {
|
|
18
|
+
"noFeaturesEnabled": "No features are enabled in legacy bootstrap mode, at least one feature must be enabled."
|
|
19
|
+
},
|
|
20
|
+
"identityCreate": {
|
|
21
|
+
"invalidMnemonic": "The mnemonic is invalid, it should be 24 words from the standard wordlist."
|
|
22
|
+
},
|
|
23
|
+
"identityImport": {
|
|
24
|
+
"identityNotFound": "The identity was not found, it must be created on-chain already.",
|
|
25
|
+
"invalidMnemonic": "The mnemonic is invalid, it should be 24 words from the standard wordlist."
|
|
26
|
+
},
|
|
27
|
+
"identityVerificationMethodCreate": {
|
|
28
|
+
"verificationMethodAlreadyExists": "The verification method with ID already exists and overwriteMode is set to \"error\"."
|
|
29
|
+
},
|
|
30
|
+
"identityVerifiableCredentialCreate": {
|
|
31
|
+
"subjectJsonLoadFailed": "Failed to load subject JSON from file: \"{subjectFilename}\""
|
|
32
|
+
},
|
|
33
|
+
"tenantCreate": {
|
|
34
|
+
"tenantAdminComponentNotRegistered": "Multi-tenant support must be enabled to use this command."
|
|
35
|
+
},
|
|
36
|
+
"tenantImport": {
|
|
37
|
+
"tenantAdminComponentNotRegistered": "Multi-tenant support must be enabled to use this command."
|
|
38
|
+
},
|
|
39
|
+
"userCreate": {
|
|
40
|
+
"passwordTooShort": "The password provided is too short, it must be at least {minLength} characters long.",
|
|
41
|
+
"userAlreadyExists": "The user with ID already exists and overwriteMode is set to \"error\"."
|
|
42
|
+
},
|
|
43
|
+
"vaultKeyCreate": {
|
|
44
|
+
"vaultKeyAlreadyExists": "The vault key with ID already exists and overwriteMode is set to \"error\"."
|
|
45
|
+
},
|
|
46
|
+
"entityStorageAuthenticationService": {
|
|
47
|
+
"loginFailed": "Login failed",
|
|
48
|
+
"userNotFound": "The user with the specified e-mail could not be found",
|
|
49
|
+
"passwordMismatch": "The password does not match the user's password"
|
|
50
|
+
},
|
|
51
|
+
"entityStorageAuthenticationAdminService": {
|
|
52
|
+
"userExists": "The user with the specified e-mail already exists",
|
|
53
|
+
"createUserFailed": "Creating the user failed",
|
|
54
|
+
"removeUserFailed": "Removing the user failed",
|
|
55
|
+
"updatePasswordFailed": "Updating the user's password failed",
|
|
56
|
+
"passwordTooShort": "The password is too short, it must be at least {minLength} characters long",
|
|
57
|
+
"userNotFound": "The user with the specified e-mail could not be found \"{notFoundId}\"",
|
|
58
|
+
"currentPasswordMismatch": "The current password is incorrect"
|
|
59
|
+
},
|
|
60
|
+
"tokenHelper": {
|
|
61
|
+
"missing": "The JSON Web token could not be found in the authorization header",
|
|
62
|
+
"payloadMissingSubject": "The JSON Web token payload does not contain a subject",
|
|
63
|
+
"payloadMissingOrganization": "The JSON Web token payload does not contain an organization",
|
|
64
|
+
"expired": "The JSON Web token has expired"
|
|
65
|
+
},
|
|
66
|
+
"authHeaderProcessor": {
|
|
67
|
+
"tenantIdMismatch": "The tenant ID in the token does not match the tenant ID in the context"
|
|
68
|
+
},
|
|
69
|
+
"validation": {
|
|
70
|
+
"beEmpty": "{fieldName} must be empty",
|
|
71
|
+
"beNotEmpty": "{fieldName} must not be empty",
|
|
72
|
+
"beText": "{fieldName} must be text",
|
|
73
|
+
"beTextValue": "{fieldName} must contain some text",
|
|
74
|
+
"beTextMinMax": "{fieldName} must be longer than {minLength} and shorter than {maxLength} characters",
|
|
75
|
+
"beTextMin": "{fieldName} must be longer than {minLength} characters",
|
|
76
|
+
"beTextMax": "{fieldName} must be shorter than {maxLength} characters",
|
|
77
|
+
"beTextBase58": "{fieldName} must be text formatted using Base58 characters",
|
|
78
|
+
"beTextBase64": "{fieldName} must be text formatted using Base64 characters",
|
|
79
|
+
"beTextHex": "{fieldName} must be text formatted using Hex characters",
|
|
80
|
+
"beTextRegExp": "{fieldName} must be text formatted using the matching pattern {format}",
|
|
81
|
+
"beNumber": "{fieldName} must be a number",
|
|
82
|
+
"beNumberMinMax": "{fieldName} must be >= {minValue} and <= {maxValue}",
|
|
83
|
+
"beNumberMin": "{fieldName} must be >= {minValue}",
|
|
84
|
+
"beNumberMax": "{fieldName} must be <= {maxValue}",
|
|
85
|
+
"beWholeNumber": "{fieldName} must be a whole number",
|
|
86
|
+
"beWholeNumberMinMax": "{fieldName} must be a whole number >= {minValue} and <= {maxValue}",
|
|
87
|
+
"beWholeNumberMin": "{fieldName} must be a whole number >= {minValue}",
|
|
88
|
+
"beWholeNumberMax": "{fieldName} must be a whole number <= {maxValue}",
|
|
89
|
+
"beBigInteger": "{fieldName} must be a bigint",
|
|
90
|
+
"beBigIntegerMinMax": "{fieldName} must be a bigint >= {minValue} and <= {maxValue}",
|
|
91
|
+
"beBigIntegerMin": "{fieldName} must be a bigint >= {minValue}",
|
|
92
|
+
"beBigIntegerMax": "{fieldName} must be a bigint <= {maxValue}",
|
|
93
|
+
"beBoolean": "{fieldName} must be true or false",
|
|
94
|
+
"beDate": "{fieldName} must be a date",
|
|
95
|
+
"beDateTime": "{fieldName} must be a date/time",
|
|
96
|
+
"beTime": "{fieldName} must be a time",
|
|
97
|
+
"beTimestampMilliseconds": "{fieldName} must be a timestamp in milliseconds",
|
|
98
|
+
"beTimestampSeconds": "{fieldName} must be a timestamp in seconds",
|
|
99
|
+
"beObject": "{fieldName} must be an object",
|
|
100
|
+
"beArray": "{fieldName} must be an array",
|
|
101
|
+
"beArrayValue": "{fieldName} must be an array with at least one item",
|
|
102
|
+
"beIncluded": "{fieldName} is unrecognised",
|
|
103
|
+
"beByteArray": "{fieldName} must be a byte array",
|
|
104
|
+
"beUrn": "{fieldName} must be a correctly formatted urn",
|
|
105
|
+
"beUrl": "{fieldName} must be a correctly formatted url",
|
|
106
|
+
"beJSON": "{fieldName} must be correctly formatted JSON",
|
|
107
|
+
"beEmail": "{fieldName} must be a correctly formatted e-mail address",
|
|
108
|
+
"minLengthRequired": "The value length should be at least {minLength}, it is {actualLength}",
|
|
109
|
+
"maxLengthRequired": "The value length should be at most {maxLength}, it is {actualLength}",
|
|
110
|
+
"repeatedCharacters": "The value should not contain repeated characters in sequence",
|
|
111
|
+
"atLeastOneLowerCase": "The value should contain at least one lowercase character",
|
|
112
|
+
"atLeastOneUpperCase": "The value should contain at least one uppercase character",
|
|
113
|
+
"atLeastOneNumber": "The value should contain at least one number",
|
|
114
|
+
"atLeastOneSpecialChar": "The value should contain at least one symbol",
|
|
115
|
+
"schema": {
|
|
116
|
+
"failedValidation": "The JSON schema failed validation, {message}",
|
|
117
|
+
"missingType": "Failed to validate as there is no handler for type \"{dataType}\""
|
|
118
|
+
},
|
|
119
|
+
"geo": {
|
|
120
|
+
"coordinatesLatitudeNumber": "The latitude value must be a number",
|
|
121
|
+
"coordinatesLatitudeRange": "The latitude value must be between -90 and 90",
|
|
122
|
+
"coordinatesLongitudeNumber": "The longitude value must be a number",
|
|
123
|
+
"coordinatesLongitudeRange": "The longitude value must be between -180 and 180"
|
|
124
|
+
},
|
|
125
|
+
"auditableItemGraphService": {
|
|
126
|
+
"edgeIdSameAsVertexId": "The edge with target id \"{targetId}\" can not point to the vertex it belongs to"
|
|
127
|
+
}
|
|
128
|
+
},
|
|
129
|
+
"guard": {
|
|
130
|
+
"undefined": "Property \"{property}\" must be defined, it is \"{value}\"",
|
|
131
|
+
"string": "Property \"{property}\" must be a string, it is \"{value}\"",
|
|
132
|
+
"stringEmpty": "Property \"{property}\" must have a value, it is empty",
|
|
133
|
+
"stringBase64": "Property \"{property}\" must be a base64 encoded string, it is \"{value}\"",
|
|
134
|
+
"stringBase64Url": "Property \"{property}\" must be a base64 url encoded string, it is \"{value}\"",
|
|
135
|
+
"stringBase58": "Property \"{property}\" must be a base58 encoded string, it is \"{value}\"",
|
|
136
|
+
"stringHex": "Property \"{property}\" must be a hex string, it is \"{value}\"",
|
|
137
|
+
"stringHexLength": "Property \"{property}\" must be a hex string of length \"{options}\", it is \"{value}\"",
|
|
138
|
+
"stringJson": "Property \"{property}\" must be a JSON string",
|
|
139
|
+
"number": "Property \"{property}\" must be a number, it is \"{value}\"",
|
|
140
|
+
"integer": "Property \"{property}\" must be an integer, it is \"{value}\"",
|
|
141
|
+
"bigint": "Property \"{property}\" must be a bigint, it is \"{value}\"",
|
|
142
|
+
"boolean": "Property \"{property}\" must be a boolean, it is \"{value}\"",
|
|
143
|
+
"date": "Property \"{property}\" must be a date, it is \"{value}\"",
|
|
144
|
+
"timestampMilliseconds": "Property \"{property}\" must be a timestamp in milliseconds, it is \"{value}\"",
|
|
145
|
+
"timestampSeconds": "Property \"{property}\" must be a timestamp in seconds, it is \"{value}\"",
|
|
146
|
+
"objectUndefined": "Property \"{property}\" must be an object, it is \"undefined\"",
|
|
147
|
+
"object": "Property \"{property}\" must be an object, it is \"{value}\"",
|
|
148
|
+
"objectValue": "Property \"{property}\" must be an object, with at least one property, it is \"{value}\"",
|
|
149
|
+
"array": "Property \"{property}\" must be an array, it is \"{value}\"",
|
|
150
|
+
"arrayValue": "Property \"{property}\" must be an array with at least one item",
|
|
151
|
+
"arrayOneOf": "Property \"{property}\" must be one of [{options}], it is \"{value}\"",
|
|
152
|
+
"arrayStartsWith": "Property \"{property}\" must be an array starting with [{startValues}], it is \"{value}\"",
|
|
153
|
+
"arrayEndsWith": "Property \"{property}\" must be an array ending with [{endValues}], it is \"{value}\"",
|
|
154
|
+
"uint8Array": "Property \"{property}\" must be a Uint8Array, it is \"{value}\"",
|
|
155
|
+
"function": "Property \"{property}\" must be a function, it is \"{value}\"",
|
|
156
|
+
"urn": "Property \"{property}\" must be a Urn formatted string, it is \"{value}\"",
|
|
157
|
+
"url": "Property \"{property}\" must be a Url formatted string, it is \"{value}\"",
|
|
158
|
+
"email": "Property \"{property}\" must be string in e-mail format, it is \"{value}\"",
|
|
159
|
+
"uuidV7": "Property \"{property}\" must be a UUIDv7 formatted string, it is \"{value}\"",
|
|
160
|
+
"uuidV7Compact": "Property \"{property}\" must be a UUIDv7 formatted string in compact mode, it is \"{value}\"",
|
|
161
|
+
"length32Multiple": "Property \"{property}\" should be a multiple of 32, it is {value}",
|
|
162
|
+
"lengthEntropy": "Property \"{property}\" should be a multiple of 4, >=16 and <= 32, it is {value}",
|
|
163
|
+
"didPartsTooFew": "The DID \"{value}\" is invalid: expected at least 3 parts but got fewer",
|
|
164
|
+
"didInvalidStart": "The DID \"{value}\" is invalid: expected to start with 'did'"
|
|
165
|
+
},
|
|
166
|
+
"objectHelper": {
|
|
167
|
+
"failedBytesToJSON": "Failed converting bytes to JSON",
|
|
168
|
+
"cannotSetArrayIndex": "Cannot set property \"{property}\" using index \"{index}\" as it is not an array",
|
|
169
|
+
"cannotSetProperty": "Cannot set property \"{property}\" when the target is not an object"
|
|
170
|
+
},
|
|
171
|
+
"common": {
|
|
172
|
+
"notImplementedMethod": "The method \"{method}\" has not been implemented",
|
|
173
|
+
"validation": "Validation failed"
|
|
174
|
+
},
|
|
175
|
+
"factory": {
|
|
176
|
+
"noUnregister": "There is no {typeName} registered with the name \"{name}\"",
|
|
177
|
+
"noGet": "The requested {typeName} \"{name}\" does not exist in the factory"
|
|
178
|
+
},
|
|
179
|
+
"bitString": {
|
|
180
|
+
"outOfRange": "The index should be >= 0 and less than the length of the bit string, the index is \"{index}\" and the number of bit is \"{numberBits}\""
|
|
181
|
+
},
|
|
182
|
+
"base32": {
|
|
183
|
+
"invalidCharacter": "Data contains a character \"{invalidCharacter}\" which is not in the charset"
|
|
184
|
+
},
|
|
185
|
+
"base64": {
|
|
186
|
+
"length4Multiple": "Invalid length should be a multiple of 4, it is \"{value}\""
|
|
187
|
+
},
|
|
188
|
+
"base58": {
|
|
189
|
+
"invalidCharacter": "Data contains a character \"{invalidCharacter}\" which is not in the charset"
|
|
190
|
+
},
|
|
191
|
+
"jsonHelper": {
|
|
192
|
+
"failedPatch": "Failed to patch the JSON object, patch index \"{index}\" failed"
|
|
193
|
+
},
|
|
194
|
+
"fetchHelper": {
|
|
195
|
+
"decodingJSON": "Decoding JSON failed for route \"{url}\"",
|
|
196
|
+
"failureStatusText": "The request to the API failed: \"{statusText}\"",
|
|
197
|
+
"connectivity": "The request failed, the API could be offline, or there are other connectivity issues",
|
|
198
|
+
"timeout": "The request timed out",
|
|
199
|
+
"general": "A general failure occurred during the request",
|
|
200
|
+
"retryLimitExceeded": "The retry limit was exceeded for route \"{url}\""
|
|
201
|
+
},
|
|
202
|
+
"jwt": {
|
|
203
|
+
"noKeyOrSigner": "No key or signer was provided for JWT creation",
|
|
204
|
+
"noKeyOrVerifier": "No key or verifier was provided for JWT creation",
|
|
205
|
+
"verifyFailed": "Failed to verify JWT",
|
|
206
|
+
"invalidTokenParts": "The JSON Web Token could not be parsed, it should contain three parts separated by dots",
|
|
207
|
+
"invalidSigningBytes": "The signing bytes are invalid, it should contain two parts separated by a dot"
|
|
208
|
+
},
|
|
209
|
+
"jwk": {
|
|
210
|
+
"jwkImportFailed": "Failed to import JWK"
|
|
211
|
+
},
|
|
212
|
+
"jws": {
|
|
213
|
+
"createFailed": "Failed to create JWS",
|
|
214
|
+
"verifyFailed": "Failed to verify JWS"
|
|
215
|
+
},
|
|
216
|
+
"headerHelper": {
|
|
217
|
+
"invalidLinkHeaderURL": "URL for Link header cannot contain \">\" character.",
|
|
218
|
+
"invalidLinkHeaderRel": "Relation type for Link header cannot contain \" character."
|
|
219
|
+
},
|
|
220
|
+
"ed25519": {
|
|
221
|
+
"privateKeyLength": "The private key length is incorrect, it should be \"{requiredSize}\" but is \"{actualSize}\"",
|
|
222
|
+
"publicKeyLength": "The public key length is incorrect, it should be \"{requiredSize}\" but is \"{actualSize}\""
|
|
223
|
+
},
|
|
224
|
+
"secp256k1": {
|
|
225
|
+
"privateKeyLength": "The private key length is incorrect, it should be \"{requiredSize}\" but is \"{actualSize}\"",
|
|
226
|
+
"publicKeyLength": "The public key length is incorrect, it should be \"{requiredSize}\" but is \"{actualSize}\""
|
|
227
|
+
},
|
|
228
|
+
"sha512": {
|
|
229
|
+
"bitSize": "Only 224, 256, 384 or 512 bits are supported, it is \"{bitSize}\""
|
|
230
|
+
},
|
|
231
|
+
"sha256": {
|
|
232
|
+
"bitSize": "Only 224 or 256 bits are supported, it is \"{bitSize}\""
|
|
233
|
+
},
|
|
234
|
+
"sha3": {
|
|
235
|
+
"bitSize": "Only 224, 256, 384 or 512 bits are supported, it is \"{bitSize}\""
|
|
236
|
+
},
|
|
237
|
+
"hmacSha256": {
|
|
238
|
+
"bitSize": "Only 224 or 256 bits are supported, it is \"{bitSize}\""
|
|
239
|
+
},
|
|
240
|
+
"hmacSha512": {
|
|
241
|
+
"bitSize": "Only 224, 256, 384 or 512 bits are supported, it is \"{bitSize}\""
|
|
242
|
+
},
|
|
243
|
+
"bech32": {
|
|
244
|
+
"decodeFailed": "The address contains decoding failed for address \"{bech32}\"",
|
|
245
|
+
"invalidChecksum": "The address contains an invalid checksum in address, \"{bech32}\"",
|
|
246
|
+
"separatorMisused": "The separator character '1' should only be used between hrp and data, \"{bech32}\"",
|
|
247
|
+
"lowerUpper": "The address my use either lowercase or uppercase, \"{bech32}\"",
|
|
248
|
+
"dataTooShort": "The address does not contain enough data to decode, \"{bech32}\""
|
|
249
|
+
},
|
|
250
|
+
"bip44": {
|
|
251
|
+
"unsupportedKeyType": "The key type \"{keyType}\" is not supported"
|
|
252
|
+
},
|
|
253
|
+
"slip0010": {
|
|
254
|
+
"invalidSeed": "The seed is invalid \"{seed}\""
|
|
255
|
+
},
|
|
256
|
+
"baseRestClient": {
|
|
257
|
+
"missingRouteProp": "Missing route parameter in data \"{routeProp}\" for route \"{route}\"",
|
|
258
|
+
"decodingFailed": "Decoding JSON failed for route \"{route}\"",
|
|
259
|
+
"failureStatusText": "The request to the API failed: \"{statusText}\""
|
|
260
|
+
},
|
|
261
|
+
"contextIdHelper": {
|
|
262
|
+
"contextIdMissing": "The context ID \"{key}\" is missing from the provided context IDs",
|
|
263
|
+
"contextIdSplitMismatch": "The context ID split parts length \"{actual}\" does not match the provided keys length \"{expected}\""
|
|
264
|
+
},
|
|
265
|
+
"contextIdStore": {
|
|
266
|
+
"asyncHooksNotAvailable": "Async Hooks are not available in this environment, please ensure you are running in Node.js"
|
|
267
|
+
},
|
|
268
|
+
"entitySchemaHelper": {
|
|
269
|
+
"noIsPrimary": "Property \"entitySchema.properties\" must contain a value with isPrimary set",
|
|
270
|
+
"multipleIsPrimary": "Property \"entitySchema.properties\" contains more than one property with isPrimary set",
|
|
271
|
+
"invalidEntityProperties": "The schema has no properties defined, but the entity has properties",
|
|
272
|
+
"invalidEntityProperty": "The entity value of \"{value}\" does not match the type \"{type}\" for property \"{property}\"",
|
|
273
|
+
"invalidOptional": "The entity property \"{property}\" of type \"{type}\" is not optional, but no value has been provided",
|
|
274
|
+
"invalidEntityKeys": "The entity had additional properties that are not in the schema, \"{keys}\""
|
|
275
|
+
},
|
|
276
|
+
"vaultConnectorHelper": {
|
|
277
|
+
"invalidSignature": "The JSON Web token signature could not be verified"
|
|
278
|
+
},
|
|
279
|
+
"tenantProcessor": {
|
|
280
|
+
"missingApiKey": "API key header or query param \"{keyName}\" is missing or invalid.",
|
|
281
|
+
"apiKeyNotFound": "No node tenant found for API key \"{key}\"."
|
|
282
|
+
},
|
|
283
|
+
"tenantAdminService": {
|
|
284
|
+
"apiKeyAlreadyInUse": "The provided API key is already in use by another tenant."
|
|
285
|
+
},
|
|
286
|
+
"commands": {
|
|
287
|
+
"common": {
|
|
288
|
+
"missingEnv": "The \"{option}\" option is configured as an environment variable, but there is no environment variable with the name \"{value}\" set.",
|
|
289
|
+
"optionInvalidHex": "The \"{option}\" does not appear to be hex. \"{value}\"",
|
|
290
|
+
"optionInvalidBase64": "The \"{option}\" does not appear to be base64. \"{value}\"",
|
|
291
|
+
"optionInvalidHexBase64": "The \"{option}\" does not appear to be hex or base64. \"{value}\"",
|
|
292
|
+
"optionMinValue": "The \"{option}\" option must be greater than or equal to {minValue}, it is {value}.",
|
|
293
|
+
"optionMaxValue": "The \"{option}\" option must be less than or equal to {maxValue}, it is {value}."
|
|
294
|
+
}
|
|
295
|
+
},
|
|
296
|
+
"jsonLdProcessor": {
|
|
297
|
+
"compact": "The JSON-LD compaction failed",
|
|
298
|
+
"expand": "The JSON-LD expansion failed",
|
|
299
|
+
"canonize": "The JSON-LD canonization failed",
|
|
300
|
+
"invalidUrl": "The JSON-LD processing failed to retrieve from the following url \"{url}\"",
|
|
301
|
+
"jsonLdError": "The JSON-LD processing failed due to the following error: \"{code}\""
|
|
302
|
+
},
|
|
303
|
+
"dataspaceProtocolHelper": {
|
|
304
|
+
"schemaNotRegistered": "JSON Schema \"{schemaId}\" is not registered in DataTypeHandlerFactory"
|
|
305
|
+
},
|
|
306
|
+
"engineCore": {
|
|
307
|
+
"componentUnknownType": "Unknown component type \"{type}\" specified for \"{componentType}\"",
|
|
308
|
+
"bootstrapFailed": "Failed to bootstrap component type \"{className}\" with instance type \"{instanceType}\"",
|
|
309
|
+
"componentStartFailed": "Failed to start component type \"{className}\" with instance type \"{instanceType}\"",
|
|
310
|
+
"componentStopFailed": "Failed to stop component type \"{className}\" with instance type \"{instanceType}\"",
|
|
311
|
+
"instanceTypeNotFound": "Instance type not found for \"{type}\" with features \"{features}\""
|
|
312
|
+
},
|
|
313
|
+
"fileStateStorage": {
|
|
314
|
+
"failedLoading": "Failed to load file state storage from \"{filename}\"",
|
|
315
|
+
"failedSaving": "Failed to save file state storage to \"{filename}\""
|
|
316
|
+
},
|
|
317
|
+
"engineModuleHelper": {
|
|
318
|
+
"moduleNotClass": "The module \"{moduleName}\" does not export a class \"{className}\""
|
|
319
|
+
},
|
|
320
|
+
"moduleHelper": {
|
|
321
|
+
"moduleNotFound": "Failed to load module \"{module}\"",
|
|
322
|
+
"entryNotFound": "Failed to load entry \"{entry}\" from module \"{module}\"",
|
|
323
|
+
"notFunction": "The entry \"{method}\" in module \"{module}\" is not a function",
|
|
324
|
+
"workerException": "The thread worker failed with an exception in module \"{module}\""
|
|
325
|
+
},
|
|
326
|
+
"engineTypes": {
|
|
327
|
+
"entityStorageCustomMissing": "Entity storage custom \"{typeCustom}\" missing for component \"{storageName}\"",
|
|
328
|
+
"entityStorageMissing": "Entity storage configuration missing for component \"{storageName}\"",
|
|
329
|
+
"connectorUnknownType": "Unknown connector type \"{type}\" specified for \"{connectorType}\""
|
|
330
|
+
},
|
|
331
|
+
"nftAttestationConnector": {
|
|
332
|
+
"attestingFailed": "Attesting the data failed",
|
|
333
|
+
"verificationFailed": "Verifying the attestation failed",
|
|
334
|
+
"transferFailed": "Transferring the attestation failed",
|
|
335
|
+
"destroyFailed": "Destroying the attestation failed",
|
|
336
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the NFT Attestation connector \"{namespace}\""
|
|
337
|
+
},
|
|
338
|
+
"proofHelper": {
|
|
339
|
+
"unsupportedProofType": "Proof type \"{proofType}\" not supported."
|
|
340
|
+
},
|
|
341
|
+
"jsonWebSignature2020SignerVerifier": {
|
|
342
|
+
"missingJws": "JWS is missing from proof."
|
|
343
|
+
},
|
|
344
|
+
"dataIntegrityProofSignerVerifier": {
|
|
345
|
+
"cryptosuiteNotSupported": "Cryptosuite \"{cryptoSuite}\" is not supported.",
|
|
346
|
+
"missingPrivateKey": "Private key is missing.",
|
|
347
|
+
"missingPublicKey": "Public key is missing."
|
|
348
|
+
},
|
|
349
|
+
"multikeyHelper": {
|
|
350
|
+
"invalidPublicKeyMultibase": "Public key multibase \"{publicKeyMultibase}\" is invalid.",
|
|
351
|
+
"invalidSecretKeyMultibase": "Secret key multibase \"{secretKeyMultibase}\" is invalid.",
|
|
352
|
+
"unsupportedCrv": "Curve \"{crv}\" is not supported.",
|
|
353
|
+
"unsupportedKty": "Key type \"{kty}\" is not supported.",
|
|
354
|
+
"publicKeyMultibaseMissingHeader": "Public key multibase \"{publicKeyMultibase}\" is missing the multi codec header",
|
|
355
|
+
"secretKeyMultibaseMissingHeader": "Secret key multibase \"{secretKeyMultibase}\" is missing the multi codec header"
|
|
356
|
+
},
|
|
357
|
+
"verificationHelper": {
|
|
358
|
+
"jwtDecodeFailed": "Decoding the JWT failed",
|
|
359
|
+
"proofMissingVerificationMethod": "The proof is missing the verification method"
|
|
360
|
+
},
|
|
361
|
+
"documentHelper": {
|
|
362
|
+
"verificationMethodNotFound": "The verification method \"{methodName}\" of type \"{methodType}\" could not be found",
|
|
363
|
+
"verificationMethodJwkNotFound": "The verification method \"{methodName}\" of type \"{methodType}\" is missing the JWK"
|
|
364
|
+
},
|
|
365
|
+
"attestationService": {
|
|
366
|
+
"noConnectors": "There are no connectors registered with the attestation factory",
|
|
367
|
+
"attestFailed": "The attestation of the data failed",
|
|
368
|
+
"verifyFailed": "The verification of the attestation failed",
|
|
369
|
+
"transferFailed": "The transfer of the attestation failed",
|
|
370
|
+
"destroyFailed": "The destruction of the attestation failed",
|
|
371
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the attestation service \"{namespace}\""
|
|
372
|
+
},
|
|
373
|
+
"auditableItemGraphRestClient": {
|
|
374
|
+
"notSupportedOnClient": "The method \"{methodName}\" is not supported on the REST client, it can only be used on a server side component"
|
|
375
|
+
},
|
|
376
|
+
"auditableItemGraphService": {
|
|
377
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the Auditable Item Graph service \"{namespace}\"",
|
|
378
|
+
"createFailed": "Creating the Auditable Item Graph vertex failed",
|
|
379
|
+
"getFailed": "Getting the Auditable Item Graph vertex failed",
|
|
380
|
+
"updatingFailed": "Updating the Auditable Item Graph vertex failed",
|
|
381
|
+
"queryingFailed": "Querying the Auditable Item Graph failed",
|
|
382
|
+
"removeVerifiableFailed": "Removing the verifiable data the Auditable Item Graph vertex failed",
|
|
383
|
+
"vertexNotFound": "The vertex with the Id \"{notFoundId}\" was not found",
|
|
384
|
+
"resourceIdMissing": "You must provide either the id, or the resourceObject must contain an id property for index \"{index}\"",
|
|
385
|
+
"aliasNotUnique": "The alias id \"{aliasId}\" is already in use on another vertex and the unique flag was set",
|
|
386
|
+
"invalidEdgeId": "The edge id \"{edgeId}\" is not valid"
|
|
387
|
+
},
|
|
388
|
+
"auditableItemStreamRestClient": {
|
|
389
|
+
"notSupportedOnClient": "The method \"{methodName}\" is not supported on the REST client, it can only be used on a server side component"
|
|
390
|
+
},
|
|
391
|
+
"auditableItemStreamService": {
|
|
392
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the Auditable Item Stream service \"{namespace}\"",
|
|
393
|
+
"createFailed": "Creating the Auditable Item Stream failed",
|
|
394
|
+
"getFailed": "Getting the Auditable Item Stream failed",
|
|
395
|
+
"updatingFailed": "Updating the Auditable Item Stream failed",
|
|
396
|
+
"removingFailed": "Removing Auditable Item Stream failed",
|
|
397
|
+
"queryingFailed": "Querying the Auditable Item Stream failed",
|
|
398
|
+
"creatingEntryFailed": "Creating entry in the Auditable Item Stream failed",
|
|
399
|
+
"updatingEntryFailed": "Updating entry in the Auditable Item Stream failed",
|
|
400
|
+
"gettingEntryFailed": "Getting entry from the Auditable Item Stream failed",
|
|
401
|
+
"gettingEntryObjectFailed": "Getting entry object from the Auditable Item Stream failed",
|
|
402
|
+
"removingEntryFailed": "Removing entry from the Auditable Item Stream failed",
|
|
403
|
+
"gettingEntriesFailed": "Getting entries from the Auditable Item Stream failed",
|
|
404
|
+
"gettingEntryObjectsFailed": "Getting entry objects from the Auditable Item Stream failed",
|
|
405
|
+
"removeVerifiableFailed": "Removing verifiable storage from the Auditable Item Stream failed",
|
|
406
|
+
"streamNotFound": "The stream with the Id \"{notFoundId}\" was not found",
|
|
407
|
+
"streamEntryNotFound": "The stream entry with the Id \"{notFoundId}\" was not found"
|
|
408
|
+
},
|
|
409
|
+
"taskSchedulerService": {
|
|
410
|
+
"taskFailed": "Task with id \"{id}\" failed to run"
|
|
411
|
+
},
|
|
412
|
+
"backgroundTaskService": {
|
|
413
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the entity storage background task \"{namespace}\"",
|
|
414
|
+
"completeFailed": "Failed to complete processing task \"{id}\" with type \"{type}\" with status \"{status}\""
|
|
415
|
+
},
|
|
416
|
+
"s3BlobStorageConnector": {
|
|
417
|
+
"bucketCreateFailed": "Creating bucket \"{bucket}\" failed",
|
|
418
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the blob storage \"{namespace}\"",
|
|
419
|
+
"getBlobFailed": "Failed to get blob in S3",
|
|
420
|
+
"setBlobFailed": "Failed to set blob in S3",
|
|
421
|
+
"removeBlobFailed": "Failed to remove blob in S3"
|
|
422
|
+
},
|
|
423
|
+
"azureBlobStorageConnector": {
|
|
424
|
+
"containerCreateFailed": "Creating container \"{container}\" failed",
|
|
425
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the blob storage \"{namespace}\"",
|
|
426
|
+
"getBlobFailed": "Failed to get blob in Azure",
|
|
427
|
+
"setBlobFailed": "Failed to set blob in Azure",
|
|
428
|
+
"removeBlobFailed": "Failed to remove blob in Azure"
|
|
429
|
+
},
|
|
430
|
+
"fileBlobStorageConnector": {
|
|
431
|
+
"directoryCreateFailed": "Creating directory \"{directory}\" failed",
|
|
432
|
+
"getBlobFailed": "Unable to get blob \"{id}\"",
|
|
433
|
+
"setBlobFailed": "Unable to set blob",
|
|
434
|
+
"removeBlobFailed": "Unable to remove blob",
|
|
435
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the blob storage \"{namespace}\""
|
|
436
|
+
},
|
|
437
|
+
"gcpBlobStorageConnector": {
|
|
438
|
+
"bucketCreateFailed": "Creating bucket \"{bucket}\" failed",
|
|
439
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the blob storage \"{namespace}\"",
|
|
440
|
+
"getBlobFailed": "Failed to get blob in GCP",
|
|
441
|
+
"setBlobFailed": "Failed to set blob in GCP",
|
|
442
|
+
"removeBlobFailed": "Failed to remove blob in GCP"
|
|
443
|
+
},
|
|
444
|
+
"ipfsBlobStorageConnector": {
|
|
445
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the blob storage \"{namespace}\"",
|
|
446
|
+
"fetchFail": "Failure during IPFS request",
|
|
447
|
+
"setBlobFailed": "Failed to store blob in IPFS",
|
|
448
|
+
"getBlobFailed": "Failed to get blob from IPFS",
|
|
449
|
+
"removeBlobFailed": "Failed to remove blob from IPFS"
|
|
450
|
+
},
|
|
451
|
+
"memoryBlobStorageConnector": {
|
|
452
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the blob storage \"{namespace}\""
|
|
453
|
+
},
|
|
454
|
+
"blobStorageService": {
|
|
455
|
+
"noConnectors": "There are no connectors registered with the blob storage factory",
|
|
456
|
+
"createFailed": "There was a problem storing the blob",
|
|
457
|
+
"getFailed": "There was a problem getting the blob",
|
|
458
|
+
"updateFailed": "There was a problem updating the blob",
|
|
459
|
+
"removeFailed": "There was a problem removing the blob",
|
|
460
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the blob storage service \"{namespace}\"",
|
|
461
|
+
"vaultConnectorNotConfigured": "The vault connector is not configured, but encryption/decryption was requested.",
|
|
462
|
+
"blobNotFound": "The blob with id \"{notFoundId}\" was not found",
|
|
463
|
+
"entityNotFound": "The entity with id \"{notFoundId}\" was not found"
|
|
464
|
+
},
|
|
465
|
+
"jsonConverterConnector": {
|
|
466
|
+
"invalidFormat": "The provided data is not valid JSON, \"{failure}\""
|
|
467
|
+
},
|
|
468
|
+
"xmlConverterConnector": {
|
|
469
|
+
"invalidFormat": "The provided data is not valid XML, \"{failure}\""
|
|
470
|
+
},
|
|
471
|
+
"jsonPathExtractorConnector": {
|
|
472
|
+
"invalidRule": "The JSONPath rule \"{rule}\" failed"
|
|
473
|
+
},
|
|
474
|
+
"jsonPathHelper": {
|
|
475
|
+
"query": "The JSONPath query \"{path}\" failed",
|
|
476
|
+
"extractSingleFailed": "Failed to extract single value from path \"{path}\"",
|
|
477
|
+
"extractAllFailed": "Failed to extract all values from path \"{path}\"",
|
|
478
|
+
"validateFailed": "The JSONPath query \"{path}\" is invalid"
|
|
479
|
+
},
|
|
480
|
+
"dataProcessingService": {
|
|
481
|
+
"noExtractorFound": "No extractors could be found in the factory",
|
|
482
|
+
"ruleGroupNotFound": "The rule group with id \"{notFoundId}\" could not be found",
|
|
483
|
+
"mimeTypeNotFound": "Unable to detect MIME type from data",
|
|
484
|
+
"converterNotFound": "Unable to find a converter for the MIME type \"{notFoundId}\""
|
|
485
|
+
},
|
|
486
|
+
"dataSpaceConnectorRestClient": {
|
|
487
|
+
"notSupportedOnClient": "The method \"{methodName}\" is not supported on the REST client, it can only be used on a server side component"
|
|
488
|
+
},
|
|
489
|
+
"dataSpaceConnectorService": {
|
|
490
|
+
"activityLogEntryNotFound": "Not found activity Log Entry: \"{notFoundId}\"",
|
|
491
|
+
"activityAlreadyNotified": "Activity has already been notified",
|
|
492
|
+
"invalidActivityGeneratorIdentity": "Invalid activity. No identity specified either on 'generator' or 'actor'",
|
|
493
|
+
"invalidActivity": "Invalid Activity. Expected fields not specified",
|
|
494
|
+
"unknownActivityLogEntryId": "Unknown Activity Log Entry Id \"{activityLogEntryId}\"",
|
|
495
|
+
"tooManyAppsRegistered": "There are several DS Connector Apps registered for Dataset \"{datasetId}\"",
|
|
496
|
+
"noAppRegistered": "There are no DS Connector Apps registered for Dataset \"{datasetId}\"",
|
|
497
|
+
"invalidDataSpaceConnectorApp": "The Data Space Connector App \"{appId}\" is invalid. It does not implement required interfaces",
|
|
498
|
+
"datasetIdRequired": "Dataset ID is required for query operations",
|
|
499
|
+
"notExpandableType": "Entity type \"{type}\" cannot be expanded",
|
|
500
|
+
"queryTypeNotSupported": "Query type \"{queryType}\" is not supported by the DS Connector App"
|
|
501
|
+
},
|
|
502
|
+
"dataSpaceConnectorSocketClient": {
|
|
503
|
+
"socketConnect": "Failure during socket connect",
|
|
504
|
+
"callback": "Error when calling local callback",
|
|
505
|
+
"notSupportedOnClient": "The method \"{methodName}\" is not supported on the socket client, it can only be used on a server side component"
|
|
506
|
+
},
|
|
507
|
+
"documentManagementService": {
|
|
508
|
+
"createFailed": "Failed to create document",
|
|
509
|
+
"updateFailed": "Failed to update document",
|
|
510
|
+
"getFailed": "Failed to get document",
|
|
511
|
+
"getRevisionFailed": "Failed to get document revision",
|
|
512
|
+
"queryFailed": "Failed to query document",
|
|
513
|
+
"documentRevisionNone": "There are no revisions in the document",
|
|
514
|
+
"documentRevisionNotFound": "There is no revision number \"{notFoundId}\" in the document",
|
|
515
|
+
"removeRevisionFailed": "Failed to remove document revision"
|
|
516
|
+
},
|
|
517
|
+
"cosmosDbEntityStorageConnector": {
|
|
518
|
+
"setFailed": "Unable to set entity \"{id}\"",
|
|
519
|
+
"getFailed": "Unable to get entity \"{id}\"",
|
|
520
|
+
"removeFailed": "Unable to remove entity \"{id}\"",
|
|
521
|
+
"queryFailed": "The query failed",
|
|
522
|
+
"comparisonNotSupported": "Comparison operator \"{comparison}\" is not supported",
|
|
523
|
+
"conditionalNotSupported": "Conditional operator \"{operator}\" is not supported",
|
|
524
|
+
"sortSingle": "You can only sort by a single property",
|
|
525
|
+
"sortNotIndexed": "The property \"{property}\" is not indexed and cannot be used for sorting",
|
|
526
|
+
"containerCreateFailed": "The container couldn't be created \"{containerId}\"",
|
|
527
|
+
"databaseCreateFailed": "Unable to create database \"{databaseId}\"",
|
|
528
|
+
"containerDoesNotExist": "Container \"{containerId}\" does not exist"
|
|
529
|
+
},
|
|
530
|
+
"dynamoDbEntityStorageConnector": {
|
|
531
|
+
"tableCreateFailed": "Creating table \"{tableName}\" failed",
|
|
532
|
+
"tableDoesNotExist": "Table \"{tableName}\" does not exist",
|
|
533
|
+
"setFailed": "Unable to set entity \"{id}\"",
|
|
534
|
+
"getFailed": "Unable to get entity \"{id}\"",
|
|
535
|
+
"removeFailed": "Unable to remove entity \"{id}\"",
|
|
536
|
+
"queryFailed": "The query failed",
|
|
537
|
+
"comparisonNotSupported": "Comparison operator \"{comparison}\" is not supported",
|
|
538
|
+
"conditionalNotSupported": "Conditional operator \"{operator}\" is not supported",
|
|
539
|
+
"sortSingle": "You can only sort by a single property",
|
|
540
|
+
"sortNotIndexed": "The property \"{property}\" is not indexed and cannot be used for sorting",
|
|
541
|
+
"propertyNotFound": "The property \"{property}\" was not found on the entity schema"
|
|
542
|
+
},
|
|
543
|
+
"fileEntityStorageConnector": {
|
|
544
|
+
"directoryCreateFailed": "Creating directory \"{directory}\" failed"
|
|
545
|
+
},
|
|
546
|
+
"firestoreEntityStorageConnector": {
|
|
547
|
+
"firestoreCreationFailed": "Failed to connect to Firestore",
|
|
548
|
+
"setEntityFailed": "Failed to set entity \"{id}\"",
|
|
549
|
+
"getEntityFailed": "Failed to get entity \"{id}\"",
|
|
550
|
+
"removeEntityFailed": "Failed to remove entity \"{id}\"",
|
|
551
|
+
"queryFailed": "The query failed when issuing the following command \"{queryDescription}\"",
|
|
552
|
+
"collectionDeleteFailed": "Failed to delete collection \"{collectionName}\"",
|
|
553
|
+
"unsupportedComparisonOperator": "Comparison operator \"{comparison}\" is not supported"
|
|
554
|
+
},
|
|
555
|
+
"mongoDbEntityStorageConnector": {
|
|
556
|
+
"setFailed": "Unable to set entity \"{id}\"",
|
|
557
|
+
"getFailed": "Unable to get entity \"{id}\"",
|
|
558
|
+
"removeFailed": "Unable to remove entity \"{id}\"",
|
|
559
|
+
"databaseCreateFailed": "The database creation failed for \"{databaseName}\"",
|
|
560
|
+
"unsupportedComparisonOperator": "Comparison operator \"{comparison}\" is not supported"
|
|
561
|
+
},
|
|
562
|
+
"mySqlEntityStorageConnector": {
|
|
563
|
+
"setFailed": "Unable to set entity \"{id}\"",
|
|
564
|
+
"getFailed": "Unable to get entity \"{id}\"",
|
|
565
|
+
"removeFailed": "Unable to remove entity \"{id}\"",
|
|
566
|
+
"queryFailed": "The query failed",
|
|
567
|
+
"comparisonNotSupported": "Comparison operator \"{comparison}\" is not supported",
|
|
568
|
+
"conditionalNotSupported": "Conditional operator \"{operator}\" is not supported",
|
|
569
|
+
"entitySchemaPropertiesUndefined": "The entity schema properties are undefined",
|
|
570
|
+
"databaseCreateFailed": "Unable to create database \"{databaseName}\""
|
|
571
|
+
},
|
|
572
|
+
"postgreSqlEntityStorageConnector": {
|
|
573
|
+
"databaseCreateFailed": "Unable to create database \"{databaseName}\"",
|
|
574
|
+
"setFailed": "Unable to set entity \"{id}\"",
|
|
575
|
+
"getFailed": "Unable to get entity \"{id}\"",
|
|
576
|
+
"removeFailed": "Unable to remove entity \"{id}\"",
|
|
577
|
+
"queryFailed": "The query failed",
|
|
578
|
+
"comparisonNotSupported": "Comparison operator \"{comparison}\" is not supported",
|
|
579
|
+
"conditionalNotSupported": "Conditional operator \"{operator}\" is not supported",
|
|
580
|
+
"entitySchemaPropertiesUndefined": "The entity schema properties are undefined"
|
|
581
|
+
},
|
|
582
|
+
"scyllaDBTableConnector": {
|
|
583
|
+
"tableCreateFailed": "Creating table \"{table}\" failed",
|
|
584
|
+
"dropTableFailed": " \"{table}\" cannot be dropped",
|
|
585
|
+
"truncateTableFailed": " \"{table}\" cannot be dropped",
|
|
586
|
+
"removeFailed": "Removing item with \"{id}\" failed",
|
|
587
|
+
"setFailed": "Setting item with \"{id}\" failed"
|
|
588
|
+
},
|
|
589
|
+
"scyllaDBViewConnector": {
|
|
590
|
+
"viewCreateFailed": "Creating view \"{view}\" failed",
|
|
591
|
+
"notSupported": "The operation is not supported \"{methodName}\""
|
|
592
|
+
},
|
|
593
|
+
"abstractScyllaDBConnector": {
|
|
594
|
+
"getFailed": "Getting item with \"{id}\" failed",
|
|
595
|
+
"findFailed": "Error while querying data on \"{table}\"",
|
|
596
|
+
"parseJSONFailed": "Parsing JSON failed for field \"{name}\" with value \"{value}\""
|
|
597
|
+
},
|
|
598
|
+
"synchronisedEntityStorageConnector": {
|
|
599
|
+
"missingRequiredProperty": "The property \"{requiredProperty}\" is required when using the Synchronised Entity Storage Connector.",
|
|
600
|
+
"missingRequiredPropertySort": "The property \"{requiredProperty}\" requires sorting attributes for the Synchronised Entity Storage Connector."
|
|
601
|
+
},
|
|
602
|
+
"verifiableCredentialAuthenticationProcessor": {
|
|
603
|
+
"tokenMissing": "No token provided",
|
|
604
|
+
"tokenVerificationFailed": "The token could not be verified",
|
|
605
|
+
"tokenMissingCredential": "The token does not contain a verifiable credential",
|
|
606
|
+
"tokenMissingIssuer": "The token does not contain an issuer",
|
|
607
|
+
"tokenMissingIssuanceDate": "The token is missing the 'issuanceDate' field for issuer \"{issuer}\"",
|
|
608
|
+
"tokenExpired": "The token has expired for issuer \"{issuer}\"",
|
|
609
|
+
"tokenMissingSubject": "The token is missing the 'credentialSubject' field for issuer \"{issuer}\""
|
|
610
|
+
},
|
|
611
|
+
"entityStorageService": {
|
|
612
|
+
"entityNotFound": "Could not find entity with id \"{notFoundId}\""
|
|
613
|
+
},
|
|
614
|
+
"localEventBusConnector": {
|
|
615
|
+
"callback": "The callback failed during publish topic \"{topic}\" for subscriptionId \"{subscriptionId}\""
|
|
616
|
+
},
|
|
617
|
+
"eventBusSocketClient": {
|
|
618
|
+
"socketConnect": "Failure during socket connect",
|
|
619
|
+
"callback": "Error when calling local callback",
|
|
620
|
+
"notSupportedOnClient": "The method \"{methodName}\" is not supported on the REST client, it can only be used on a server side component"
|
|
621
|
+
},
|
|
622
|
+
"federatedCatalogueService": {
|
|
623
|
+
"datasetNotFound": "Dataset with ID \"{notFoundId}\" not found in the catalogue",
|
|
624
|
+
"datasetNotConformant": "Dataset \"{dataSetId}\" does not conform to DS Protocol specification",
|
|
625
|
+
"datasetIdInvalidUri": "Dataset @id \"{dataSetId}\" must be a valid URI (URN or URL) per DS Protocol",
|
|
626
|
+
"datasetMissingPublisher": "Dataset \"{dataSetId}\" is missing required dcterms:publisher property (needed for participant identification)",
|
|
627
|
+
"filterIndexCreationFailed": "Failed to create filter index for dataset \"{dataSetId}\" using filter \"{filterType}\"",
|
|
628
|
+
"multipleFiltersNotSupported": "Multiple filters are not supported in a single query",
|
|
629
|
+
"noDatasetsFound": "No datasets found in the catalogue"
|
|
630
|
+
},
|
|
631
|
+
"federatedCatalogueRestClient": {
|
|
632
|
+
"notSupportedOnClient": "The method \"{methodName}\" is not supported on the REST client, it can only be used on a server side component"
|
|
633
|
+
},
|
|
634
|
+
"entityStorageIdentityResolverConnector": {
|
|
635
|
+
"documentNotFound": "The document could not be found",
|
|
636
|
+
"resolveDocumentFailed": "Resolving the document failed"
|
|
637
|
+
},
|
|
638
|
+
"entityStorageIdentityConnector": {
|
|
639
|
+
"createDocumentFailed": "Creating the document failed",
|
|
640
|
+
"removeDocumentFailed": "Removing the document failed",
|
|
641
|
+
"signatureVerificationFailed": "The document integrity check failed",
|
|
642
|
+
"missingDid": "The full id including DID is required",
|
|
643
|
+
"addVerificationMethodFailed": "Adding the verification method failed",
|
|
644
|
+
"removeVerificationMethodFailed": "Removing the verification method failed",
|
|
645
|
+
"addServiceFailed": "Adding the service failed",
|
|
646
|
+
"removeServiceFailed": "Removing the service failed",
|
|
647
|
+
"documentNotFound": "The document could not be found \"{notFoundId}\"",
|
|
648
|
+
"verificationMethodNotFound": "The verification method could not be found",
|
|
649
|
+
"serviceNotFound": "The service could not be found",
|
|
650
|
+
"publicKeyJwkMissing": "The verification method contains no publicKeyJwk in method \"{method}\"",
|
|
651
|
+
"jwkSignatureFailed": "The signature on the JWK failed verification",
|
|
652
|
+
"createVerifiableCredentialFailed": "Creating the verifiable credential failed",
|
|
653
|
+
"checkingVerifiableCredentialFailed": "Checking the verifiable credential failed",
|
|
654
|
+
"createVerifiablePresentationFailed": "Creating the verifiable presentation failed",
|
|
655
|
+
"checkingVerifiablePresentationFailed": "Checking the verifiable presentation failed",
|
|
656
|
+
"createProofFailed": "Creating the signature for the data failed",
|
|
657
|
+
"methodMissing": "The verification method specified does not exist \"{method}\"",
|
|
658
|
+
"verifyProofFailed": "Verifying the signature for the data failed",
|
|
659
|
+
"revokeVerifiableCredentialsFailed": "Revoking verifiable credentials failed",
|
|
660
|
+
"unrevokeVerifiableCredentialsFailed": "Unrevoking verifiable credentials failed"
|
|
661
|
+
},
|
|
662
|
+
"entityStorageIdentityProfileConnector": {
|
|
663
|
+
"alreadyExists": "The identity profile already exists for the identity \"{existingId}\"",
|
|
664
|
+
"createFailed": "Creating the identity profile failed \"{identity}\"",
|
|
665
|
+
"identityNotFound": "The identity profile could not be found \"{notFoundId}\"",
|
|
666
|
+
"getFailed": "Getting the identity profile failed \"{identity}\"",
|
|
667
|
+
"updateFailed": "Updating the identity profile failed \"{identity}\"",
|
|
668
|
+
"notFound": "The identity profile failed \"{notFoundId}\"",
|
|
669
|
+
"removeFailed": "Removing the identity profile failed \"{identity}\"",
|
|
670
|
+
"listFailed": "Failed listing identities"
|
|
671
|
+
},
|
|
672
|
+
"iotaIdentityResolverConnector": {
|
|
673
|
+
"documentNotFound": "The document could not be found",
|
|
674
|
+
"resolveDocumentFailed": "Resolving the document failed \"{documentId}\""
|
|
675
|
+
},
|
|
676
|
+
"iotaIdentityConnector": {
|
|
677
|
+
"createDocumentFailed": "Creating the document failed",
|
|
678
|
+
"removeDocumentFailed": "Removing the document failed",
|
|
679
|
+
"missingDid": "The full id including DID is required",
|
|
680
|
+
"addVerificationMethodFailed": "Adding the verification method failed",
|
|
681
|
+
"removeVerificationMethodFailed": "Removing the verification method failed",
|
|
682
|
+
"addServiceFailed": "Adding the service failed",
|
|
683
|
+
"removeServiceFailed": "Removing the service failed",
|
|
684
|
+
"documentNotFound": "The document could not be found",
|
|
685
|
+
"verificationMethodNotFound": "The verification method could not be found",
|
|
686
|
+
"serviceNotFound": "The service could not be found",
|
|
687
|
+
"publicKeyJwkMissing": "The verification method contains no publicKeyJwk in JWK \"{jwk}\"",
|
|
688
|
+
"publicKeyJwkMethodMissing": "The verification method contains no publicKeyJwk in method \"{method}\"",
|
|
689
|
+
"privateKeyMissing": "The verification method contains no privateKey \"{keyId}\"",
|
|
690
|
+
"verificationKeyMissing": "The verification key is missing from the vault for method \"{method}\"",
|
|
691
|
+
"createVerifiableCredentialFailed": "Creating the verifiable credential failed",
|
|
692
|
+
"checkingVerifiableCredentialFailed": "Checking the verifiable credential failed",
|
|
693
|
+
"createVerifiablePresentationFailed": "Creating the verifiable presentation failed",
|
|
694
|
+
"checkingVerifiablePresentationFailed": "Checking the verifiable presentation failed",
|
|
695
|
+
"createProofFailed": "Creating the signature for the data failed",
|
|
696
|
+
"methodMissing": "The verification method specified does not exist \"{method}\"",
|
|
697
|
+
"verifyProofFailed": "Verifying the signature for the data failed",
|
|
698
|
+
"revokeVerifiableCredentialsFailed": "Revoking verifiable credentials failed",
|
|
699
|
+
"unrevokeVerifiableCredentialsFailed": "Unrevoking verifiable credentials failed",
|
|
700
|
+
"invalidSubjectId": "The subject id format is invalid it must be a Url or Urn, it is \"{subjectId}\"",
|
|
701
|
+
"missingControllerToken": "The controller token is missing",
|
|
702
|
+
"identityNotFound": "The identity could not be found \"{notFoundId}\"",
|
|
703
|
+
"revocationServiceNotFound": "The revocation service could not be found in the document",
|
|
704
|
+
"didExtractionFailed": "Extracting the DID from the document id failed",
|
|
705
|
+
"transactionConfirmationTimeout": "The transaction was not confirmed in the expected time",
|
|
706
|
+
"transactionBuildFailed": "Building the transaction failed",
|
|
707
|
+
"gasStationTransactionBuildFailed": "Building the gas station transaction failed"
|
|
708
|
+
},
|
|
709
|
+
"iota": {
|
|
710
|
+
"insufficientFunds": "There were insufficient funds to complete the operation",
|
|
711
|
+
"packageNotFoundOnNetwork": "The package \"{packageId}\" was not found on the network",
|
|
712
|
+
"packageObjectError": "Failed to fetch the package object \"{packageId}\"",
|
|
713
|
+
"valueTransactionFailed": "The value transaction failed",
|
|
714
|
+
"transactionFailed": "The transaction failed",
|
|
715
|
+
"addressNotFound": "The address is missing could not be found from the seed \"{address}\"",
|
|
716
|
+
"gasStationTransactionFailed": "The gas station transaction failed",
|
|
717
|
+
"dryRunFailed": "The dry run execution failed"
|
|
718
|
+
},
|
|
719
|
+
"iotaSmartContractUtils": {
|
|
720
|
+
"migrationFailed": "Smart contract migration failed",
|
|
721
|
+
"migrateSmartContractFailed": "Failed to migrate smart contract for object \"{objectId}\"",
|
|
722
|
+
"enableMigrationFailed": "Failed to enable migration for smart contract",
|
|
723
|
+
"disableMigrationFailed": "Failed to disable migration for smart contract",
|
|
724
|
+
"migrationStateNotReadable": "Cannot read migration state for ID \"{migrationStateId}\"",
|
|
725
|
+
"isMigrationActiveFailed": "Failed to check if migration is active",
|
|
726
|
+
"invalidVersionData": "Invalid version data received from smart contract",
|
|
727
|
+
"getCurrentContractVersionNoData": "No version data returned from contract",
|
|
728
|
+
"getCurrentContractVersionFailed": "Failed to get current contract version",
|
|
729
|
+
"objectNotReadable": "Cannot read object with ID \"{objectId}\"",
|
|
730
|
+
"objectInvalidFormat": "Object \"{objectId}\" has invalid format",
|
|
731
|
+
"validateObjectVersionFailed": "Failed to validate object version for \"{objectId}\"",
|
|
732
|
+
"getContractObjectIdsFailed": "Failed to get contract object IDs for namespace \"{namespace}\" on network \"{network}\"",
|
|
733
|
+
"adminCapNotFound": "AdminCap object not found for type \"{adminCapType}\" and address \"{adminAddress}\"",
|
|
734
|
+
"migrationStateNotFound": "MigrationState object not found for type \"{migrationStateType}\" and address \"{adminAddress}\""
|
|
735
|
+
},
|
|
736
|
+
"universalResolverConnector": {
|
|
737
|
+
"resolveDocumentFailed": "Resolving the document failed \"{documentId}\""
|
|
738
|
+
},
|
|
739
|
+
"identityService": {
|
|
740
|
+
"noConnectors": "There are no connectors registered with the identity factory",
|
|
741
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the identity service \"{namespace}\"",
|
|
742
|
+
"connectorNotFound": "There is no connector with the namespace \"{namespace}\" registered with the identity factory",
|
|
743
|
+
"jwtDecodeFailed": "Decoding the JWT failed",
|
|
744
|
+
"identityCreateFailed": "Creating the identity failed",
|
|
745
|
+
"identityRemoveFailed": "Removing the identity failed \"{identity}\"",
|
|
746
|
+
"verificationMethodCreateFailed": "Creating the verification method failed for identity \"{identity}\"",
|
|
747
|
+
"verificationMethodRemoveFailed": "Removing the verification method failed \"{verificationMethodId}\"",
|
|
748
|
+
"serviceCreateFailed": "Creating the service failed for identity \"{identity}\", service \"{serviceId}\"",
|
|
749
|
+
"serviceRemoveFailed": "Removing the service failed \"{serviceId}\"",
|
|
750
|
+
"verifiableCredentialCreateFailed": "Creating the verifiable credential failed for method \"{verificationMethodId}\"",
|
|
751
|
+
"verifiableCredentialVerifyFailed": "Verifying the verifiable credential failed",
|
|
752
|
+
"verifiableCredentialRevokeFailed": "Revoking the verifiable credential failed for document \"{issuerIdentity}\" with index \"{credentialIndex}\"",
|
|
753
|
+
"verifiableCredentialUnrevokeFailed": "Unrevoking the verifiable credential failed for document \"{issuerIdentity}\" with index \"{credentialIndex}\"",
|
|
754
|
+
"verifiablePresentationCreateFailed": "Creating the verifiable presentation failed for method \"{verificationMethodId}\"",
|
|
755
|
+
"verifiablePresentationVerifyFailed": "Verifying the verifiable presentation failed",
|
|
756
|
+
"proofCreateFailed": "Creating the proof failed for method \"{verificationMethodId}\"",
|
|
757
|
+
"proofVerifyFailed": "Verifying the proof failed"
|
|
758
|
+
},
|
|
759
|
+
"identityResolverService": {
|
|
760
|
+
"noConnectors": "There are no connectors registered with the identity resolver factory",
|
|
761
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the identity service \"{namespace}\"",
|
|
762
|
+
"connectorNotFound": "There is no connector with the namespace \"{namespace}\" registered with the identity factory",
|
|
763
|
+
"identityResolveFailed": "Resolving the identity failed \"{identity}\""
|
|
764
|
+
},
|
|
765
|
+
"identityProfileService": {
|
|
766
|
+
"createFailed": "Creating the identity profile failed \"{identity}\"",
|
|
767
|
+
"getFailed": "Getting the identity profile failed",
|
|
768
|
+
"getPublicFailed": "Getting the public identity profile failed",
|
|
769
|
+
"updateFailed": "Updating the identity profile failed \"{identity}\"",
|
|
770
|
+
"notFound": "The identity profile could not be found \"{notFoundId}\"",
|
|
771
|
+
"removeFailed": "Removing the identity profile failed \"{identity}\"",
|
|
772
|
+
"listFailed": "Failed listing identities"
|
|
773
|
+
},
|
|
774
|
+
"immutableProofRestClient": {
|
|
775
|
+
"notSupportedOnClient": "The method \"{methodName}\" is not supported on the REST client, it can only be used on a server side component"
|
|
776
|
+
},
|
|
777
|
+
"immutableProofService": {
|
|
778
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the Immutable Proof service \"{namespace}\"",
|
|
779
|
+
"createFailed": "Creating the proof failed",
|
|
780
|
+
"getFailed": "Getting the proof failed",
|
|
781
|
+
"verifyFailed": "Verifying the proof failed",
|
|
782
|
+
"removeVerifiableFailed": "Removing verifiable entry from the Immutable Proof failed",
|
|
783
|
+
"proofNotFound": "The proof with the Id \"{notFoundId}\" was not found",
|
|
784
|
+
"createProofFailed": "Creating the immutable proof failed"
|
|
785
|
+
},
|
|
786
|
+
"awsMessagingSmsConnector": {
|
|
787
|
+
"sendSMSFailed": "Failed to send SMS"
|
|
788
|
+
},
|
|
789
|
+
"awsMessagingPushNotificationConnector": {
|
|
790
|
+
"applicationRegistrationFailed": "Application registration failed for applicationId {applicationId}",
|
|
791
|
+
"applicationIdNotFound": "ApplicationId not found: {applicationId}",
|
|
792
|
+
"deviceTokenCheckFailed": "Failed to check device token",
|
|
793
|
+
"deviceTokenRegisterFailed": "Failed to register device token",
|
|
794
|
+
"platformAppCreationFailed": "Failed to create platform application for applicationId {applicationId}",
|
|
795
|
+
"sendPushNotificationFailed": "Failed to send push notification",
|
|
796
|
+
"platformAppCheckFailed": "Failed to check platform application"
|
|
797
|
+
},
|
|
798
|
+
"awsMessagingEmailConnector": {
|
|
799
|
+
"sendCustomEmailFailed": "Failed to send custom email"
|
|
800
|
+
},
|
|
801
|
+
"entityStorageMessagingSmsConnector": {
|
|
802
|
+
"sendSMSFailed": "Failed to send SMS"
|
|
803
|
+
},
|
|
804
|
+
"entityStorageMessagingPushNotificationConnector": {
|
|
805
|
+
"deviceTokenRegisterFailed": "Failed to register device token",
|
|
806
|
+
"sendPushNotificationFailed": "Failed to send push notification"
|
|
807
|
+
},
|
|
808
|
+
"entityStorageMessagingEmailConnector": {
|
|
809
|
+
"sendCustomEmailFailed": "Failed to send custom email"
|
|
810
|
+
},
|
|
811
|
+
"messagingService": {
|
|
812
|
+
"notConfiguredEmailMessagingConnector": "Email messaging connector was not configured",
|
|
813
|
+
"notConfiguredPushNotificationMessagingConnector": "Push notification messaging connector was not configured",
|
|
814
|
+
"notConfiguredSmsMessagingConnector": "SMS messaging connector was not configured"
|
|
815
|
+
},
|
|
816
|
+
"messagingAdminService": {
|
|
817
|
+
"getTemplateFailed": "Failed to get template with id: \"{templateId}\" and locale: \"{locale}\""
|
|
818
|
+
},
|
|
819
|
+
"entityStorageNftConnector": {
|
|
820
|
+
"nftNotFound": "The NFT with the ID \"{notFoundId}\" was not found",
|
|
821
|
+
"notControllerTransfer": "The NFT can only be transferred by the controller",
|
|
822
|
+
"notControllerBurn": "The NFT can only be burned by the controller",
|
|
823
|
+
"notControllerUpdate": "The NFT can only be updated by the controller",
|
|
824
|
+
"mintingFailed": "Minting the NFT failed",
|
|
825
|
+
"resolvingFailed": "Resolving the NFT failed",
|
|
826
|
+
"burningFailed": "Burning the NFT failed",
|
|
827
|
+
"transferFailed": "Transferring the NFT failed",
|
|
828
|
+
"updateFailed": "Updating the NFT failed",
|
|
829
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the IOTA NFT connector \"{namespace}\""
|
|
830
|
+
},
|
|
831
|
+
"iotaNftConnector": {
|
|
832
|
+
"mintingFailed": "Minting the NFT failed",
|
|
833
|
+
"resolvingFailed": "Resolving the NFT failed",
|
|
834
|
+
"burningFailed": "Burning the NFT failed",
|
|
835
|
+
"transferFailed": "Transferring the NFT failed",
|
|
836
|
+
"updateFailed": "Updating the NFT failed",
|
|
837
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the IOTA NFT connector \"{namespace}\"",
|
|
838
|
+
"failedToGetNftId": "Failed to get NFT ID from mint response",
|
|
839
|
+
"nftNotFound": "The NFT \"{notFoundId}\" was not found",
|
|
840
|
+
"nftOwnerNftFound": "The owner for NFT \"{nftId}\" was not found",
|
|
841
|
+
"startFailed": "Failed to start the IOTA NFT connector",
|
|
842
|
+
"packageIdNotInitialised": "The package id has not been initialised.",
|
|
843
|
+
"invalidImmutableMetadata": "The immutable metadata for NFT \"{nftId}\" is invalid",
|
|
844
|
+
"invalidMetadata": "The metadata for NFT \"{nftId}\" is invalid",
|
|
845
|
+
"contractDataNotFound": "Contract data not found for network \"{network}\". Available networks: {availableNetworks}",
|
|
846
|
+
"packageNotFoundOnNetwork": "Package \"{deployedPackageId}\" not found on \"{network}\" network",
|
|
847
|
+
"deployedPackageIdRequired": "deployedPackageId is required for network operations on \"{network}\".",
|
|
848
|
+
"packageIdNotFound": "Package ID not found for network \"{network}\"",
|
|
849
|
+
"invalidGasBudget": "Invalid gas budget: {gasBudget}",
|
|
850
|
+
"noWalletConfigured": "For write operations a wallet must be configured in the connector options"
|
|
851
|
+
},
|
|
852
|
+
"iotaNftUtils": {
|
|
853
|
+
"invalidNftIdFormat": "The NFT ID \"{id}\" has an invalid format"
|
|
854
|
+
},
|
|
855
|
+
"nftService": {
|
|
856
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the NFT service \"{namespace}\"",
|
|
857
|
+
"noConnectors": "There are no connectors registered with the nft factory",
|
|
858
|
+
"mintFailed": "The minting of the NFT failed",
|
|
859
|
+
"resolveFailed": "The resolving of the NFT failed",
|
|
860
|
+
"burnFailed": "The burning of the NFT failed",
|
|
861
|
+
"transferFailed": "The transfer of the NFT failed",
|
|
862
|
+
"updateFailed": "The update of the NFT failed"
|
|
863
|
+
},
|
|
864
|
+
"dataAccessPointService": {
|
|
865
|
+
"noHandlerForAssetType": "No handler registered for asset type \"{assetType}\"",
|
|
866
|
+
"notAuthorizedToQuery": "Not authorized to query asset type \"{assetType}\"",
|
|
867
|
+
"notAuthorizedToGet": "Not authorized to get asset type \"{assetType}\" with id \"{id}\""
|
|
868
|
+
},
|
|
869
|
+
"trustHelper": {
|
|
870
|
+
"trustVerifyFailed": "Trust verification failed for action \"{action}\""
|
|
871
|
+
},
|
|
872
|
+
"policyAdministrationPointService": {
|
|
873
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the rights management components \"{namespace}\"",
|
|
874
|
+
"policyNotFound": "Policy not found with id: \"{notFoundId}\""
|
|
875
|
+
},
|
|
876
|
+
"policyDecisionPointService": {
|
|
877
|
+
"decidingFailed": "Deciding on policies for locator \"{locator}\" failed in arbiter with id: \"{arbiterId}\"",
|
|
878
|
+
"noSupportedArbiters": "No arbiters found that support the given locator: \"{locator}\""
|
|
879
|
+
},
|
|
880
|
+
"policyEnforcementPointService": {
|
|
881
|
+
"processingFailed": "Failed to process information using processor with id: \"{processorId}\", locator: \"{locator}\""
|
|
882
|
+
},
|
|
883
|
+
"policyInformationPointService": {
|
|
884
|
+
"sourceRetrieveFailed": "Failed to retrieve information from source with id: \"{sourceId}\", locator: \"{locator}\""
|
|
885
|
+
},
|
|
886
|
+
"identityPolicyInformationSource": {
|
|
887
|
+
"identityRetrievalFailed": "Failed to retrieve identity information for locator: \"{locator}\""
|
|
888
|
+
},
|
|
889
|
+
"policyNegotiationPointService": {
|
|
890
|
+
"noOfferFound": "No offer found with id: \"{offerId}\"",
|
|
891
|
+
"noNegotiatorFound": "No negotiator found which support offer id: \"{offerId}\"",
|
|
892
|
+
"noRequesterFound": "No requester found with id: \"{requesterId}\"",
|
|
893
|
+
"negotiationFailed": "Negotiation failed for offer id: \"{offerId}\"",
|
|
894
|
+
"agreementMissing": "The agreement is missing",
|
|
895
|
+
"negotiationNotFound": "No negotiation found with id: \"{notFoundId}\"",
|
|
896
|
+
"requesterNotFound": "No requester found with id: \"{notFoundId}\"",
|
|
897
|
+
"invalidState": "The negotiation is in an incorrect state \"{state}\" for negotiation with id: \"{negotiationId}\"",
|
|
898
|
+
"offerNotAccepted": "Offer with id: \"{offerId}\" was not accepted by the requester",
|
|
899
|
+
"agreementNotAccepted": "Agreement with id: \"{agreementId}\" was not accepted by the requester",
|
|
900
|
+
"noAgreementCreated": "No agreement was created for offer with id: \"{offerId}\""
|
|
901
|
+
},
|
|
902
|
+
"policyNegotiationAdminPointService": {
|
|
903
|
+
"policyNotFound": "Policy with id: \"{notFoundId}\" not found"
|
|
904
|
+
},
|
|
905
|
+
"policyExecutionPointService": {
|
|
906
|
+
"actionExecutionFailed": "Action execution failed for id: \"{actionId}\", at stage \"{stage}\", with locator: \"{locator}\""
|
|
907
|
+
},
|
|
908
|
+
"policyNegotiationPointRestClient": {
|
|
909
|
+
"notSupportedOnClient": "The method \"{methodName}\" is not supported on the REST client, it can only be used on a server side component"
|
|
910
|
+
},
|
|
911
|
+
"synchronisedStorageService": {
|
|
912
|
+
"notTrustedNode": "This method can only be called on a trusted node",
|
|
913
|
+
"entitySyncFailed": "Failed to sync synchronised entity storage connector",
|
|
914
|
+
"consolidationSyncFailed": "Failed to consolidate synchronised entity storage connector",
|
|
915
|
+
"decryptionKeyNotFound": "Decryption key not found, ensure the synchronised storage component is initialised and the decryption key is set"
|
|
916
|
+
},
|
|
917
|
+
"remoteSyncStateHelper": {
|
|
918
|
+
"finalisingSyncChangesFailed": "Failed to finalise sync changes for storage key \"{storageKey}\""
|
|
919
|
+
},
|
|
920
|
+
"blobStorageHelper": {
|
|
921
|
+
"loadBlobFailed": "Failed to load blob with id \"{blobId}\"",
|
|
922
|
+
"saveBlobFailed": "Failed to save blob",
|
|
923
|
+
"notTrustedNode": "Cannot save blob, this is not a trusted node",
|
|
924
|
+
"removeBlobFailed": "Failed to remove blob with id \"{blobId}\""
|
|
925
|
+
},
|
|
926
|
+
"entityStorageTelemetryConnector": {
|
|
927
|
+
"metricNotFound": "The metric could not be found \"{notFoundId}\"",
|
|
928
|
+
"metricAlreadyExists": "The metric already exists \"{existingId}\"",
|
|
929
|
+
"counterIncOnly": "A counter metric can only be incremented, or added to with an integer",
|
|
930
|
+
"upDownCounterIncOrDecOnly": "An up/down counter metric can only be incremented, decremented or adjusted with an integer",
|
|
931
|
+
"gaugeNoIncDec": "A gauge can not be incremented or decremented"
|
|
932
|
+
},
|
|
933
|
+
"silentTelemetryConnector": {
|
|
934
|
+
"notSupported": "The method \"{methodName}\" is not supported on silent telemetry connector."
|
|
935
|
+
},
|
|
936
|
+
"trustService": {
|
|
937
|
+
"notVerified": "Payload verification failed",
|
|
938
|
+
"noGeneratorsRegistered": "No trust generators are registered in the factory"
|
|
939
|
+
},
|
|
940
|
+
"jwtVerifiableCredentialVerifier": {
|
|
941
|
+
"tokenMissingCredential": "The JWT token does not contain a verifiable credential.",
|
|
942
|
+
"tokenMissingIssuer": "The verifiable credential in the JWT does not contain an issuer.",
|
|
943
|
+
"tokenExpired": "The JWT token has expired.",
|
|
944
|
+
"tokenMissingSubject": "The verifiable credential in the JWT does not contain a subject.",
|
|
945
|
+
"tokenDecodingFailed": "Failed to decode the JWT token."
|
|
946
|
+
},
|
|
947
|
+
"entityStorageVaultConnector": {
|
|
948
|
+
"keyAlreadyExists": "The key \"{existingId}\" already exists in the vault",
|
|
949
|
+
"keyNotFound": "The key \"{notFoundId}\" was not found in the vault",
|
|
950
|
+
"secretNotFound": "The secret \"{notFoundId}\" was not found in the vault",
|
|
951
|
+
"unsupportedKeyType": "The key type \"{keyType}\" is not supported",
|
|
952
|
+
"keyTypeMismatch": "The key type \"{keyType}\" does not match the requested encryption method \"{encryptionType}\""
|
|
953
|
+
},
|
|
954
|
+
"hashicorpVaultConnector": {
|
|
955
|
+
"setSecretFailed": "Failed to set secret \"{name}\"",
|
|
956
|
+
"removeSecretFailed": "Failed to remove secret \"{name}\"",
|
|
957
|
+
"getSecretVersionsFailed": "Failed to get secret versions \"{name}\"",
|
|
958
|
+
"hashicorpVaultConnectionFailed": "Failed to connect to Hashicorp Vault",
|
|
959
|
+
"createKeyFailed": "Failed to create key \"{name, type}\"",
|
|
960
|
+
"unsupportedKeyType": "Unsupported key type \"{type}\"",
|
|
961
|
+
"removeKeyFailed": "Failed to remove key \"{name}\"",
|
|
962
|
+
"updateKeyConfigFailed": "Failed to update key config \"{name}\"",
|
|
963
|
+
"addKeyFailed": "Failed to add key \"{name, type}\"",
|
|
964
|
+
"backupKeyNotFound": "Backup key \"{notFoundId}\" not found",
|
|
965
|
+
"backupKeyFailed": "Failed to backup key \"{name}\"",
|
|
966
|
+
"restoreKeyFailed": "Failed to restore key \"{name}\"",
|
|
967
|
+
"importKeyFailed": "Failed to restore key \"{name}\"",
|
|
968
|
+
"exportKeyFailed": "Failed to export key \"{name}\" with keyPath \"{keyPath}\"",
|
|
969
|
+
"getKeyDeleteConfigurationFailed": "Failed to get key delete configuration \"{name}\"",
|
|
970
|
+
"exportKeyNotFound": "Export key with name \"{notFoundId}\" not found",
|
|
971
|
+
"versionsNotFound": "Versions for key \"{notFoundId}\" not found",
|
|
972
|
+
"keyNotFound": "The key \"{notFoundId}\" was not found in the vault",
|
|
973
|
+
"secretNotFound": "The secret \"{notFoundId}\" was not found in the vault",
|
|
974
|
+
"getKeyFailed": "Failed to get key \"{name}\"",
|
|
975
|
+
"signDataFailed": "Failed to sign data \"{name}\"",
|
|
976
|
+
"invalidSignResponse": "Invalid sign response \"{name}\"",
|
|
977
|
+
"verifyDataFailed": "Failed to verify data \"{name}\"",
|
|
978
|
+
"encryptDataFailed": "Failed to encrypt data \"{name, encryptionType}\"",
|
|
979
|
+
"decryptDataFailed": "Failed to decrypt data \"{name, encryptionType}\"",
|
|
980
|
+
"invalidDecryptResponse": "Invalid decrypt response \"{name, encryptionType}\"",
|
|
981
|
+
"invalidEncryptResponse": "Invalid encrypt response \"{name, encryptionType}\"",
|
|
982
|
+
"keyAlreadyExists": "Key \"{existingId}\" already exists",
|
|
983
|
+
"invalidReadKeyResponse": "Invalid read key response \"{name}\"",
|
|
984
|
+
"renameKeyFailed": "Failed to rename key from \"{name}\" to \"{newName}\"",
|
|
985
|
+
"keyTypeMismatch": "The key type \"{keyType}\" does not match the requested encryption method \"{encryptionType}\""
|
|
986
|
+
},
|
|
987
|
+
"entityStorageVerifiableStorageConnector": {
|
|
988
|
+
"verifiableStorageNotFound": "The verifiable item with the Id \"{notFoundId}\" was not found",
|
|
989
|
+
"creatingFailed": "Creating the item failed",
|
|
990
|
+
"updatingFailed": "Updating the item failed",
|
|
991
|
+
"gettingFailed": "Getting the item failed",
|
|
992
|
+
"removingFailed": "Removing the item failed",
|
|
993
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the IOTA Verifiable Storage connector \"{namespace}\"",
|
|
994
|
+
"notInAllowList": "The user is not in the allow list",
|
|
995
|
+
"notCreator": "Only the creator can remove the verifiable item",
|
|
996
|
+
"allowListTooBig": "The number of items in the allow list is larger than the maximum allowed"
|
|
997
|
+
},
|
|
998
|
+
"iotaVerifiableStorageConnector": {
|
|
999
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the IOTA Verifiable Storage connector \"{namespace}\"",
|
|
1000
|
+
"creatingFailed": "Creating the verifiable item failed",
|
|
1001
|
+
"updatingFailed": "Updating the verifiable item failed",
|
|
1002
|
+
"gettingFailed": "Getting the verifiable item failed",
|
|
1003
|
+
"removingFailed": "Removing the verifiable item failed",
|
|
1004
|
+
"updateFailed": "Updating the verifiable item failed",
|
|
1005
|
+
"packageIdNotFound": "Package ID not found for network \"{network}\"",
|
|
1006
|
+
"storingTransactionFailed": "The transaction to store the data failed",
|
|
1007
|
+
"removingTransactionFailed": "The transaction to remove the data failed",
|
|
1008
|
+
"objectNotFound": "The object was not found",
|
|
1009
|
+
"objectIdNotFound": "The object ID was not found in the verifiable item for namespace \"{namespace}\"",
|
|
1010
|
+
"connectorNotStarted": "Please call start() before using this connector. Package ID: \"{packageId}\" is missing.",
|
|
1011
|
+
"startFailed": "Failed to start the IOTA Verifiable Storage connector.",
|
|
1012
|
+
"invalidGasBudget": "The gas budget must be greater than 0",
|
|
1013
|
+
"notInAllowList": "The user is not in the allow list",
|
|
1014
|
+
"notCreator": "Only the creator can remove the verifiable item",
|
|
1015
|
+
"allowListTooBig": "The number of items in the allow list is larger than the maximum allowed",
|
|
1016
|
+
"contractDataNotFound": "Contract data not found for network \"{network}\". Available networks: {availableNetworks}",
|
|
1017
|
+
"deployedPackageIdRequired": "deployedPackageId is required for network operations on \"{network}\".",
|
|
1018
|
+
"packageNotFoundOnNetwork": "Package \"{deployedPackageId}\" not found on \"{network}\" network"
|
|
1019
|
+
},
|
|
1020
|
+
"iotaVerifiableStorageUtils": {
|
|
1021
|
+
"invalidVerifiableStorageIdFormat": "The verifiable storage ID \"{id}\" has an invalid format"
|
|
1022
|
+
},
|
|
1023
|
+
"verifiableStorageService": {
|
|
1024
|
+
"namespaceMismatch": "The namespace in the urn \"{id}\" does not match the namespace of the Verifiable Storage service \"{namespace}\"",
|
|
1025
|
+
"noConnectors": "There are no connectors registered with the Verifiable Storage factory",
|
|
1026
|
+
"createFailed": "The creating of the Verifiable Storage failed",
|
|
1027
|
+
"updateFailed": "The updating of the Verifiable Storage failed",
|
|
1028
|
+
"getFailed": "The retrieving of the Verifiable Storage failed",
|
|
1029
|
+
"removeFailed": "The removing of the Verifiable Storage failed"
|
|
1030
|
+
},
|
|
1031
|
+
"entityStorageWalletConnector": {
|
|
1032
|
+
"insufficientFunds": "There are insufficient funds in the wallet."
|
|
1033
|
+
},
|
|
1034
|
+
"iotaWalletConnector": {
|
|
1035
|
+
"transferFailed": "The wallet transfer failed."
|
|
1036
|
+
},
|
|
1037
|
+
"iotaFaucetConnector": {
|
|
1038
|
+
"fundingFailed": "Fund the address from faucet failed",
|
|
1039
|
+
"faucetRateLimit": "Faucet rate limit exceeded"
|
|
1040
|
+
},
|
|
1041
|
+
"fastifyWebServer": {
|
|
1042
|
+
"startFailed": "The Web Server failed to start",
|
|
1043
|
+
"badRequest": "The web server could not handle the request",
|
|
1044
|
+
"noRestProcessors": "You must configure at least one REST processor",
|
|
1045
|
+
"noSocketProcessors": "You must configure at least one socket processor",
|
|
1046
|
+
"postProcessorError": "There was a failure after in a post processor for route \"{route}\""
|
|
1047
|
+
},
|
|
1048
|
+
"restRouteProcessor": {
|
|
1049
|
+
"routeNotFound": "The web server could not find the REST route \"{notFoundId}\""
|
|
1050
|
+
},
|
|
1051
|
+
"socketRouteProcessor": {
|
|
1052
|
+
"routeNotFound": "The web server could not find the socket route \"{notFoundId}\""
|
|
1053
|
+
},
|
|
1054
|
+
"jsonLdMimeTypeProcessor": {
|
|
1055
|
+
"invalidJsonLd": "The JSON-LD content is invalid or missing '@context'."
|
|
1056
|
+
},
|
|
1057
|
+
"loggingProcessor": {
|
|
1058
|
+
"responseMessage": "<=== {statusCode} {method} {requestUrl} duration: {elapsedMicroSeconds}µs"
|
|
1059
|
+
},
|
|
1060
|
+
"informationRestClient": {
|
|
1061
|
+
"notSupportedOnClient": "The method \"{methodName}\" is not supported on the REST client, it can only be used on a server side component"
|
|
1062
|
+
}
|
|
1063
|
+
},
|
|
1064
|
+
"node": {
|
|
1065
|
+
"extensionLoading": "Loading Extension",
|
|
1066
|
+
"extensionInitialisingEngine": "Initialising engine for extension \"{extension}\"",
|
|
1067
|
+
"extensionInitialisingEngineServer": "Initialising engine server for extension \"{extension}\"",
|
|
1068
|
+
"extensionShutdown": "Shutdown extension \"{extension}\"",
|
|
1069
|
+
"extendingEngine": "Extending Engine",
|
|
1070
|
+
"extendingEngineServer": "Extending Engine Server",
|
|
1071
|
+
"extensionSecurityWarning": "SECURITY WARNING: Loading extension from external URL: {url}",
|
|
1072
|
+
"extensionNpmInstalling": "Installing npm extension",
|
|
1073
|
+
"extensionHttpsDownloading": "Downloading HTTPS extension",
|
|
1074
|
+
"extensionCacheExpired": "Cache expired for extension: {url}",
|
|
1075
|
+
"extensionForceRefresh": "Force refresh enabled for extension: {url}",
|
|
1076
|
+
"cli": {
|
|
1077
|
+
"commands": {
|
|
1078
|
+
"command": "Command",
|
|
1079
|
+
"help": {
|
|
1080
|
+
"description": "Display help information about CLI commands",
|
|
1081
|
+
"labels": {
|
|
1082
|
+
"commands": "All the commands available are listed below, for more information use the --help option with a specific command.",
|
|
1083
|
+
"example": "Example",
|
|
1084
|
+
"optional": "optional",
|
|
1085
|
+
"required": "required",
|
|
1086
|
+
"default": "default",
|
|
1087
|
+
"options": "options"
|
|
1088
|
+
}
|
|
1089
|
+
},
|
|
1090
|
+
"bootstrap-legacy": {
|
|
1091
|
+
"description": "Bootstrap in legacy mode for backwards compatibility, **will be deprecated in future versions**",
|
|
1092
|
+
"example": "bootstrap-legacy --load-env=\"./.env.bootstrap-legacy\"",
|
|
1093
|
+
"params": {
|
|
1094
|
+
"load-env": {
|
|
1095
|
+
"description": "Comma separated list of paths to .env files to read input parameters from."
|
|
1096
|
+
}
|
|
1097
|
+
},
|
|
1098
|
+
"labels": {
|
|
1099
|
+
"nodeIdentityCreate": "Creating node identity",
|
|
1100
|
+
"nodeAuthKeyCreate": "Creating node auth key",
|
|
1101
|
+
"vcAuthenticationMethodCreate": "Creating VC authentication method for node identity",
|
|
1102
|
+
"synchronisedStorageKeyAdd": "Adding synchronised storage key for node identity",
|
|
1103
|
+
"nodeIdentitySet": "Setting node identity",
|
|
1104
|
+
"nodeTenantCreate": "Creating node tenant",
|
|
1105
|
+
"nodeTenantSet": "Setting node tenant",
|
|
1106
|
+
"organisationCreate": "Creating organisation identity",
|
|
1107
|
+
"blobStorageKeyCreate": "Creating blob storage encryption key for organisation identity",
|
|
1108
|
+
"attestationMethodCreate": "Creating attestation method for organisation identity",
|
|
1109
|
+
"immutableProofMethodCreate": "Creating immutable proof method for organisation identity",
|
|
1110
|
+
"adminIdentityCreate": "Creating admin user identity",
|
|
1111
|
+
"adminUserCreate": "Creating admin user"
|
|
1112
|
+
}
|
|
1113
|
+
},
|
|
1114
|
+
"identity-create": {
|
|
1115
|
+
"description": "Create an identity",
|
|
1116
|
+
"example": "identity-create --mnemonic=\"...\" --fund-wallet=true",
|
|
1117
|
+
"params": {
|
|
1118
|
+
"mnemonic": {
|
|
1119
|
+
"description": "The mnemonic phrase to use for the identity. If not provided, a random mnemonic will be generated."
|
|
1120
|
+
},
|
|
1121
|
+
"identity": {
|
|
1122
|
+
"description": "The DID of the identity to create. If not provided, a new DID will be generated."
|
|
1123
|
+
},
|
|
1124
|
+
"controller": {
|
|
1125
|
+
"description": "The controller DID for the identity. If not provided, the identity will be its own controller."
|
|
1126
|
+
},
|
|
1127
|
+
"fund-wallet": {
|
|
1128
|
+
"description": "Whether to fund the wallet associated with the identity from a faucet."
|
|
1129
|
+
},
|
|
1130
|
+
"load-env": {
|
|
1131
|
+
"description": "Comma separated list of paths to .env files to read input parameters from."
|
|
1132
|
+
},
|
|
1133
|
+
"output-json": {
|
|
1134
|
+
"description": "Path to a .json file to store the command output."
|
|
1135
|
+
},
|
|
1136
|
+
"output-env": {
|
|
1137
|
+
"description": "Path to a .env file to store the command output."
|
|
1138
|
+
},
|
|
1139
|
+
"output-env-prefix": {
|
|
1140
|
+
"description": "Prefix to use for variables in the output .env file."
|
|
1141
|
+
}
|
|
1142
|
+
},
|
|
1143
|
+
"labels": {
|
|
1144
|
+
"mnemonic": "Mnemonic",
|
|
1145
|
+
"processingMnemonic": "Processing mnemonic",
|
|
1146
|
+
"readingMnemonic": "Reading mnemonic",
|
|
1147
|
+
"storingMnemonic": "Storing mnemonic",
|
|
1148
|
+
"existingMnemonic": "Mnemonic already exists",
|
|
1149
|
+
"noExistingMnemonic": "No existing mnemonic found",
|
|
1150
|
+
"generatingMnemonic": "Generating mnemonic",
|
|
1151
|
+
"processingIdentity": "Processing identity",
|
|
1152
|
+
"resolvingIdentity": "Resolving identity",
|
|
1153
|
+
"existingIdentity": "Identity already exists",
|
|
1154
|
+
"noIdentityFound": "No identity found",
|
|
1155
|
+
"creatingIdentity": "Creating identity",
|
|
1156
|
+
"createdIdentity": "Created identity",
|
|
1157
|
+
"fundingWallet": "Funding wallet",
|
|
1158
|
+
"addressIndex": "Address Index",
|
|
1159
|
+
"addingTokens": "Adding tokens to address \"{address}\"",
|
|
1160
|
+
"explorer": "Explorer",
|
|
1161
|
+
"walletAddress": "Wallet Address",
|
|
1162
|
+
"did": "DID"
|
|
1163
|
+
}
|
|
1164
|
+
},
|
|
1165
|
+
"identity-import": {
|
|
1166
|
+
"description": "Import an identity",
|
|
1167
|
+
"example": "identity-import --identity=\"did:iota:...\" --mnemonic=\"...\"",
|
|
1168
|
+
"params": {
|
|
1169
|
+
"identity": {
|
|
1170
|
+
"description": "The DID of the identity to import."
|
|
1171
|
+
},
|
|
1172
|
+
"mnemonic": {
|
|
1173
|
+
"description": "The mnemonic phrase to use for the identity."
|
|
1174
|
+
},
|
|
1175
|
+
"load-env": {
|
|
1176
|
+
"description": "Comma separated list of paths to .env files to read input parameters from."
|
|
1177
|
+
}
|
|
1178
|
+
},
|
|
1179
|
+
"labels": {
|
|
1180
|
+
"resolvingIdentity": "Resolving identity",
|
|
1181
|
+
"storingMnemonic": "Storing mnemonic"
|
|
1182
|
+
}
|
|
1183
|
+
},
|
|
1184
|
+
"identity-verifiable-credential-create": {
|
|
1185
|
+
"description": "Create a verifiable credential",
|
|
1186
|
+
"example": "identity-verifiable-credential-create --identity=\"did:iota:....\" --verification-method-id=\"my-id\" --subject-json=\"./subject.json\"",
|
|
1187
|
+
"params": {
|
|
1188
|
+
"identity": {
|
|
1189
|
+
"description": "The DID of the identity to use to create the credential."
|
|
1190
|
+
},
|
|
1191
|
+
"verification-method-id": {
|
|
1192
|
+
"description": "The ID of the verification method to use to create the credential."
|
|
1193
|
+
},
|
|
1194
|
+
"controller": {
|
|
1195
|
+
"description": "The controller DID for the identity. If not provided, the identity will be its own controller."
|
|
1196
|
+
},
|
|
1197
|
+
"subject-json": {
|
|
1198
|
+
"description": "The subject JSON file to load."
|
|
1199
|
+
},
|
|
1200
|
+
"credential-id": {
|
|
1201
|
+
"description": "The id of the verifiable credential."
|
|
1202
|
+
},
|
|
1203
|
+
"expiration-date": {
|
|
1204
|
+
"description": "The expiration date of the verifiable credential."
|
|
1205
|
+
},
|
|
1206
|
+
"load-env": {
|
|
1207
|
+
"description": "Comma separated list of paths to .env files to read input parameters from."
|
|
1208
|
+
},
|
|
1209
|
+
"output-json": {
|
|
1210
|
+
"description": "Path to a .json file to store the command output."
|
|
1211
|
+
},
|
|
1212
|
+
"output-env": {
|
|
1213
|
+
"description": "Path to a .env file to store the command output."
|
|
1214
|
+
},
|
|
1215
|
+
"output-env-prefix": {
|
|
1216
|
+
"description": "Prefix to use for variables in the output .env file."
|
|
1217
|
+
}
|
|
1218
|
+
},
|
|
1219
|
+
"labels": {
|
|
1220
|
+
"creating": "Creating verifiable credential",
|
|
1221
|
+
"created": "Created verifiable credential",
|
|
1222
|
+
"jwtToken": "JWT Token"
|
|
1223
|
+
}
|
|
1224
|
+
},
|
|
1225
|
+
"identity-verification-method-import": {
|
|
1226
|
+
"description": "Import an identity verification method",
|
|
1227
|
+
"example": "identity-verification-method-import --identity=\"did:iota:....\" --verification-method-type=\"verificationMethod\" --verification-method-id=\"my-key-1\" ----private-key-hex=\"15...a2\"",
|
|
1228
|
+
"params": {
|
|
1229
|
+
"identity": {
|
|
1230
|
+
"description": "The DID of the identity to import the verification method to."
|
|
1231
|
+
},
|
|
1232
|
+
"verification-method-type": {
|
|
1233
|
+
"description": "The type of verification method to import."
|
|
1234
|
+
},
|
|
1235
|
+
"verification-method-id": {
|
|
1236
|
+
"description": "The ID of the verification method to import."
|
|
1237
|
+
},
|
|
1238
|
+
"controller": {
|
|
1239
|
+
"description": "The controller DID for the identity. If not provided, the identity will be its own controller."
|
|
1240
|
+
},
|
|
1241
|
+
"private-key-hex": {
|
|
1242
|
+
"description": "The private key in hex format."
|
|
1243
|
+
},
|
|
1244
|
+
"load-env": {
|
|
1245
|
+
"description": "Comma separated list of paths to .env files to read input parameters from."
|
|
1246
|
+
}
|
|
1247
|
+
},
|
|
1248
|
+
"labels": {
|
|
1249
|
+
"resolvingIdentity": "Resolving identity",
|
|
1250
|
+
"importing": "Importing verification method",
|
|
1251
|
+
"imported": "Imported verification method"
|
|
1252
|
+
}
|
|
1253
|
+
},
|
|
1254
|
+
"identity-verification-method-create": {
|
|
1255
|
+
"description": "Create an identity verification method",
|
|
1256
|
+
"example": "identity-verification-method-create --identity=\"did:iota:....\" --verification-method-type=\"verificationMethod\" --verification-method-id=\"my-key-1\" --controller=\"did:iota:....\"",
|
|
1257
|
+
"params": {
|
|
1258
|
+
"identity": {
|
|
1259
|
+
"description": "The DID of the identity to add the verification method to."
|
|
1260
|
+
},
|
|
1261
|
+
"verification-method-type": {
|
|
1262
|
+
"description": "The type of verification method to add."
|
|
1263
|
+
},
|
|
1264
|
+
"verification-method-id": {
|
|
1265
|
+
"description": "The ID of the verification method to add."
|
|
1266
|
+
},
|
|
1267
|
+
"controller": {
|
|
1268
|
+
"description": "The controller DID for the identity. If not provided, the identity will be its own controller."
|
|
1269
|
+
},
|
|
1270
|
+
"overwrite-mode": {
|
|
1271
|
+
"description": "The mode to use when a verification method with the same ID already exists."
|
|
1272
|
+
},
|
|
1273
|
+
"load-env": {
|
|
1274
|
+
"description": "Comma separated list of paths to .env files to read input parameters from."
|
|
1275
|
+
},
|
|
1276
|
+
"output-json": {
|
|
1277
|
+
"description": "Path to a .json file to store the command output."
|
|
1278
|
+
},
|
|
1279
|
+
"output-env": {
|
|
1280
|
+
"description": "Path to a .env file to store the command output."
|
|
1281
|
+
},
|
|
1282
|
+
"output-env-prefix": {
|
|
1283
|
+
"description": "Prefix to use for variables in the output .env file."
|
|
1284
|
+
}
|
|
1285
|
+
},
|
|
1286
|
+
"labels": {
|
|
1287
|
+
"resolvingIdentity": "Resolving identity",
|
|
1288
|
+
"skipping": "The verification method with ID already exists, skipping creation",
|
|
1289
|
+
"creatingVerificationMethod": "Creating verification method",
|
|
1290
|
+
"createdVerificationMethod": "Created verification method",
|
|
1291
|
+
"verificationMethodId": "Verification Method ID",
|
|
1292
|
+
"verificationMethodType": "Verification Method Type",
|
|
1293
|
+
"kid": "Key Id",
|
|
1294
|
+
"privateKeyBase64Url": "Private Key Base64Url",
|
|
1295
|
+
"publicKeyBase64Url": "Public Key Base64Url",
|
|
1296
|
+
"privateKeyBase64": "Private Key Base64",
|
|
1297
|
+
"publicKeyBase64": "Public Key Base64",
|
|
1298
|
+
"privateKeyHex": "Private Key Hex",
|
|
1299
|
+
"publicKeyHex": "Public Key Hex"
|
|
1300
|
+
}
|
|
1301
|
+
},
|
|
1302
|
+
"node-set-identity": {
|
|
1303
|
+
"description": "Set the node identity",
|
|
1304
|
+
"example": "node-set-identity --identity=\"did:iota...\"",
|
|
1305
|
+
"params": {
|
|
1306
|
+
"identity": {
|
|
1307
|
+
"description": "The identity to set in the node."
|
|
1308
|
+
},
|
|
1309
|
+
"load-env": {
|
|
1310
|
+
"description": "Comma separated list of paths to .env files to read input parameters from."
|
|
1311
|
+
}
|
|
1312
|
+
},
|
|
1313
|
+
"labels": {
|
|
1314
|
+
"stored": "The node identity has been stored"
|
|
1315
|
+
}
|
|
1316
|
+
},
|
|
1317
|
+
"tenant-create": {
|
|
1318
|
+
"description": "Create a tenant with associated api key",
|
|
1319
|
+
"example": "tenant-create --tenant-id=\"0011..aabb\" --api-key=\"aabb..0099\" --label=\"My Tenant\"",
|
|
1320
|
+
"params": {
|
|
1321
|
+
"tenant-id": {
|
|
1322
|
+
"description": "The tenant ID to add. If not provided a random tenant id will be generated."
|
|
1323
|
+
},
|
|
1324
|
+
"api-key": {
|
|
1325
|
+
"description": "The API key to associate with the tenant id. If not provided, a random key will be generated."
|
|
1326
|
+
},
|
|
1327
|
+
"label": {
|
|
1328
|
+
"description": "A descriptive label for the tenant."
|
|
1329
|
+
},
|
|
1330
|
+
"load-env": {
|
|
1331
|
+
"description": "Comma separated list of paths to .env files to read input parameters from."
|
|
1332
|
+
},
|
|
1333
|
+
"output-json": {
|
|
1334
|
+
"description": "Path to a .json file to store the command output."
|
|
1335
|
+
},
|
|
1336
|
+
"output-env": {
|
|
1337
|
+
"description": "Path to a .env file to store the command output."
|
|
1338
|
+
},
|
|
1339
|
+
"output-env-prefix": {
|
|
1340
|
+
"description": "Prefix to use for variables in the output .env file."
|
|
1341
|
+
}
|
|
1342
|
+
},
|
|
1343
|
+
"labels": {
|
|
1344
|
+
"creating": "Creating tenant",
|
|
1345
|
+
"tenantId": "Tenant ID",
|
|
1346
|
+
"apiKey": "API Key",
|
|
1347
|
+
"label": "Label"
|
|
1348
|
+
}
|
|
1349
|
+
},
|
|
1350
|
+
"tenant-import": {
|
|
1351
|
+
"description": "Import a tenant with associated api key",
|
|
1352
|
+
"example": "tenant-import --tenant-id=\"0011..aabb\" --api-key=\"aabb..0099\" --label=\"My Tenant\"",
|
|
1353
|
+
"params": {
|
|
1354
|
+
"tenant-id": {
|
|
1355
|
+
"description": "The tenant ID to import."
|
|
1356
|
+
},
|
|
1357
|
+
"api-key": {
|
|
1358
|
+
"description": "The API key to associate with the tenant id."
|
|
1359
|
+
},
|
|
1360
|
+
"label": {
|
|
1361
|
+
"description": "A descriptive label for the tenant."
|
|
1362
|
+
},
|
|
1363
|
+
"load-env": {
|
|
1364
|
+
"description": "Comma separated list of paths to .env files to read input parameters from."
|
|
1365
|
+
}
|
|
1366
|
+
},
|
|
1367
|
+
"labels": {
|
|
1368
|
+
"importing": "Importing tenant",
|
|
1369
|
+
"imported": "Imported tenant"
|
|
1370
|
+
}
|
|
1371
|
+
},
|
|
1372
|
+
"node-set-tenant": {
|
|
1373
|
+
"description": "Set the node tenant",
|
|
1374
|
+
"example": "node-set-tenant --tenant-id=\"0011..aabb\"",
|
|
1375
|
+
"params": {
|
|
1376
|
+
"tenant-id": {
|
|
1377
|
+
"description": "The tenant ID to add. If not provided a random tenant id will be generated."
|
|
1378
|
+
},
|
|
1379
|
+
"load-env": {
|
|
1380
|
+
"description": "Comma separated list of paths to .env files to read input parameters from."
|
|
1381
|
+
}
|
|
1382
|
+
},
|
|
1383
|
+
"labels": {
|
|
1384
|
+
"stored": "The tenant id has been stored"
|
|
1385
|
+
}
|
|
1386
|
+
},
|
|
1387
|
+
"user-create": {
|
|
1388
|
+
"description": "Create a user",
|
|
1389
|
+
"example": "user-create --user-identity=\"did:iota:....\" --organization-identity=\"did:iota:....\" --email=\"bob@examples.com\" --password=\"pass1234\" --givenName=\"Bob\" --familyName=\"Smith\"",
|
|
1390
|
+
"params": {
|
|
1391
|
+
"user-identity": {
|
|
1392
|
+
"description": "The DID to associate the user with."
|
|
1393
|
+
},
|
|
1394
|
+
"organization-identity": {
|
|
1395
|
+
"description": "The organization DID to associate the user with."
|
|
1396
|
+
},
|
|
1397
|
+
"email": {
|
|
1398
|
+
"description": "The email address of the user."
|
|
1399
|
+
},
|
|
1400
|
+
"password": {
|
|
1401
|
+
"description": "The password for the user."
|
|
1402
|
+
},
|
|
1403
|
+
"given-name": {
|
|
1404
|
+
"description": "The given name of the user."
|
|
1405
|
+
},
|
|
1406
|
+
"family-name": {
|
|
1407
|
+
"description": "The family name of the user."
|
|
1408
|
+
},
|
|
1409
|
+
"overwrite-mode": {
|
|
1410
|
+
"description": "The mode to use when a user with the same identity already exists."
|
|
1411
|
+
},
|
|
1412
|
+
"load-env": {
|
|
1413
|
+
"description": "Comma separated list of paths to .env files to read input parameters from."
|
|
1414
|
+
},
|
|
1415
|
+
"output-json": {
|
|
1416
|
+
"description": "Path to a .json file to store the command output."
|
|
1417
|
+
},
|
|
1418
|
+
"output-env": {
|
|
1419
|
+
"description": "Path to a .env file to store the command output."
|
|
1420
|
+
},
|
|
1421
|
+
"output-env-prefix": {
|
|
1422
|
+
"description": "Prefix to use for variables in the output .env file."
|
|
1423
|
+
}
|
|
1424
|
+
},
|
|
1425
|
+
"labels": {
|
|
1426
|
+
"creating": "Creating user",
|
|
1427
|
+
"storingUser": "Storing user",
|
|
1428
|
+
"storingProfile": "Storing profile",
|
|
1429
|
+
"userCreated": "User created",
|
|
1430
|
+
"skipping": "The user with ID already exists, skipping creation",
|
|
1431
|
+
"overwriting": "Overwriting existing user with ID"
|
|
1432
|
+
}
|
|
1433
|
+
},
|
|
1434
|
+
"vault-key-create": {
|
|
1435
|
+
"description": "Create a vault key for an identity",
|
|
1436
|
+
"example": "vault-key-create --identity=\"did:iota:....\" --key-id=\"my-key\" --type=\"Ed25519\"",
|
|
1437
|
+
"params": {
|
|
1438
|
+
"identity": {
|
|
1439
|
+
"description": "The DID to associate the key with."
|
|
1440
|
+
},
|
|
1441
|
+
"key-id": {
|
|
1442
|
+
"description": "The ID of the key."
|
|
1443
|
+
},
|
|
1444
|
+
"key-type": {
|
|
1445
|
+
"description": "The type of the key."
|
|
1446
|
+
},
|
|
1447
|
+
"overwrite-mode": {
|
|
1448
|
+
"description": "The mode to use when a key with the same id already exists."
|
|
1449
|
+
},
|
|
1450
|
+
"load-env": {
|
|
1451
|
+
"description": "Comma separated list of paths to .env files to read input parameters from."
|
|
1452
|
+
},
|
|
1453
|
+
"output-json": {
|
|
1454
|
+
"description": "Path to a .json file to store the command output."
|
|
1455
|
+
},
|
|
1456
|
+
"output-env": {
|
|
1457
|
+
"description": "Path to a .env file to store the command output."
|
|
1458
|
+
},
|
|
1459
|
+
"output-env-prefix": {
|
|
1460
|
+
"description": "Prefix to use for variables in the output .env file."
|
|
1461
|
+
}
|
|
1462
|
+
},
|
|
1463
|
+
"labels": {
|
|
1464
|
+
"creating": "Creating key",
|
|
1465
|
+
"created": "Created key",
|
|
1466
|
+
"skipping": "The key with ID already exists, skipping creation",
|
|
1467
|
+
"overwriting": "Overwriting existing key with ID",
|
|
1468
|
+
"keyId": "Key ID",
|
|
1469
|
+
"keyType": "Key Type",
|
|
1470
|
+
"privateKeyBase64": "Private Key Base64",
|
|
1471
|
+
"publicKeyBase64": "Public Key Base64",
|
|
1472
|
+
"privateKeyHex": "Private Key Hex",
|
|
1473
|
+
"publicKeyHex": "Public Key Hex"
|
|
1474
|
+
}
|
|
1475
|
+
},
|
|
1476
|
+
"vault-key-import": {
|
|
1477
|
+
"description": "Import a vault key for an identity",
|
|
1478
|
+
"example": "vault-key-import --identity=\"did:iota:....\" --key-id=\"my-key\" --key-type=Ed25519 --private-key-hex=\"15...a2\"",
|
|
1479
|
+
"params": {
|
|
1480
|
+
"identity": {
|
|
1481
|
+
"description": "The DID to associate the key with."
|
|
1482
|
+
},
|
|
1483
|
+
"key-id": {
|
|
1484
|
+
"description": "The ID of the key."
|
|
1485
|
+
},
|
|
1486
|
+
"key-type": {
|
|
1487
|
+
"description": "The type of the key."
|
|
1488
|
+
},
|
|
1489
|
+
"private-key-hex": {
|
|
1490
|
+
"description": "The private key in hex format."
|
|
1491
|
+
},
|
|
1492
|
+
"load-env": {
|
|
1493
|
+
"description": "Comma separated list of paths to .env files to read input parameters from."
|
|
1494
|
+
}
|
|
1495
|
+
},
|
|
1496
|
+
"labels": {
|
|
1497
|
+
"importing": "Importing key",
|
|
1498
|
+
"imported": "Imported key"
|
|
1499
|
+
}
|
|
1500
|
+
}
|
|
1501
|
+
}
|
|
1502
|
+
}
|
|
1503
|
+
},
|
|
1504
|
+
"errorNames": {
|
|
1505
|
+
"error": "Error",
|
|
1506
|
+
"generalError": "General",
|
|
1507
|
+
"guardError": "Guard",
|
|
1508
|
+
"conflictError": "Conflict",
|
|
1509
|
+
"notFoundError": "Not Found",
|
|
1510
|
+
"notSupportedError": "Not Supported",
|
|
1511
|
+
"alreadyExistsError": "Already Exists",
|
|
1512
|
+
"notImplementedError": "Not Implemented",
|
|
1513
|
+
"validationError": "Validation",
|
|
1514
|
+
"unprocessableError": "Unprocessable",
|
|
1515
|
+
"unauthorizedError": "Unauthorized"
|
|
1516
|
+
},
|
|
1517
|
+
"validation": {
|
|
1518
|
+
"defaultFieldName": "The field"
|
|
1519
|
+
},
|
|
1520
|
+
"errorMessages": {
|
|
1521
|
+
"fetch": "Fetch"
|
|
1522
|
+
},
|
|
1523
|
+
"warn": {
|
|
1524
|
+
"common": {
|
|
1525
|
+
"devOnlyTool": "This tool is intended to be used for development purposes, it is not recommended for use in production scenarios."
|
|
1526
|
+
},
|
|
1527
|
+
"backgroundTaskService": {
|
|
1528
|
+
"maxSystemWorkerCountReached": "The maximum system worker count of {maxSystemWorkerCount} has been reached, can not create any more worker for task type \"{type}\""
|
|
1529
|
+
},
|
|
1530
|
+
"changeSetHelper": {
|
|
1531
|
+
"getChangeSetError": "Failed to retrieve change set with id \"{changeSetStorageId}\""
|
|
1532
|
+
},
|
|
1533
|
+
"remoteSyncStateHelper": {
|
|
1534
|
+
"getSyncStateError": "Failed to retrieve sync state for syncPointerId \"{syncPointerId}\""
|
|
1535
|
+
}
|
|
1536
|
+
},
|
|
1537
|
+
"cli": {
|
|
1538
|
+
"progress": {
|
|
1539
|
+
"done": "Done.",
|
|
1540
|
+
"error": "Error",
|
|
1541
|
+
"loadingEnvFiles": "Loading env files",
|
|
1542
|
+
"pleaseWait": "Please wait...",
|
|
1543
|
+
"writingJsonFile": "Writing JSON file",
|
|
1544
|
+
"writingEnvFile": "Writing env file",
|
|
1545
|
+
"readingJsonFile": "Reading JSON file",
|
|
1546
|
+
"readingEnvFile": "Reading env file"
|
|
1547
|
+
},
|
|
1548
|
+
"options": {
|
|
1549
|
+
"lang": {
|
|
1550
|
+
"param": "--lang '<'lang'>'",
|
|
1551
|
+
"description": "The language to display the output in."
|
|
1552
|
+
},
|
|
1553
|
+
"load-env": {
|
|
1554
|
+
"param": "--load-env [env...]",
|
|
1555
|
+
"description": "Load the env files to initialise any environment variables."
|
|
1556
|
+
},
|
|
1557
|
+
"no-console": {
|
|
1558
|
+
"param": "--no-console",
|
|
1559
|
+
"description": "Hides the output in the console."
|
|
1560
|
+
},
|
|
1561
|
+
"json": {
|
|
1562
|
+
"param": "--json '<'filename'>'",
|
|
1563
|
+
"description": "Creates a JSON file containing the output."
|
|
1564
|
+
},
|
|
1565
|
+
"env": {
|
|
1566
|
+
"param": "--env '<'filename'>'",
|
|
1567
|
+
"description": "Creates an env file containing the output."
|
|
1568
|
+
},
|
|
1569
|
+
"merge-json": {
|
|
1570
|
+
"param": "--merge-json",
|
|
1571
|
+
"description": "If the JSON file already exists merge the data instead of overwriting."
|
|
1572
|
+
},
|
|
1573
|
+
"merge-env": {
|
|
1574
|
+
"param": "--merge-env",
|
|
1575
|
+
"description": "If the env file already exists merge the data instead of overwriting."
|
|
1576
|
+
}
|
|
1577
|
+
}
|
|
1578
|
+
},
|
|
1579
|
+
"engineCore": {
|
|
1580
|
+
"debuggingEnabled": "Debugging is enabled",
|
|
1581
|
+
"starting": "Engine is starting",
|
|
1582
|
+
"started": "Engine has started",
|
|
1583
|
+
"stopping": "Engine is stopping",
|
|
1584
|
+
"stopped": "Engine has stopped",
|
|
1585
|
+
"configuring": "Configuring component type \"{componentType}\" with configuration type \"{configType}\"",
|
|
1586
|
+
"bootstrapStarted": "Bootstrap started",
|
|
1587
|
+
"bootstrapComplete": "Bootstrap complete",
|
|
1588
|
+
"bootstrapping": "Bootstrapping component type \"{className}\" with instance type \"{instanceType}\"",
|
|
1589
|
+
"componentsStarting": "Components are starting",
|
|
1590
|
+
"componentsComplete": "Components have started",
|
|
1591
|
+
"componentsStopping": "Components are stopping",
|
|
1592
|
+
"componentsStopped": "Components have stopped",
|
|
1593
|
+
"componentStarting": "Starting component type \"{className}\" with instance type \"{instanceType}\"",
|
|
1594
|
+
"componentStopping": "Stopping component type \"{className}\" with instance type \"{instanceType}\""
|
|
1595
|
+
},
|
|
1596
|
+
"fileStateStorage": {
|
|
1597
|
+
"loading": "Loading state from file storage with filename \"{filename}\"",
|
|
1598
|
+
"saving": "Saving state to file storage with filename \"{filename}\""
|
|
1599
|
+
},
|
|
1600
|
+
"memoryStateStorage": {
|
|
1601
|
+
"loading": "Loading state from memory",
|
|
1602
|
+
"saving": "Saving state to memory"
|
|
1603
|
+
},
|
|
1604
|
+
"info": {
|
|
1605
|
+
"engineTypes": {
|
|
1606
|
+
"configuringEntityStorage": "Configuring {element} with name \"{storageName}\" using \"{storageType}\" connector"
|
|
1607
|
+
},
|
|
1608
|
+
"taskSchedulerService": {
|
|
1609
|
+
"taskAdded": "Task with id \"{id}\" added",
|
|
1610
|
+
"taskRemoved": "Task with id \"{id}\" removed",
|
|
1611
|
+
"taskTriggered": "Task with id \"{id}\" triggered at time \"{time}\""
|
|
1612
|
+
},
|
|
1613
|
+
"backgroundTaskService": {
|
|
1614
|
+
"start": "Processing task \"{id}\" with type \"{type}\"",
|
|
1615
|
+
"complete": "Completed processing task \"{id}\" with type \"{type}\" with status \"{status}\"",
|
|
1616
|
+
"initialisingWorker": "Initialising worker for task type \"{type}\"",
|
|
1617
|
+
"shutdownWorker": "Shutting down worker for task type \"{type}\""
|
|
1618
|
+
},
|
|
1619
|
+
"s3BlobStorageConnector": {
|
|
1620
|
+
"bucketCreating": "Creating bucket \"{bucket}\"",
|
|
1621
|
+
"bucketExists": "Skipping create bucket \"{bucket}\" as it already exists"
|
|
1622
|
+
},
|
|
1623
|
+
"azureBlobStorageConnector": {
|
|
1624
|
+
"containerCreating": "Creating container \"{container}\"",
|
|
1625
|
+
"containerExists": "Skipping create container \"{container}\" as it already exists"
|
|
1626
|
+
},
|
|
1627
|
+
"fileBlobStorageConnector": {
|
|
1628
|
+
"directoryCreating": "Creating directory \"{directory}\"",
|
|
1629
|
+
"directoryExists": "Skipping create directory \"{directory}\" as it already exists"
|
|
1630
|
+
},
|
|
1631
|
+
"gcpBlobStorageConnector": {
|
|
1632
|
+
"bucketCreating": "Creating bucket \"{bucket}\"",
|
|
1633
|
+
"bucketExists": "Skipping create bucket \"{bucket}\" as it already exists"
|
|
1634
|
+
},
|
|
1635
|
+
"dataSpaceConnectorService": {
|
|
1636
|
+
"scheduledTask": "\"{taskId}\": Task scheduled for Data Space Connector App \"{dataSpaceConnectorAppId}\"",
|
|
1637
|
+
"registeredApp": "App with Id \"{appId}\" has been registered",
|
|
1638
|
+
"unregisteredApp": "App with Id \"{appId}\" has been unregistered"
|
|
1639
|
+
},
|
|
1640
|
+
"dataSpaceConnectorSocketClient": {
|
|
1641
|
+
"subscribeActivityLogs": "Subscription created for topic activity logs with id \"{subscriptionId}\"",
|
|
1642
|
+
"unsubscribeActivityLogs": "Subscription removed for topic activity logs with id \"{subscriptionId}\""
|
|
1643
|
+
},
|
|
1644
|
+
"cosmosDbEntityStorageConnector": {
|
|
1645
|
+
"databaseCreating": "Database \"{databaseId}\" creating",
|
|
1646
|
+
"databaseExists": "Database \"{databaseId}\" created or it already exists",
|
|
1647
|
+
"containerCreating": "Container \"{containerId}\" creating",
|
|
1648
|
+
"containerExists": "Container \"{containerId}\" created or it already exists"
|
|
1649
|
+
},
|
|
1650
|
+
"dynamoDbEntityStorageConnector": {
|
|
1651
|
+
"tableCreating": "Creating table \"{tableName}\"",
|
|
1652
|
+
"tableCreated": "Created table \"{tableName}\"",
|
|
1653
|
+
"tableExists": "Skipping create table \"{tableName}\" as it already exists"
|
|
1654
|
+
},
|
|
1655
|
+
"fileEntityStorageConnector": {
|
|
1656
|
+
"directoryCreating": "Creating directory \"{directory}\"",
|
|
1657
|
+
"directoryCreated": "Created directory \"{directory}\"",
|
|
1658
|
+
"directoryExists": "Skipping create directory \"{directory}\" as it already exists"
|
|
1659
|
+
},
|
|
1660
|
+
"firestoreEntityStorageConnector": {
|
|
1661
|
+
"firestoreCreating": "Creating Firestore",
|
|
1662
|
+
"firestoreCreated": "Created Firestore"
|
|
1663
|
+
},
|
|
1664
|
+
"mongoDbEntityStorageConnector": {
|
|
1665
|
+
"databaseCreating": "Database \"{databaseName}\" creating",
|
|
1666
|
+
"databaseExists": "Database \"{databaseName}\" created or it already exists",
|
|
1667
|
+
"collectionExists": "Database \"{collectionName}\" created or it already exists"
|
|
1668
|
+
},
|
|
1669
|
+
"mySqlEntityStorageConnector": {
|
|
1670
|
+
"databaseCreating": "Database \"{databaseName}\" creating",
|
|
1671
|
+
"databaseExists": "Database \"{databaseName}\" created or it already exists",
|
|
1672
|
+
"tableCreating": "Table \"{tableName}\" creating",
|
|
1673
|
+
"tableExists": "Table \"{tableName}\" created or it already exists"
|
|
1674
|
+
},
|
|
1675
|
+
"postgreSqlEntityStorageConnector": {
|
|
1676
|
+
"databaseCreating": "Database \"{databaseName}\" creating",
|
|
1677
|
+
"databaseExists": "Database \"{databaseName}\" created or it already exists",
|
|
1678
|
+
"tableCreating": "Table \"{tableName}\" creating",
|
|
1679
|
+
"tableExists": "Table \"{tableName}\" created or it already exists"
|
|
1680
|
+
},
|
|
1681
|
+
"scyllaDBTableConnector": {
|
|
1682
|
+
"keyspaceCreating": "Creating keyspace \"{keyspace}\"",
|
|
1683
|
+
"keyspaceExists": "Skipping create keyspace \"{keyspace}\" as it already exists",
|
|
1684
|
+
"tableCreating": "Creating table \"{table}\"",
|
|
1685
|
+
"tableExists": "Skipping create table \"{table}\" as it already exists",
|
|
1686
|
+
"typeCreating": "Creating type \"{typeName}\"",
|
|
1687
|
+
"sql": "SQL: \"{sql}\""
|
|
1688
|
+
},
|
|
1689
|
+
"scyllaDBViewConnector": {
|
|
1690
|
+
"viewCreating": "Creating view \"{view}\"",
|
|
1691
|
+
"viewCreated": "Created view \"{view}\"",
|
|
1692
|
+
"viewExists": "Skipping create view \"{view}\" as it already exists"
|
|
1693
|
+
},
|
|
1694
|
+
"abstractScyllaDBConnector": {
|
|
1695
|
+
"sql": "SQL: \"{sql}\""
|
|
1696
|
+
},
|
|
1697
|
+
"localEventBusConnector": {
|
|
1698
|
+
"subscribe": "Subscription created for topic \"{topic}\" with id \"{subscriptionId}\"",
|
|
1699
|
+
"unsubscribe": "Subscription removed for topic \"{topic}\" with id \"{subscriptionId}\"",
|
|
1700
|
+
"publish": "Event publish for topic \"{topic}\" with id \"{eventId}\", with \"{subscriptionCount}\" subscriptions"
|
|
1701
|
+
},
|
|
1702
|
+
"eventBusSocketClient": {
|
|
1703
|
+
"subscribe": "Subscription created for topic \"{topic}\" with id \"{subscriptionId}\"",
|
|
1704
|
+
"unsubscribe": "Subscription removed for topic \"{topic}\" with id \"{subscriptionId}\""
|
|
1705
|
+
},
|
|
1706
|
+
"federatedCatalogueService": {
|
|
1707
|
+
"datasetRetrieve": "Retrieving dataset \"{dataSetId}\" from catalogue",
|
|
1708
|
+
"datasetSet": "Storing dataset \"{dataSetId}\" in catalogue",
|
|
1709
|
+
"datasetRemove": "Removing dataset \"{dataSetId}\" from catalogue",
|
|
1710
|
+
"catalogQuery": "Executing catalogue query",
|
|
1711
|
+
"catalogQueryComplete": "Catalogue query complete, found {resultCount} results",
|
|
1712
|
+
"filterIndexPersisted": "Filter indexes persisted for dataset \"{dataSetId}\" using filter \"{filterType}\", {indexCount} entries"
|
|
1713
|
+
},
|
|
1714
|
+
"iota": {
|
|
1715
|
+
"transactionCosts": "Transaction costs for operation \"{operation}\", \"{cost}\""
|
|
1716
|
+
},
|
|
1717
|
+
"immutableProofService": {
|
|
1718
|
+
"createdProof": "The immutable proof with Id \"{proofId}\" has been created successfully"
|
|
1719
|
+
},
|
|
1720
|
+
"awsMessagingSmsConnector": {
|
|
1721
|
+
"smsSending": "Sending SMS of type"
|
|
1722
|
+
},
|
|
1723
|
+
"awsMessagingPushNotificationConnector": {
|
|
1724
|
+
"registeringApplications": "Registering applications",
|
|
1725
|
+
"deviceRegistering": "Registering device token",
|
|
1726
|
+
"deviceTokenChecking": "Checking device token",
|
|
1727
|
+
"platformAppChecking": "Checking platform application",
|
|
1728
|
+
"pushNotificationSending": "Sending push notification",
|
|
1729
|
+
"platformAppCreating": "Creating platform application"
|
|
1730
|
+
},
|
|
1731
|
+
"awsMessagingEmailConnector": {
|
|
1732
|
+
"emailSending": "Sending email of type {type}"
|
|
1733
|
+
},
|
|
1734
|
+
"entityStorageMessagingSmsConnector": {
|
|
1735
|
+
"smsSending": "Sending SMS"
|
|
1736
|
+
},
|
|
1737
|
+
"entityStorageMessagingPushNotificationConnector": {
|
|
1738
|
+
"deviceRegistering": "Registering device",
|
|
1739
|
+
"pushNotificationSending": "Sending push notification"
|
|
1740
|
+
},
|
|
1741
|
+
"entityStorageMessagingEmailConnector": {
|
|
1742
|
+
"emailSending": "Sending email"
|
|
1743
|
+
},
|
|
1744
|
+
"messagingService": {},
|
|
1745
|
+
"iotaNftConnector": {
|
|
1746
|
+
"contractReady": "Contract ready for use"
|
|
1747
|
+
},
|
|
1748
|
+
"policyEnforcementPointService": {
|
|
1749
|
+
"processing": "Processing information using processor with id: \"{processorId}\", locator: \"{locator}\"",
|
|
1750
|
+
"intercepting": "Intercepting information for locator: \"{locator}\""
|
|
1751
|
+
},
|
|
1752
|
+
"identityPolicyInformationSource": {
|
|
1753
|
+
"identityRetrieving": "Retrieving identity information for locator: \"{locator}\""
|
|
1754
|
+
},
|
|
1755
|
+
"staticPolicyInformationSource": {
|
|
1756
|
+
"staticRetrieving": "Retrieving static policy information for locator \"{locator}\" with access mode: \"{accessMode}\"",
|
|
1757
|
+
"staticRetrieved": "Retrieved static policy information for locator: \"{locator}\" with access mode: \"{accessMode}\", item count: {itemCount}"
|
|
1758
|
+
},
|
|
1759
|
+
"loggingPolicyExecutionAction": {
|
|
1760
|
+
"policyActionExecutedBefore": "Policy executed for locator: \"{locator}\", stage: \"{stage}\", data: \"{data}\", policies: \"{policies}\"",
|
|
1761
|
+
"policyActionExecutedAfter": "Policy executed for locator: \"{locator}\", stage: \"{stage}\", data: \"{data}\", policies: \"{policies}\", decisions: \"{decisions}\""
|
|
1762
|
+
},
|
|
1763
|
+
"policyManagementPointService": {
|
|
1764
|
+
"retrieving": "Retrieving policies for locator \"locator\"",
|
|
1765
|
+
"retrieved": "Retrieved {count} policies for locator \"locator\"."
|
|
1766
|
+
},
|
|
1767
|
+
"policyExecutionPointService": {
|
|
1768
|
+
"executingActions": "Executing actions for stage: \"{stage}\", locator: \"{locator}\"",
|
|
1769
|
+
"executingAction": "Executing action for stage: \"{stage}\", locator: \"{locator}\""
|
|
1770
|
+
},
|
|
1771
|
+
"changeSetHelper": {
|
|
1772
|
+
"changeSetApplyingChange": "Applying remote sync change with operation id \"{operation}\" for item with id \"{id}\"",
|
|
1773
|
+
"changeSetStoring": "Storing remote sync change set with id \"{id}\"",
|
|
1774
|
+
"getChangeSet": "Retrieving change set with id \"{changeSetStorageId}\"",
|
|
1775
|
+
"getChangeSetEmpty": "No change set found with id \"{changeSetStorageId}\"",
|
|
1776
|
+
"copyChangeSet": "Copying change set with id \"{changeSetStorageId}\"",
|
|
1777
|
+
"storageReset": "Resetting storage for storage key \"{storageKey}\""
|
|
1778
|
+
},
|
|
1779
|
+
"localSyncStateHelper": {
|
|
1780
|
+
"getSnapshots": "Retrieving snapshot for storage key \"{storageKey}\"",
|
|
1781
|
+
"getSnapshotsExists": "Found existing snapshot for storage key \"{storageKey}\"",
|
|
1782
|
+
"getSnapshotsDoesNotExist": "No local change snapshot found for storage key \"{storageKey}\", creating new one",
|
|
1783
|
+
"applySyncState": "Syncing from remote state with \"{snapshotCount}\" snapshots",
|
|
1784
|
+
"applySnapshot": "Processing sync snapshot with id \"{snapshotId}\" created on \"{dateCreated}\"",
|
|
1785
|
+
"applySnapshotNoExisting": "There are no existing snapshots, find a consolidated snapshot for storage key \"{storageKey}\"",
|
|
1786
|
+
"applySnapshotFoundConsolidated": "Found consolidated snapshot with id \"{snapshotId}\" for storage key \"{storageKey}\"",
|
|
1787
|
+
"applySnapshotNoConsolidated": "No consolidated snapshot found, cannot apply sync state for storage key \"{storageKey}\"",
|
|
1788
|
+
"processModifiedSnapshot": "Processing modified sync snapshot with id \"{snapshotId}\", remote modified on \"{remoteModified}\", local modified on \"{localModified}\"",
|
|
1789
|
+
"processNewSnapshot": "Processing new sync snapshot with id \"{snapshotId}\", created on \"{dateCreated}\"",
|
|
1790
|
+
"removeLocalChangeSnapshot": "Removing local change snapshot with id \"{snapshotId}\"",
|
|
1791
|
+
"addLocalChange": "Adding local change with id \"{id}\" to local change snapshot for storage key \"{storageKey}\", operation \"{operation}\"",
|
|
1792
|
+
"setLocalChangeSnapshot": "Storing local change snapshot for storage key \"{storageKey}\""
|
|
1793
|
+
},
|
|
1794
|
+
"remoteSyncStateHelper": {
|
|
1795
|
+
"verifiableSyncPointerStoreRetrieving": "Retrieving verifiable sync pointer for key \"{key}\"",
|
|
1796
|
+
"verifiableSyncPointerStoreNotFound": "No verifiable sync pointer store found for key \"{key}\"",
|
|
1797
|
+
"verifiableSyncPointerStoreRetrieved": "Retrieved verifiable sync pointer for key \"{key}\"",
|
|
1798
|
+
"verifiableSyncPointerStoreStoring": "Storing verifiable sync pointer store for key \"{key}\"",
|
|
1799
|
+
"syncStateStoring": "Storing sync state entry with \"{snapshotCount}\" snapshots",
|
|
1800
|
+
"syncStateRetrieving": "Retrieving sync state entry for syncPointerId \"{syncPointerId}\"",
|
|
1801
|
+
"syncStateRetrieved": "Retrieving sync state entry for syncPointerId \"{syncPointerId}\" with \"{snapshotCount}\" snapshots",
|
|
1802
|
+
"syncStateNotFound": "No sync state entry found for syncPointerId \"{syncPointerId}\"",
|
|
1803
|
+
"consolidationStarting": "Starting consolidation of remote sync state",
|
|
1804
|
+
"consolidationCompleted": "Consolidation of remote sync state completed",
|
|
1805
|
+
"addChangeSetToSyncState": "Adding change set with id \"{changeSetStorageId}\" to remote sync state for storage key \"{storageKey}\"",
|
|
1806
|
+
"buildingChangeSet": "Building change set for storage key \"{storageKey}\" with \"{changeCount}\" changes",
|
|
1807
|
+
"finalisingSyncChanges": "Finalising sync changes for storage key \"{storageKey}\"",
|
|
1808
|
+
"createChangeSetRequestingItem": "Creating change set for key \"{storageKey}\", requesting item with id \"{id}\"",
|
|
1809
|
+
"createChangeSetRespondingItem": "Responding to change set request for key \"{storageKey}\", item with id \"{id}\""
|
|
1810
|
+
},
|
|
1811
|
+
"synchronisedStorageService": {
|
|
1812
|
+
"registerStorageKey": "Registering synchronised storage key \"{storageKey}\"",
|
|
1813
|
+
"activateStorageKey": "Activating synchronised storage key \"{storageKey}\"",
|
|
1814
|
+
"startEntitySync": "Starting synchronised entity storage for key \"{storageKey}\"",
|
|
1815
|
+
"updateFromRemoteSyncState": "Updating synchronised entity storage from remote sync state for key \"{storageKey}\"",
|
|
1816
|
+
"updateFromLocalSyncState": "Updating synchronised entity storage from local sync state for key \"{storageKey}\"",
|
|
1817
|
+
"updateFromLocalSyncStateNoChanges": "No changes found in local sync state for key \"{storageKey}\", skipping update",
|
|
1818
|
+
"builtStorageChangeSet": "Built storage change set for key \"{storageKey}\" with id \"{changeSetStorageId}\"",
|
|
1819
|
+
"builtStorageChangeSetNone": "No changes found for key \"{storageKey}\", no storage change set created",
|
|
1820
|
+
"sendingChangeSetToTrustedNode": "Sending change set with id \"{changeSetStorageId}\" to trusted node for key \"{storageKey}\"",
|
|
1821
|
+
"decryptionKeyRequest": "Decryption key requested by node identity \"{nodeId}\"",
|
|
1822
|
+
"syncChangeSetForRemoteNode": "Synchronising change set with id \"{changeSetStorageId}\" for node identity \"{nodeId}\""
|
|
1823
|
+
},
|
|
1824
|
+
"blobStorageHelper": {
|
|
1825
|
+
"loadBlob": "Loading blob with id \"{blobId}\"",
|
|
1826
|
+
"loadedBlob": "Loaded blob with id \"{blobId}\"",
|
|
1827
|
+
"loadBlobEmpty": "No blob found with id \"{blobId}\"",
|
|
1828
|
+
"saveBlob": "Saving blob",
|
|
1829
|
+
"savedBlob": "Saved blob with id \"{blobId}\"",
|
|
1830
|
+
"removeBlob": "Removing blob with id \"{blobId}\"",
|
|
1831
|
+
"removedBlob": "Removed blob with id \"{blobId}\"",
|
|
1832
|
+
"removeBlobEmpty": "No blob found to remove with id \"{blobId}\""
|
|
1833
|
+
},
|
|
1834
|
+
"entityStorageTelemetryConnector": {
|
|
1835
|
+
"metricCreated": "The metric was created \"{id}\" with type \"type\" and label \"{label}\"",
|
|
1836
|
+
"metricUpdated": "The metric was updated \"{id}\" with type \"type\" and label \"{label}\"",
|
|
1837
|
+
"metricRemoved": "The metric was removed \"{id}\"",
|
|
1838
|
+
"metricValueCreated": "The metric value was created for \"{id}\" with value \"{value}\""
|
|
1839
|
+
},
|
|
1840
|
+
"trustService": {
|
|
1841
|
+
"verifying": "Verifying payload: \"{payload}\"",
|
|
1842
|
+
"verified": "Payload verified successfully"
|
|
1843
|
+
},
|
|
1844
|
+
"hashicorpVaultConnector": {
|
|
1845
|
+
"hashicorpVaultConnected": "Connected to Hashicorp Vault"
|
|
1846
|
+
},
|
|
1847
|
+
"iotaVerifiableStorageConnector": {
|
|
1848
|
+
"contractReady": "Contract ready for use"
|
|
1849
|
+
},
|
|
1850
|
+
"fastifyWebServer": {
|
|
1851
|
+
"building": "Building Web Server",
|
|
1852
|
+
"starting": "Starting Web Server at address \"{host}\" on port \"{port}\"",
|
|
1853
|
+
"started": "The Web Server started on {addresses}",
|
|
1854
|
+
"stopped": "The Web Server was stopped",
|
|
1855
|
+
"restRouteAdded": "Added REST route \"{route}\" \"{method}\"",
|
|
1856
|
+
"socketRouteAdded": "Added socket route: handshake path \"{handshakePath}\", namespace \"{namespace}\", event name \"{eventName}\""
|
|
1857
|
+
},
|
|
1858
|
+
"loggingProcessor": {
|
|
1859
|
+
"requestMessage": "===> {method} {requestUrl}",
|
|
1860
|
+
"responseMessage": "<=== {statusCode} {method} {requestUrl} duration: {elapsedMicroSeconds}µs"
|
|
1861
|
+
}
|
|
1862
|
+
},
|
|
1863
|
+
"nftAttestationConnector": {
|
|
1864
|
+
"verificationFailures": {
|
|
1865
|
+
"noData": "There is no data in the resolved NFT",
|
|
1866
|
+
"proofFailed": "The proof of the attestation could not be verified",
|
|
1867
|
+
"revoked": "The proof of the attestation has been revoked"
|
|
1868
|
+
}
|
|
1869
|
+
},
|
|
1870
|
+
"auditableItemGraphService": {},
|
|
1871
|
+
"debug": {
|
|
1872
|
+
"dataSpaceConnectorService": {
|
|
1873
|
+
"newActivity": "New Activity of type \"{activityType}\" notified by \"{generator}\"",
|
|
1874
|
+
"taskSchedulerStarted": "Task Scheduler started with this config: \"{taskTime}\"",
|
|
1875
|
+
"scheduledCleanUpTask": "Activity Log clean up task scheduled",
|
|
1876
|
+
"engineCloneStart": "'start' method has been called from an engine clone. No task scheduler created",
|
|
1877
|
+
"cleanUpOngoing": "There is an ongoing clean up of activity logs. Skipping",
|
|
1878
|
+
"activityLogCleanedUp": "Activity Log has been cleaned up. \"{numRecordsDeleted}\" records deleted"
|
|
1879
|
+
},
|
|
1880
|
+
"dataSpaceConnectorSocketRoutes": {
|
|
1881
|
+
"activityLogStatusConnected": "Web Socket Connected: Socket Id: \"{socketId}\"",
|
|
1882
|
+
"activityLogStatusDisconnected": "Web Socket disconnected: Socket Id: \"{socketId}\""
|
|
1883
|
+
}
|
|
1884
|
+
}
|
|
1885
|
+
}
|