TypeScript API / laikacms/i18n / defaultMessages

Variable: defaultMessages

const defaultMessages: object = en;

Type Declaration

assetsObsidian.atomNotFound

assetsObsidian.atomNotFound: string = 'No asset or folder was found at this key.';

assetsObsidian.directoryNotFound

assetsObsidian.directoryNotFound: string = 'The requested folder could not be found in the vault.';

assetsObsidian.expectedAssetFoundDocument

assetsObsidian.expectedAssetFoundDocument: string = 'This key belongs to a document, not an asset.';

assetsObsidian.expectedFileFoundDirectory

assetsObsidian.expectedFileFoundDirectory: string = 'A file was expected here, but a folder was found instead.';

assetsObsidian.fileNotFound

assetsObsidian.fileNotFound: string = 'The requested asset could not be found in the vault.';

assetsObsidian.filesystemError

assetsObsidian.filesystemError: string = 'A vault file system error occurred.';

assetsObsidian.pathTraversalRejected

assetsObsidian.pathTraversalRejected: string = 'The requested path is outside the allowed vault location.';

assetsObsidian.updateUnsupported

assetsObsidian.updateUnsupported: string = 'Assets in an Obsidian vault have no metadata to update; replace the file instead.';

back

back: string = 'Back';

cancel

cancel: string = 'Cancel';

close

close: string = 'Close';

confirm

confirm: string = 'Confirm';

confirmPassword

confirmPassword: string = 'Confirm password';

create

create: string = 'Create';

delete

delete: string = 'Delete';

documentsJsonapiProxy.invalidResponse

documentsJsonapiProxy.invalidResponse: string = 'The response from the upstream server could not be processed.';

documentsJsonapiProxy.lockAttributesMissing

documentsJsonapiProxy.lockAttributesMissing: string = 'The upstream server returned an incomplete lock.';

documentsJsonapiProxy.lockTimestampInvalid

documentsJsonapiProxy.lockTimestampInvalid: string = 'The upstream server returned a lock with an invalid timestamp.';

documentsJsonapiProxy.networkError

documentsJsonapiProxy.networkError: string = 'The upstream server could not be reached.';

documentsJsonapiProxy.syncTokenMissing

documentsJsonapiProxy.syncTokenMissing: string = 'The upstream server did not return a sync token.';

documentsJsonapiProxy.unknownRecordType

documentsJsonapiProxy.unknownRecordType: string = 'The upstream server returned a record of an unknown type.';

documentsObsidian.notPublished

documentsObsidian.notPublished: string = 'This note exists but is not a published document.';

documentsObsidian.notUnpublished

documentsObsidian.notUnpublished: string = 'This note exists but is published, not an unpublished draft.';

documentsObsidian.revisionsUnsupported

documentsObsidian.revisionsUnsupported: string = 'The Obsidian backend has no version history; revisions are unsupported.';

edit

edit: string = 'Edit';

email

email: string = 'Email';

error

error: string = 'Error';

filter

filter: string = 'Filter';

forbidden

forbidden: string = 'Forbidden';

forgotPassword

forgotPassword: string = 'Forgot password?';

invalidEmail

invalidEmail: string = 'Must be a valid email address';

invalidUrl

invalidUrl: string = 'Must be a valid URL';

loading

loading: string = 'Loading...';

login

login: string = 'Log in';

logout

logout: string = 'Log out';

maxLength

maxLength: string = 'Must be at most {{max}} characters';

minLength

minLength: string = 'Must be at least {{min}} characters';

networkError

networkError: string = 'Network error';

next

next: string = 'Next';

no

no: string = 'No';

noPermissionAccessDocument

noPermissionAccessDocument: string = 'You do not have permission to access this document';

notFound

notFound: string = 'Not found';

ok

ok: string = 'OK';

open

open: string = 'Open';

password

password: string = 'Password';

previous

previous: string = 'Previous';

refresh

refresh: string = 'Refresh';

register

register: string = 'Register';

rememberMe

rememberMe: string = 'Remember me';

required

required: string = 'This field is required';

resetPassword

resetPassword: string = 'Reset password';

save

save: string = 'Save';

search

search: string = 'Search';

serverError

serverError: string = 'Server error';

sort

sort: string = 'Sort';

storage.drizzle.atomNotFound

storage.drizzle.atomNotFound: string = 'No item was found at this key.';

storage.drizzle.cannotRemoveFolderKey

storage.drizzle.cannotRemoveFolderKey: string = 'This key cannot be removed because it is a folder with items in it.';

storage.drizzle.contentRequired

storage.drizzle.contentRequired: string = 'Content is required to create this item.';

storage.drizzle.directoryNotFound

storage.drizzle.directoryNotFound: string = 'The requested folder could not be found.';

storage.drizzle.entryAlreadyExists

storage.drizzle.entryAlreadyExists: string = 'An item with this key already exists.';

storage.drizzle.failedToRemoveAtom

storage.drizzle.failedToRemoveAtom: string = 'The item could not be removed.';

storage.drizzle.fileNotFound

storage.drizzle.fileNotFound: string = 'The requested object could not be found.';

storage.drizzle.invalidJsonContent

storage.drizzle.invalidJsonContent: string = 'The stored content is not valid JSON.';

storage.fs.contentRequired

storage.fs.contentRequired: string = 'Content is required to create this item.';

storage.fs.directoryNotEmpty

storage.fs.directoryNotEmpty: string = 'The folder could not be deleted because it still contains items.';

storage.fs.directoryNotFound

storage.fs.directoryNotFound: string = 'The requested folder could not be found.';

storage.fs.entryAlreadyExists

storage.fs.entryAlreadyExists: string = 'An item with this key already exists.';

storage.fs.entryTypeUnsupported

storage.fs.entryTypeUnsupported: string = 'Only files and folders can be managed here.';

storage.fs.expectedDirectoryFoundFile

storage.fs.expectedDirectoryFoundFile: string = 'A folder was expected here, but a file was found instead.';

storage.fs.expectedFileFoundDirectory

storage.fs.expectedFileFoundDirectory: string = 'A file was expected here, but a folder was found instead.';

storage.fs.failedToGetDirectoryMetadata

storage.fs.failedToGetDirectoryMetadata: string = 'The folder metadata could not be retrieved.';

storage.fs.failedToGetFileMetadata

storage.fs.failedToGetFileMetadata: string = 'The file metadata could not be retrieved.';

storage.fs.failedToListDirectory

storage.fs.failedToListDirectory: string = 'The folder contents could not be listed.';

storage.fs.failedToListDrives

storage.fs.failedToListDrives: string = 'The available drives could not be listed.';

storage.fs.failedToReadFile

storage.fs.failedToReadFile: string = 'The file could not be read.';

storage.fs.fileNotFound

storage.fs.fileNotFound: string = 'The requested file could not be found.';

storage.fs.invalidRequest

storage.fs.invalidRequest: string = 'The request could not be processed.';

storage.fs.pathTraversalRejected

storage.fs.pathTraversalRejected: string = 'The requested path is outside the allowed storage location.';

storage.fs.permissionDenied

storage.fs.permissionDenied: string = 'You do not have the necessary file system permissions for this operation.';

storage.fs.unexpectedFileSystemError

storage.fs.unexpectedFileSystemError: string = 'An unexpected file system error occurred.';

storage.githubCdn.directoryInsteadOfFile

storage.githubCdn.directoryInsteadOfFile: string = 'A folder was found where a file was expected.';

storage.githubCdn.fileInsteadOfDirectory

storage.githubCdn.fileInsteadOfDirectory: string = 'A file was found where a folder was expected.';

storage.githubCdn.fileNotFound

storage.githubCdn.fileNotFound: string = 'The requested file could not be found in the repository.';

storage.githubCdn.tooManyRequests

storage.githubCdn.tooManyRequests: string = 'The CDN is rate-limiting requests. Please try again later.';

storage.githubCdn.unexpectedError

storage.githubCdn.unexpectedError: string = 'An unexpected error occurred while fetching from the CDN.';

storage.r2.contentRequired

storage.r2.contentRequired: string = 'Content is required to create this item.';

storage.r2.directoryNotFound

storage.r2.directoryNotFound: string = 'The requested folder could not be found.';

storage.r2.entryAlreadyExists

storage.r2.entryAlreadyExists: string = 'An item with this key already exists.';

storage.r2.failedToCreateOrUpdateObject

storage.r2.failedToCreateOrUpdateObject: string = 'The object could not be created or updated.';

storage.r2.failedToDeleteObject

storage.r2.failedToDeleteObject: string = 'The object could not be deleted.';

storage.r2.failedToGetDirectoryMetadata

storage.r2.failedToGetDirectoryMetadata: string = 'The folder metadata could not be retrieved.';

storage.r2.failedToGetObjectMetadata

storage.r2.failedToGetObjectMetadata: string = 'The object metadata could not be retrieved.';

storage.r2.failedToListDirectory

storage.r2.failedToListDirectory: string = 'The folder contents could not be listed.';

storage.r2.failedToReadObject

storage.r2.failedToReadObject: string = 'The object contents could not be read.';

storage.r2.fileNotFound

storage.r2.fileNotFound: string = 'The requested file could not be found.';

storage.r2.invalidRequest

storage.r2.invalidRequest: string = 'The request could not be processed.';

storage.web.directoryNotFound

storage.web.directoryNotFound: string = 'The requested folder could not be found in local storage.';

storage.web.fileNotFound

storage.web.fileNotFound: string = 'The requested object could not be found in local storage.';

storage.web.quotaExceeded

storage.web.quotaExceeded: string = 'The storage quota has been exceeded.';

storage.web.unexpectedError

storage.web.unexpectedError: string = 'An unexpected local storage error occurred.';

storage.webdav.atomNotFound

storage.webdav.atomNotFound: string = 'No item was found at this key.';

storage.webdav.authenticationFailed

storage.webdav.authenticationFailed: string = 'Authentication with the WebDAV server failed.';

storage.webdav.conflict

storage.webdav.conflict: string = 'The request conflicts with the current state of the WebDAV server.';

storage.webdav.contentRequired

storage.webdav.contentRequired: string = 'Content is required to create this item.';

storage.webdav.directoryNotEmpty

storage.webdav.directoryNotEmpty: string = 'The folder could not be deleted because it still contains items.';

storage.webdav.directoryNotFound

storage.webdav.directoryNotFound: string = 'The requested folder could not be found.';

storage.webdav.entryAlreadyExists

storage.webdav.entryAlreadyExists: string = 'An item with this key already exists.';

storage.webdav.fetchImplementationMissing

storage.webdav.fetchImplementationMissing: string = 'No network client is available to talk to the WebDAV server.';

storage.webdav.fileNotFound

storage.webdav.fileNotFound: string = 'The requested file could not be found.';

storage.webdav.invalidRequest

storage.webdav.invalidRequest: string = 'The request could not be processed.';

storage.webdav.methodNotAllowed

storage.webdav.methodNotAllowed: string = 'The WebDAV server does not allow this operation.';

storage.webdav.permissionDenied

storage.webdav.permissionDenied: string = 'You do not have the necessary permissions for this operation.';

storage.webdav.resourceLocked

storage.webdav.resourceLocked: string = 'The resource is locked and cannot be modified right now.';

storage.webdav.resourceNotFound

storage.webdav.resourceNotFound: string = 'The requested resource could not be found.';

storage.webdav.serverUnreachable

storage.webdav.serverUnreachable: string = 'The WebDAV server could not be reached.';

storage.webdav.serviceUnavailable

storage.webdav.serviceUnavailable: string = 'The WebDAV server is currently unavailable.';

storage.webdav.tooManyRequests

storage.webdav.tooManyRequests: string = 'The WebDAV server is rate-limiting requests. Please try again later.';

storage.webdav.unexpectedError

storage.webdav.unexpectedError: string = 'An unexpected error occurred while talking to the WebDAV server.';

storage.webfs.cannotDeleteRoot

storage.webfs.cannotDeleteRoot: string = 'The repository root directory cannot be deleted.';

storage.webfs.directoryInsteadOfFile

storage.webfs.directoryInsteadOfFile: string = 'A folder was found where a file was expected.';

storage.webfs.directoryNotEmpty

storage.webfs.directoryNotEmpty: string = 'The folder could not be deleted because it still contains items.';

storage.webfs.directoryNotFound

storage.webfs.directoryNotFound: string = 'The requested folder could not be found.';

storage.webfs.fileInsteadOfDirectory

storage.webfs.fileInsteadOfDirectory: string = 'A file was found where a folder was expected.';

storage.webfs.fileNotFound

storage.webfs.fileNotFound: string = 'The requested file could not be found.';

storage.webfs.permissionDenied

storage.webfs.permissionDenied: string = 'You do not have the necessary file system permissions for this operation.';

storage.webfs.permissionPromptRequired

storage.webfs.permissionPromptRequired: string = 'File system access must be re-requested; trigger a user gesture to call requestPermission().';

storage.webfs.quotaExceeded

storage.webfs.quotaExceeded: string = 'The file system storage quota has been exceeded.';

storage.webfs.staleHandle

storage.webfs.staleHandle: string = 'The directory handle is no longer valid; ask the user to pick the directory again.';

storage.webfs.unexpectedError

storage.webfs.unexpectedError: string = 'An unexpected file system error occurred.';

success

success: string = 'Success';

unauthorized

unauthorized: string = 'Unauthorized';

unknownError

unknownError: string = 'Unknown error';

validationError

validationError: string = 'Validation error';

yes

yes: string = 'Yes';