export var messages;
(function (messages) {
    messages["ERR_COMMUNITY_SIGNER_NOT_DEFINED"] = "Community signer is not defined";
    messages["ERR_COMMUNITY_CAN_EITHER_RUN_OR_UPDATE"] = "Community can either sync through .start() or update, but not both";
    messages["ERR_PUBLICATION_MISSING_FIELD"] = "Publication is missing field(s)";
    messages["ERR_COMMUNITY_MISSING_FIELD"] = "Community is missing field needed for publishing";
    messages["ERR_COMMUNITY_OPTIONS_MISSING_ADDRESS"] = "The options sent to pkc.createCommunity() is missing address or signer";
    messages["ERR_INVALID_COMMUNITY_ADDRESS_SCHEMA"] = "Community address is incorrect. Address should be either a domain or IPNS";
    messages["ERR_CID_IS_INVALID"] = "CID is invalid";
    messages["ERR_DATA_PATH_IS_NOT_DEFINED"] = "pkcOptions.dataPath needs to be defined with native functions";
    messages["ERR_COMMUNITY_OWNER_ATTEMPTED_EDIT_NEW_ADDRESS_THAT_ALREADY_EXISTS"] = "Community owner attempted to edit community.address to a new address that already exists";
    messages["ERR_COMMENT_MISSING_IPFS_AND_UPDATE"] = "Comment is missing CommentIpfs and CommentUpdate";
    messages["ERR_COMMENT_MISSING_CID"] = "Comment is missing cid";
    messages["ERR_COMMENT_MISSING_IPFS"] = "Comment is missing CommentIpfs props";
    messages["ERR_COMMENT_MISSING_UPDATE"] = "Comment is missing CommentUpdate props";
    messages["ERR_COMMENT_IPFS_COMMUNITY_NAME_MISMATCH"] = "CommentIpfs community name does not match the expected community name";
    messages["ERR_NEED_TO_STOP_UPDATING_COMMUNITY_BEFORE_STARTING"] = "You need to stop updating the community before starting it";
    messages["ERR_HELIAS_STOPPING_OR_STOPPED"] = "Helia is stopping or stopped already. You can't use any helia functions";
    messages["ERR_FAILED_TO_DIAL_ANY_PUBSUB_PEERS_FROM_DELEGATED_ROUTERS"] = "Failed to dial and connect to any IPNS-Over-Pubsub peers from delegated routers";
    messages["ERR_FETCH_OVER_IPNS_OVER_PUBSUB_RETURNED_UNDEFINED"] = "libp2p Fetch over IPNS-Over-Pubsub returned undefined when requested from a peer";
    messages["ERR_FAILED_TO_DIAL_ANY_PEERS_PROVIDING_CID"] = "Failed to dial and connect to any peers providing a CID";
    messages["ERR_GET_COMMUNITY_TIMED_OUT"] = "pkc.getCommunity({address}) timed out";
    messages["ERR_TIMEOUT_WAITING_FOR_PUBSUB_TOPIC_PEERS"] = "Timeout waiting for propagation of pubsub topic peers";
    messages["ERR_PUBSUB_TOPIC_PEER_WAIT_ABORTED"] = "Aborted while waiting for a peer to subscribe to a pubsub topic";
    messages["ERR_TIMED_OUT_RM_MFS_FILE"] = "Timed out removing MFS paths. We may need to nuke the whole MFS directory and republish everything";
    messages["ERR_ABORTED_RESOLVING_TEXT_RECORD"] = "Aborted resolving text record on domain";
    // PKC errors
    messages["ERR_CALLED_COMMUNITY_STOP_WITHOUT_UPDATE"] = "community.stop() called without calling update() first";
    messages["ERR_PKC_MISSING_NATIVE_FUNCTIONS"] = "missing nativeFunctions required to create a community";
    messages["ERR_CAN_NOT_RUN_A_COMMUNITY_WITH_NO_IPFS_NODE"] = "Can't run a community with pkc.ipfsHttpClientOptions undefined";
    messages["ERR_PKC_OPTION_NOT_ACCEPTED"] = "Option is not accepted on PKC constructor";
    messages["ERR_FAILED_TO_GET_CONFIG_ON_KUBO_NODE"] = "Failed to get config on kubo node";
    messages["ERR_FAILED_TO_SET_CONFIG_ON_KUBO_NODE"] = "Failed to set config on kubo node";
    messages["ERR_FAILED_TO_SHUTDOWN_KUBO_NODE"] = "Failed to shutdown kubo node";
    messages["ERR_CAN_NOT_CREATE_A_LOCAL_COMMUNITY"] = "Can't create a new local community with the provided arguments";
    messages["ERR_COMMUNITY_ADDRESS_IS_PROVIDED_AS_NULL_OR_UNDEFINED"] = "User provided options.address in createCommunity that is either undefined or null";
    messages["ERR_UNABLE_TO_DERIVE_PUBSUB_COMMENT_PUBLICATION_FROM_JSONIFIED_COMMENT"] = "User provided a jsonfied (cloned) Comment and we're unable to derive request.comment from it. This is an implementation error";
    messages["ERR_UNABLE_TO_DERIVE_PUBSUB_COMMENT_EDIT_PUBLICATION_FROM_JSONIFIED_COMMENT_EDIT"] = "User provided a jsonfied (cloned) CommentEdit and we're unable to derive request.commentEdit from it. This is an implementation error";
    messages["ERR_UNABLE_TO_DERIVE_PUBSUB_COMMENT_MODERATION_PUBLICATION_FROM_JSONIFIED_COMMENT_MODERATION"] = "User provided a jsonfied (cloned) CommentModeration and we're unable to derive request.commentModeration from it. This is an implementation error";
    messages["ERR_UNABLE_TO_DERIVE_PUBSUB_VOTE_PUBLICATION_FROM_JSONIFIED_VOTE"] = "User provided a jsonfied (cloned) Vote and we're unable to derive request.vote from it. This is an implementation error";
    messages["ERR_UNABLE_TO_DERIVE_PUBSUB_COMMUNITY_EDIT_PUBLICATION_FROM_JSONIFIED_COMMUNITY_EDIT"] = "User provided a jsonfied (cloned) CommunityEdit and we're unable to derive request.communityEdit from it. This is an implementation error";
    messages["ERR_PKC_SQLITE_LONG_TERM_STORAGE_KEYV_ERROR"] = "Error in Keyv SQLITE adapter";
    messages["ERR_PKC_IS_DESTROYED"] = "PKC instance has been destroyed. Create a new instance.";
    // Fetch errors
    messages["ERR_FAILED_TO_FETCH_IPFS_VIA_GATEWAY"] = "Failed to fetch IPFS file via gateway";
    messages["ERR_FAILED_TO_FETCH_IPFS_CID_VIA_IPFS_P2P"] = "Failed to fetch an IPFS CID via IPFS P2P";
    messages["ERR_FAILED_TO_FETCH_IPNS_VIA_GATEWAY"] = "Failed to fetch IPNS through gateway";
    messages["ERR_IPNS_RECORD_NOT_FOUND"] = "IPNS record not found in local Kubo node";
    messages["ERR_FAILED_TO_FETCH_COMMUNITY_FROM_GATEWAYS"] = "Failed to fetch Community IPNS record from gateway(s)";
    messages["ERR_FETCH_OVER_IPNS_OVER_PUBSUB_FAILED"] = "Failed to fetch IPNS record over IPNS-Over-Pubsub using libp2p/fetch";
    messages["ERR_LIBP2P_FETCH_IPNS_FROM_PEER_TIMEDOUT"] = "libp2p fetch IPNS from peer timed out";
    messages["ERR_FAILED_TO_FETCH_COMMENT_IPFS_FROM_GATEWAYS"] = "Failed to fetch comment IPFS file from gateway(s)";
    messages["ERR_FAILED_TO_FETCH_COMMENT_UPDATE_FROM_GATEWAYS"] = "Failed to fetch comment update IPFS file from gateway(s)";
    messages["ERR_FAILED_TO_FETCH_PAGE_IPFS_FROM_GATEWAYS"] = "Failed to fetch Page IPFS file from gateway(s)";
    messages["ERR_FAILED_TO_FETCH_GENERIC_IPFS_FROM_GATEWAYS"] = "Failed to fetch IPFS file from gateways(s)";
    messages["ERR_FAILED_TO_RESOLVE_IPNS_VIA_IPFS_P2P"] = "Failed to resolve IPNS through IPFS P2P. It may have resolved IPNS name to an undefined CID";
    messages["ERR_FAILED_TO_FETCH_COMMENT_UPDATE_FROM_ALL_POST_UPDATES_RANGES"] = "Failed to fetch CommentUpdate from all post update timestamp ranges";
    messages["ERR_COMMUNITY_HAS_NO_POST_UPDATES"] = "Community has no postUpdates field and therefore can't fetch a commentUpdate";
    messages["ERR_FAILED_TO_FETCH_GENERIC"] = "Failed to fetch";
    messages["ERR_OVER_DOWNLOAD_LIMIT"] = "The file size is larger than download limit";
    messages["ERR_CALCULATED_CID_DOES_NOT_MATCH"] = "The CID calculated from loaded content does not match the provided CID";
    messages["ERR_FAILED_TO_FETCH_THUMBNAIL_URL_OF_LINK"] = "Failed to fetch the thumbnail url of the link";
    messages["ERR_FAILED_TO_FETCH_THUMBNAIL_DIMENSION_OF_LINK"] = "Failed to fetch the thumbnail dimension of the link";
    messages["ERR_COMMUNITY_NAME_HAS_CAPITAL_LETTER"] = "Domain address has an uppercase letter. Community domain address should be lowercase";
    messages["ERR_GATEWAY_TIMED_OUT_OR_ABORTED"] = "Fetching from gateway has been aborted/timed out";
    messages["ERR_FAILED_TO_PARSE_CID_FROM_GATEWAY_RESPONSE_ETAG"] = "Failed to parse the CID from the etag header of IPNS gateway response";
    messages["ERR_GATEWAY_MISSING_ETAG_HEADER"] = "Gateway response is missing the etag header";
    messages["ERR_GATEWAY_ABORTING_LOADING_COMMUNITY_BECAUSE_SAME_INVALID_COMMUNITY_RECORD"] = "Aborted the gateway request to load community record because it will give us an invalid record we already processed and validated before";
    messages["ERR_GATEWAY_ABORTING_LOADING_COMMUNITY_BECAUSE_SAME_UPDATE_CID"] = "Aborted the gateway request to load community record because it will give us the same record we already have";
    messages["ERR_GATEWAY_ABORTING_LOADING_COMMUNITY_BECAUSE_WE_ALREADY_LOADED_THIS_RECORD"] = "Aborted the gateway request to load community record because we already loaded this record before";
    messages["ERR_GATEWAY_PROVIDED_INCORRECT_X_IPFS_ROOTS"] = "Gateway provided an x-ipfs-roots that doesn't correspond to body";
    messages["ERR_REMOTE_COMMUNITY_RECEIVED_ALREADY_PROCCESSED_RECORD"] = "We loaded a community record but it's a record we already consumed before";
    messages["ERR_COMMENT_RECEIVED_ALREADY_PROCESSED_COMMENT_UPDATE"] = "We loaded a CommentUpdate but it's a record we already consumed";
    messages["ERR_FETCH_CID_P2P_TIMEOUT"] = "Fetching CID via Kubo-rpc-client/helia P2P has timed out";
    messages["ERR_FETCH_CID_P2P_TIMEOUT_AFTER_RETRIES"] = "Fetching CID via Kubo-rpc-client/helia P2P has timed out after all retry attempts";
    messages["ERR_RESOLVED_IPNS_P2P_TO_UNDEFINED"] = "Resolved IPNS name to undefined. Does this IPNS name exist?";
    messages["ERR_IPNS_RESOLUTION_P2P_TIMEOUT"] = "IPNS resolution P2P timed out";
    messages["ERR_IPNS_MAX_HOPS_EXCEEDED"] = "IPNS record resolution followed more than the maximum allowed /ipns/ -> /ipns/ delegation hops";
    messages["ERR_RESOLVED_IPNS_TO_UNSUPPORTED_VALUE"] = "Resolved IPNS record to a value that is neither an /ipfs/ path nor an /ipns/ path";
    messages["ERR_GATEWAY_IPNS_RECORD_CHAIN_INVALID"] = "Failed to validate the IPNS record chain (anchor -> ... -> terminal) fetched from the gateway";
    messages["ERR_FIND_PROVIDERS_TIMEOUT"] = "Finding providers for CID timed out without yielding any results";
    messages["ERR_NO_DEFAULT_IPFS_PROVIDER"] = "No default IPFS provider found. Make sure to define either kuboRpcClientOptions or libp2pJsClientOptions";
    messages["ERR_NO_DEFAULT_PUBSUB_PROVIDER"] = "No default pubsub provider found. Make sure to define either pubsubKuboRpcClientOptions or libp2pJsClientOptions";
    messages["ERR_NO_DEFAULT_KUBO_RPC_PUBSUB_PROVIDER"] = "No default kubo rpc pubsub provider found. Make sure to define pubsubKuboRpcClientOptions";
    messages["ERR_NO_DEFAULT_KUBO_RPC_IPFS_PROVIDER"] = "No default kubo rpc ipfs provider found. Make sure to define kuboRpcClientOptions";
    messages["ERR_CAN_NOT_HAVE_BOTH_KUBO_AND_LIBP2P_JS_CLIENTS_DEFINED"] = "Can't have both libp2pJsClientOptions and kuboRpcClientOptions or pubsubKuboRpcClientOptions defined. Please define only one of them";
    messages["ERR_INVALID_PUBSUB_PROVIDER"] = "Couldn't find a kubo pubsub RPC with that url or a libp2pjs with that key";
    messages["ERR_ADDED_COMMENT_IPFS_TO_IPFS_BUT_GOT_DIFFERENT_CID"] = "Added CommentIpfs to IPFS but we got a different cid than challengeVerification.commentUpdate.cid, should not happen";
    messages["ERR_NO_PUBSUB_PROVIDERS_AVAILABLE_TO_PUBLISH_OVER_PUBSUB"] = "No pubsub providers available to publish over pubsub";
    // Schema errors
    messages["ERR_INVALID_JSON"] = "The loaded file is not the expected json";
    messages["ERR_INVALID_COMMENT_IPFS_SCHEMA"] = "The schema of Comment ipfs file is invalid";
    messages["ERR_REPLY_HAS_NOT_DEFINED_POST_CID"] = "User attempted to create a reply without defining postCid";
    messages["ERR_REPLY_POST_CID_IS_NOT_PARENT_OF_REPLY"] = "User's reply has reply.postCid that is not the post of the reply";
    messages["ERR_POST_CANNOT_HAVE_QUOTED_CIDS"] = "Only replies can have quotedCids, posts cannot quote other comments";
    messages["ERR_QUOTED_CID_DOES_NOT_EXIST"] = "One or more quoted CIDs do not exist in this community";
    messages["ERR_QUOTED_CID_NOT_UNDER_POST"] = "One or more quoted CIDs are not under the same post";
    messages["ERR_QUOTED_CID_IS_PENDING_APPROVAL"] = "One or more quoted CIDs are pending approval";
    messages["ERR_INVALID_COMMUNITY_IPFS_SCHEMA"] = "The loaded Community record has an invalid schema";
    messages["ERR_INVALID_COMMENT_UPDATE_SCHEMA"] = "The schema of Comment Update is invalid";
    messages["ERR_INVALID_PAGE_IPFS_SCHEMA"] = "The schema of Page ipfs file is invalid";
    messages["ERR_INVALID_MODQUEUE_PAGE_IPFS_SCHEMA"] = "The schema of mod queue page ipfs file is invalid";
    messages["ERR_INVALID_CHALLENGE_DECRYPTED_SCHEMA"] = "The schema of decrypted challenge.encrypted is invalid";
    messages["ERR_INVALID_CHALLENGE_VERIFICATION_DECRYPTED_SCHEMA"] = "The schema of challengeverification.encryption is invalid";
    messages["ERR_INVALID_RPC_ENCODED_CHALLENGE_REQUEST_PUBSUB_MSG_SCHEMA"] = "The rpc server transmitted an encoded challenge request pubsub message with invalid schema";
    messages["ERR_INVALID_RPC_ENCODED_CHALLENGE_PUBSUB_MSG_SCHEMA"] = "The rpc server transmitted an encoded challenge pubsub message with invalid schema";
    messages["ERR_INVALID_RPC_ENCODED_CHALLENGE_ANSWER_PUBSUB_MSG_SCHEMA"] = "The rpc server transmitted an encoded challenge answer pubsub message with invalid schema";
    messages["ERR_INVALID_RPC_ENCODED_CHALLENGE_VERIFICATION_PUBSUB_MSG_SCHEMA"] = "The rpc server transmitted an enocded challenge verification pubsub message with invalid schema";
    messages["ERR_INVALID_RPC_LOCAL_COMMUNITY_UPDATE_SCHEMA"] = "RPC server has transmitted a local community update result with invalid schema";
    messages["ERR_INVALID_RPC_COMMUNITY_UPDATING_STATE_SCHEMA"] = "RPC server transmitted an invalid updating state schema";
    messages["ERR_INVALID_RPC_COMMUNITY_STARTED_STATE_SCHEMA"] = "RPC server transmitted an invalid started state schema";
    messages["ERR_INVALID_RPC_ENCODED_CHALLENGE_REQUEST_WITH_COMMUNITY_AUTHOR_PUBSUB_MSG_SCHEMA"] = "RPC server transmitted an invalid challenge request schema for RpcLocalCommunity";
    messages["ERR_INVALID_RPC_REMOTE_COMMUNITY_SCHEMA"] = "Invalid schema of remote community transmitted by RPC";
    messages["ERR_INVALID_RPC_PUBLICATION_PUBLISHING_STATE_SCHEMA"] = "Invalid schema of publication.publishingState transmitted by RPC";
    messages["ERR_INVALID_RPC_PUBLICATION_STATE_SCHEMA"] = "Invalid schema of publication.state transmitted by RPC";
    messages["ERR_INVALID_CID_STRING_SCHEMA"] = "Invalid cid string schema";
    messages["ERR_LOCAL_COMMUNITY_PRODUCED_INVALID_SCHEMA"] = "Local community produced a community record with invalid schema";
    messages["ERR_INVALID_RPC_COMMENT_UPDATE_SCHEMA"] = "RPC server transmitted an update event with invalid schema, it should follow CommentUpdate schema";
    messages["ERR_INVALID_RPC_COMMENT_SCHEMA"] = "RPC server transmitted a comment event with an invalid schema, it should follow CommentIpfs schema";
    messages["ERR_INVALID_RPC_COMMENT_UPDATING_STATE_SCHEMA"] = "RPC server transmitted a comment's updating state with invalid schema";
    messages["ERR_INVALID_RPC_COMMENT_STATE_SCHEMA"] = "RPC server transmitted a comment state with invalid schema";
    messages["ERR_INVALID_CREATE_COMMUNITY_ARGS_SCHEMA"] = "User provided invalid schema of arguments for pkc.createCommunity";
    messages["ERR_INVALID_CREATE_COMMENT_EDIT_ARGS_SCHEMA"] = "User provided invalid schema of arguments for pkc.createCommentEdit";
    messages["ERR_INVALID_CREATE_VOTE_ARGS_SCHEMA"] = "User provided invalid schema of arguments for pkc.createVote";
    messages["ERR_INVALID_CREATE_COMMENT_MODERATION_ARGS_SCHEMA"] = "User provided an invalid schema of arguments for pkc.createCommentModeration";
    messages["ERR_INVALID_CREATE_COMMENT_ARGS_SCHEMA"] = "User provided an invalid schema of arguments for pkc.createComment";
    messages["ERR_INVALID_CREATE_REMOTE_COMMUNITY_ARGS_SCHEMA"] = "User provided an invalid remote community schema";
    messages["ERR_INVALID_CREATE_COMMUNITY_EDIT_ARGS_SCHEMA"] = "User provided an invalid args to pkc.createCommunityEdit";
    messages["ERR_GENERIC_RPC_INVALID_SCHEMA"] = "The RPC server responded with invalid schema error";
    messages["ERR_INVALID_NEW_WS_SERVER_SETTINGS_SCHEMA"] = "RPC client sent new settings with invalid schema";
    messages["ERR_INVALID_CREATE_NEW_LOCAL_COMMUNITY_USER_OPTIONS"] = "User provided arguments to create a local community with invalid schema";
    messages["ERR_INVALID_COMMENT_EDIT_CHALLENGE_REQUEST_TO_ENCRYPT_SCHEMA"] = "RPC client sent an invalid schema for challenge request with commentEdit";
    messages["ERR_INVALID_VOTE_CHALLENGE_REQUEST_TO_ENCRYPT_SCHEMA"] = "RPC client sent an invalid schema for challenge request with vote";
    messages["ERR_INVALID_COMMENT_CHALLENGE_REQUEST_TO_ENCRYPT_SCHEMA"] = "RPC client sent an invalid schema for challenge request with comment";
    messages["ERR_INVALID_COMMENT_MODERATION_CHALLENGE_REQUEST_TO_ENCRYPT_SCHEMA"] = "RPC client sent an invalid schema for challenge request with commentModeration";
    messages["ERR_INVALID_COMMUNITY_EDIT_CHALLENGE_REQUEST_TO_ENCRYPT_SCHEMA"] = "RPC client sent an invalid schema for challenge request with communityEdit";
    messages["ERR_COMMUNITY_EDIT_OPTIONS_SCHEMA"] = "User sent a community edit options with invalid schema";
    messages["ERR_INVALID_CHALLENGE_ANSWERS"] = "User sent challenge answers with invalid schema";
    messages["ERR_INVALID_CREATE_PKC_WS_SERVER_OPTIONS_SCHEMA"] = "Invalid create arguments for PKC WS RPC server";
    messages["ERR_INVALID_CREATE_PKC_ARGS_SCHEMA"] = "User sent arguments with invalid schema in an attempt to create a PKC instance";
    messages["ERR_INVALID_CREATE_COMMUNITY_WITH_RPC_ARGS_SCHEMA"] = "User provided invalid schema of arguments for pkc.createCommunity while connected to RPC";
    messages["ERR_CAN_NOT_SET_EXCLUDE_PUBLICATION_TO_EMPTY_OBJECT"] = "The community has community.settings.challenges[x].exclude[y].publicationType is set to an empty object. You should either choose which publication to exclude or remove exclude.publicationType";
    messages["ERR_COMMUNITY_HAS_NO_INTERNAL_STATE"] = "The community has no internal state. This should never happen. Please report this bug.";
    // Sign errors
    messages["ERR_AUTHOR_ADDRESS_NOT_MATCHING_SIGNER"] = "comment.author.address does not match signer.address";
    messages["ERR_AUTHOR_ADDRESS_IS_NOT_A_DOMAIN_OR_B58"] = "author.address is not a domain or B58";
    messages["ERR_SIGNATURE_PUBLIC_KEY_IS_NOT_B58"] = "The public key of the signature is not B58";
    messages["ERR_PUBLICATION_FAILED_TO_DECRYPT_CHALLENGE"] = "The publication received a challenge and failed to decrypt";
    // Verify Signature errors
    messages["ERR_SIGNATURE_IS_INVALID"] = "Signature of publication is invalid";
    messages["ERR_SIGNATURE_HAS_NO_PUBLIC_KEY"] = "Signature of publication has no public key";
    messages["ERR_COMMENT_UPDATE_EDIT_SIGNATURE_IS_INVALID"] = "The author edit of comment (commentUpdate.edit) has an invalid signature";
    messages["ERR_THE_COMMUNITY_IPNS_RECORD_POINTS_TO_DIFFERENT_ADDRESS_THAN_WE_EXPECTED"] = "The community record address does not correspond to the requested community. requestedCommunity.address !== providedCommunity.address";
    messages["ERR_COMMUNITY_NAME_RESOLVES_TO_DIFFERENT_PUBLIC_KEY"] = "The community name resolves to a different public key than the one provided. The community may have migrated to a new key.";
    messages["ERR_AUTHOR_NOT_MATCHING_SIGNATURE"] = "comment.author.address doesn't match comment.signature.publicKey";
    messages["ERR_AUTHOR_NAME_MUST_BE_A_DOMAIN"] = "author.name must be a domain name (e.g. 'example.bso')";
    messages["ERR_COMMUNITY_IPNS_NAME_DOES_NOT_MATCH_SIGNATURE_PUBLIC_KEY"] = "The IPNS name of community doesn't match community.signature.publicKey";
    messages["ERR_COMMENT_SHOULD_BE_THE_LATEST_EDIT"] = "comment.content is not set to the latest comment.authorEdit.content";
    messages["ERR_COMMENT_UPDATE_IS_NOT_SIGNED_BY_COMMUNITY"] = "Comment update is not signed by the community";
    messages["ERR_AUTHOR_EDIT_IS_NOT_SIGNED_BY_AUTHOR"] = "Author edit is not signed by original author of comment";
    messages["ERR_COMMENT_UPDATE_DIFFERENT_CID_THAN_COMMENT"] = "CommentUpdate.cid is different than calculated or provided comment.cid";
    messages["ERR_PAGE_COMMENT_POST_HAS_POST_CID_DEFINED_WITH_DEPTH_0"] = "pageComment.comment.postCid is defined even though depth = 0, comments in page need to adhere to strict CommentIpfs and CommentUpdate props";
    messages["ERR_CHALLENGE_MSG_SIGNER_IS_NOT_COMMUNITY"] = "The signer of challenge pubsub message is not the community";
    messages["ERR_CHALLENGE_VERIFICATION_MSG_SIGNER_IS_NOT_COMMUNITY"] = "The signer of challenge verification pubsub message is not the community";
    messages["ERR_CHALLENGE_REQUEST_ID_NOT_DERIVED_FROM_SIGNATURE"] = "Challenge request id is not derived from signature.publicKey";
    messages["ERR_CHALLENGE_SIGNATURE_IS_INVALID"] = "Received a challenge message with an invalid signature";
    messages["ERR_CHALLENGE_VERIFICATION_SIGNATURE_IS_INVALID"] = "Received a challenge verification message with an invalid signature";
    messages["ERR_LOCAL_COMMUNITY_PRODUCED_INVALID_SIGNATURE"] = "Local community produced a new record with invalid signature";
    messages["ERR_COMMUNITY_POSTS_INVALID"] = "community.posts signature is invalid";
    messages["ERR_COMMENT_IPFS_SIGNATURE_IS_INVALID"] = "CommentIpfs signature is invalid";
    messages["ERR_COMMENT_UPDATE_SIGNATURE_IS_INVALID"] = "CommentUpdate signature is invalid";
    messages["ERR_COMMENT_IPFS_RECORD_INCLUDES_RESERVED_FIELD"] = "CommentIpfs record includes a reserved field";
    messages["ERR_COMMENT_IPFS_AUTHOR_INCLUDES_RESERVED_FIELD"] = "CommentIpfs author includes a reserved field";
    messages["ERR_COMMENT_UPDATE_RECORD_INCLUDES_RESERVED_FIELD"] = "CommentUpdate record includes a reserved field";
    messages["ERR_COMMUNITY_EDIT_HAS_RESERVED_FIELD"] = "CommunityEdit record includes a reserved field";
    messages["ERR_COMMUNITY_SIGNATURE_IS_INVALID"] = "Community signature is invalid";
    messages["ERR_COMMUNITY_RECORD_INCLUDES_RESERVED_FIELD"] = "The CommunityIpfs record includes a reserved field";
    messages["ERR_FAILED_TO_RESOLVE_COMMUNITY_DOMAIN"] = "Failed to resolve the community domain address to use for verification";
    messages["ERR_FAILED_TO_RESOLVE_AUTHOR_DOMAIN"] = "Failed to resolve the author domain address to use for verification";
    messages["ERR_AUTHOR_DOMAIN_RESOLVES_TO_DIFFERENT_SIGNER"] = "The author domain resolved to a public key that does not match the publication signer";
    messages["ERR_COMMUNITY_RECORD_INCLUDES_FIELD_NOT_IN_SIGNED_PROPERTY_NAMES"] = "CommunityIpfs record includes a field not included in signature.signedPropertyNames";
    messages["ERR_VOTE_RECORD_INCLUDES_FIELD_NOT_IN_SIGNED_PROPERTY_NAMES"] = "VotePubsubMessagePublication record includes a field that's not included in signature.signedPropertyNames";
    messages["ERR_COMMENT_EDIT_RECORD_INCLUDES_FIELD_NOT_IN_SIGNED_PROPERTY_NAMES"] = "CommentEditPubsubMessagePublication record includes a field that's not included in signature.signedPropertyNames";
    messages["ERR_COMMENT_MODERATION_RECORD_INCLUDES_FIELD_NOT_IN_SIGNED_PROPERTY_NAMES"] = "CommentModerationPubsubMessagePublication includes a field that's not included in signature.signedPropertyNames";
    messages["ERR_COMMENT_PUBSUB_RECORD_INCLUDES_FIELD_NOT_IN_SIGNED_PROPERTY_NAMES"] = "CommentPubsubMessagePublication includes a field that's not included in signature.signedPropertyNames";
    messages["ERR_COMMENT_UPDATE_RECORD_INCLUDES_FIELD_NOT_IN_SIGNED_PROPERTY_NAMES"] = "CommentUpdate record includes a field that's not included in signature.signedPropertyNames";
    messages["ERR_CHALLENGE_REQUEST_INCLUDES_FIELD_NOT_IN_SIGNED_PROPERTY_NAMES"] = "ChallengeRequestPubsubMessage include a field that's not part of signature.signedPropertyNames";
    messages["ERR_CHALLENGE_INCLUDES_FIELD_NOT_IN_SIGNED_PROPERTY_NAMES"] = "ChallengePubsubMessage includes a field that's not part of signature.signedPropertyNames";
    messages["ERR_CHALLENGE_ANSWER_INCLUDES_FIELD_NOT_IN_SIGNED_PROPERTY_NAMES"] = "ChallengeAnswerPubsubMessage includes a field that's not part of signature.signedPropertyNames";
    messages["ERR_CHALLENGE_VERIFICATION_INCLUDES_FIELD_NOT_IN_SIGNED_PROPERTY_NAMES"] = "ChallengeVerificationPubsubMessage includes a field that's not part of signature.signedPropertyNames";
    messages["ERR_COMMUNITY_EDIT_RECORD_INCLUDES_FIELD_NOT_IN_SIGNED_PROPERTY_NAMES"] = "CommunityEditPubsubPublication includes a field that's not in signature.signedPropertyNames";
    messages["ERR_COMMUNITY_CHANGED_COMMENT_PUBSUB_PUBLICATION_PROPS"] = "The community changed CommentPubsubMessagePublication props in decryptedChallengeVerification.comment";
    messages["ERR_COMMUNITY_SENT_CHALLENGE_VERIFICATION_WITH_INVALID_COMMENT"] = "The community sent an invalid decryptedChallengeVerification.comment";
    messages["ERR_COMMUNITY_SENT_CHALLENGE_VERIFICATION_WITH_INVALID_COMMENTUPDATE"] = "The community sent an invalid decryptedChallengeVerification.commentUpdate";
    messages["ERR_COMMUNITY_SENT_CHALLENGE_VERIFICATION_WITH_INVALID_CID"] = "The community sent decryptedChallengeVerification with commentUpdate.cid that does not correspond to commentIpfs";
    messages["ERR_PAGE_COMMENT_IS_INVALID"] = "validatePage has found a comment within a page that is invalid";
    messages["ERR_PAGE_COMMENT_IS_A_REPLY_BUT_HAS_NO_PARENT_COMMENT_INSTANCE"] = "Page comment is a reply with depth greater than 0, but has no parent comment instance cid";
    messages["ERR_PAGE_COMMENT_DEPTH_VALUE_IS_NOT_RELATIVE_TO_ITS_PARENT"] = "Page comment is a reply with a depth that's not relative to its direct parent";
    messages["ERR_PAGE_COMMENT_PARENT_DOES_NOT_EXIST_IN_FLAT_PAGE"] = "The parent of a comment in a flat page does not exist";
    messages["ERR_PAGE_COMMENT_POST_CID_IS_NOT_SAME_AS_POST_CID_OF_COMMENT_INSTANCE"] = "The post cid of reply in page is different than the post cid of the comment instance. Did the community instance put the wrong reply in this page?";
    messages["ERR_REPLY_IN_FLAT_PAGE_HAS_NO_PARENT_CID"] = "Reply in flat page has no parent CID";
    messages["ERR_PAGE_COMMENT_NO_WAY_TO_DERIVE_POST_CID"] = "Unable to derive post cid from page comment while verifying page";
    messages["ERR_POSTS_PAGE_IS_INVALID"] = "The page of posts is invalid";
    messages["ERR_REPLIES_PAGE_IS_INVALID"] = "The page of replies is invalid";
    messages["ERR_USER_ATTEMPTS_TO_VALIDATE_REPLIES_PAGE_WITHOUT_PARENT_COMMENT_CID"] = "User attempted to validate replies page without providing parent comment cid. Make sure parent comment is properly loaded";
    messages["ERR_USER_ATTEMPTS_TO_VALIDATE_REPLIES_PAGE_WITHOUT_PARENT_COMMENT_DEPTH"] = "User attempted to validate replies page without providing parent comment depth. Make sure parent comment is properly loaded";
    messages["ERR_USER_ATTEMPTS_TO_VALIDATE_REPLIES_PAGE_WITHOUT_PARENT_COMMENT_POST_CID"] = "User attempted to validate replies page without providing parent comment post cid. Make sure parent comment is properly loaded";
    messages["ERR_USER_ATTEMPTS_TO_GET_REPLIES_PAGE_WITHOUT_PARENT_COMMENT_CID"] = "User attempted to get replies page without providing parent comment cid. Make sure parent comment is properly loaded";
    messages["ERR_USER_ATTEMPTS_TO_GET_REPLIES_PAGE_WITHOUT_PARENT_COMMENT_DEPTH"] = "User attempted to get replies page without providing parent comment depth. Make sure parent comment is properly loaded";
    messages["ERR_USER_ATTEMPTS_TO_GET_REPLIES_PAGE_WITHOUT_PARENT_COMMENT_POST_CID"] = "User attempted to get replies page without providing parent comment post cid. Make sure parent comment is properly loaded";
    messages["ERR_FAILED_TO_FIND_REPLY_COMMENT_UPDATE_WITHIN_PARENT_COMMENT_PAGE_CIDS"] = "Failed to find reply comment update within parent comment page cids";
    messages["ERR_COMMUNITY_REGISTRY_LOOKUP_HAS_NO_ALIASES"] = "Community lookup has no aliases \u2014 at least one of address, name, publicKey, or signer.address must be defined";
    messages["ERR_INVALID_COMMENT_IPFS"] = "The part of CommentIpfs in Comment or PageComment is invalid";
    messages["ERR_COMMENT_MISSING_POST_CID"] = "Comment instance or PageComment has no postCid. postCid should always be defined if you have CommentIpfs";
    messages["ERR_INVALID_COMMENT_UPDATE"] = "The part of CommentUpdate in Comment or PageComment is invalid";
    // getPage errors
    messages["ERR_COMMENT_IN_PAGE_BELONG_TO_DIFFERENT_COMMUNITY"] = "Comment in page should be under the same community";
    messages["ERR_PARENT_CID_OF_COMMENT_IN_PAGE_IS_NOT_CORRECT"] = "The parent cid of comment in page is not correct";
    messages["ERR_PAGE_SIGNATURE_IS_INVALID"] = "The signature of one of the comment in the page is invalid";
    messages["ERR_MOD_QUEUE_PAGE_IS_INVALID"] = "The signature of mod queue page is invalid";
    // Community rejections of pubsub messages
    messages["ERR_CHALLENGE_ANSWER_WITH_NO_CHALLENGE_REQUEST"] = "Received a challenge answer without a prior challenge request";
    messages["ERR_REUSED_PUBSUB_MSG_SIGNER"] = "Reusing a pubsub message signer is forbidden";
    messages["ERR_PUBSUB_MSG_TIMESTAMP_IS_OUTDATED"] = "The timestamp of the pubsub message is outdated";
    // Community rejections of publications
    messages["ERR_UNAUTHORIZED_COMMENT_EDIT"] = "The author of this edit is not a mod/admin/owner or an author of the original comment. Can't edit";
    messages["ERR_COMMUNITY_COMMENT_TIMESTAMP_IS_EARLIER_THAN_PARENT"] = "Rejecting post/comment because its timestamp is earlier than its parent";
    messages["ERR_USER_PUBLISHED_UNDER_PENDING_COMMENT"] = "User attempted to publish a publication under a pending comment";
    messages["ERR_USER_PUBLISHED_UNDER_DISAPPROVED_COMMENT"] = "User attempted to publish a publication under a disapproved comment";
    messages["ERR_MOD_ATTEMPTING_TO_APPROVE_OR_DISAPPROVE_COMMENT_THAT_IS_NOT_PENDING"] = "Mod published a comment moderation with approved field on a comment that's not pending approval";
    messages["ERR_PUBLICATION_PARENT_DOES_NOT_EXIST_IN_COMMUNITY"] = "The parent of this publication does not exist within the community's records";
    messages["ERR_COMMUNITY_PUBLICATION_PARENT_CID_NOT_DEFINED"] = "The parent cid of this publication is not defined. Make sure either commentCid or parentCid is defined";
    messages["ERR_PUBLICATION_INVALID_COMMUNITY_ADDRESS"] = "The communityAddress field of publication is not the same as the community being published to";
    messages["ERR_PUBLICATION_USES_DEPRECATED_SUBPLEBBIT_ADDRESS"] = "Publication uses the deprecated `subplebbitAddress` field; update your client to use `communityPublicKey`";
    messages["ERR_PUBLICATION_USES_DEPRECATED_COMMUNITY_ADDRESS"] = "Publication uses the deprecated `communityAddress` field; update your client to use `communityPublicKey`";
    messages["ERR_PUBLICATION_INVALID_COMMUNITY_PUBLIC_KEY"] = "The communityPublicKey field of publication does not match the community's IPNS key";
    messages["ERR_PUBLICATION_INVALID_COMMUNITY_NAME"] = "The communityName field of publication does not match the community's address";
    messages["ERR_AUTHOR_IS_BANNED"] = "Author is banned";
    messages["ERR_PUBLICATION_HAS_NO_AUTHOR_ADDRESS"] = "Publication has no author.address";
    messages["ERR_COMMUNITY_PUBLICATION_PARENT_HAS_BEEN_REMOVED"] = "The parent of this publication has been removed";
    messages["ERR_COMMUNITY_PUBLICATION_PARENT_HAS_BEEN_DELETED"] = "The parent of this publication has been deleted";
    messages["ERR_COMMUNITY_PUBLICATION_POST_HAS_BEEN_DELETED"] = "The post of this publication has been deleted";
    messages["ERR_COMMUNITY_PUBLICATION_POST_HAS_BEEN_REMOVED"] = "The post of this publication has been removed";
    messages["ERR_COMMUNITY_PUBLICATION_POST_IS_LOCKED"] = "The post of this publication has been locked";
    messages["ERR_COMMUNITY_PUBLICATION_POST_IS_ARCHIVED"] = "The post of this publication has been archived";
    messages["ERR_FORBIDDEN_AUTHOR_FIELD"] = "The author field includes a forbidden field";
    messages["ERR_FORBIDDEN_COMMENT_FIELD"] = "The comment/post contains a forbidden field";
    messages["ERR_FORBIDDEN_SIGNER_FIELD"] = "The publication includes a signer field which is forbidden";
    messages["ERR_DUPLICATE_COMMENT"] = "Comment is duplicated";
    messages["ERR_DUPLICATE_COMMENT_MODERATION"] = "CommentModeration is duplicated";
    messages["ERR_DUPLICATE_COMMENT_EDIT"] = "CommentEdit is duplicated";
    messages["ERR_AUTHOR_ADDRESS_UNDEFINED"] = "author address is undefined";
    messages["ERR_COMMUNITY_FAILED_TO_DECRYPT_PUBSUB_MSG"] = "Community failed to decrypt the pubsub message";
    messages["ERR_REQUEST_PUBLICATION_OVER_ALLOWED_SIZE"] = "request.publication size is over 40kb";
    messages["UNAUTHORIZED_AUTHOR_ATTEMPTED_TO_CHANGE_VOTE"] = "An author attempted to change another author's vote";
    messages["COMMENT_LINK_LENGTH_IS_OVER_LIMIT"] = "comment.link length is over the limit";
    messages["INCORRECT_VOTE_VALUE"] = "The vote can only be 1 or 0 or -1";
    messages["ERR_COMMENT_HAS_INVALID_LINK_FIELD"] = "The comment arguments you provided contain an invalid .link";
    messages["ERR_POST_LINK_IS_NOT_OF_MEDIA"] = "Publishing to the community requires a post with a link pointing to media (audio, video, image)";
    messages["ERR_REPLY_HAS_INVALID_LINK_FIELD"] = "The reply must include a valid .link (https URL)";
    messages["ERR_REPLY_LINK_IS_NOT_OF_MEDIA"] = "Publishing a reply to the community requires a link pointing to media (audio, video, image)";
    messages["ERR_COMMENT_CONTENT_CONTAINS_MARKDOWN_IMAGE"] = "This community does not allow embedding images in markdown content";
    messages["ERR_COMMENT_CONTENT_CONTAINS_MARKDOWN_VIDEO"] = "This community does not allow embedding videos in markdown content";
    messages["ERR_COMMENT_HAS_LINK_THAT_IS_IMAGE"] = "This community does not allow comments with image links";
    messages["ERR_COMMENT_HAS_LINK_THAT_IS_VIDEO"] = "This community does not allow comments with video links";
    messages["ERR_COMMENT_HAS_SPOILER_ENABLED"] = "This community does not allow authors to mark comments as spoilers";
    messages["ERR_REPLY_HAS_LINK_THAT_IS_IMAGE"] = "This community does not allow replies with image links";
    messages["ERR_REPLY_HAS_LINK_THAT_IS_VIDEO"] = "This community does not allow replies with video links";
    messages["ERR_COMMENT_HAS_LINK_THAT_IS_AUDIO"] = "This community does not allow comments with audio links";
    messages["ERR_REPLY_HAS_LINK_THAT_IS_AUDIO"] = "This community does not allow replies with audio links";
    messages["ERR_REPLY_HAS_LINK"] = "This community does not allow replies with links";
    messages["ERR_COMMENT_CONTENT_CONTAINS_MARKDOWN_AUDIO"] = "This community does not allow embedding audio in markdown content";
    messages["ERR_REPLY_HAS_SPOILER_ENABLED"] = "This community does not allow authors to mark replies as spoilers";
    messages["ERR_NESTED_REPLIES_NOT_ALLOWED"] = "This community does not allow nested replies (depth > 1)";
    messages["ERR_COMMENT_HAS_NO_CONTENT_LINK_TITLE"] = "Comment has no content, link or title";
    messages["ERR_COMMENT_EDIT_HAS_NO_EDIT_FIELD"] = "CommentEdit has no editable field. At least one of content, deleted, flairs, spoiler or nsfw must be defined";
    messages["ERR_COMMENT_MODERATION_HAS_NO_MODERATION_FIELD"] = "CommentModeration has no moderation field. At least one moderation field other than reason must be defined";
    messages["ERR_REQUEST_ENCRYPTED_IS_INVALID_JSON_AFTER_DECRYPTION"] = "request.encrypted is an invalid json after decrypting";
    messages["ERR_REQUEST_ENCRYPTED_HAS_INVALID_SCHEMA_AFTER_DECRYPTING"] = "request.encrypted has an invalid schema after decrypting";
    messages["ERR_CHALLENGE_REQUEST_ENCRYPTED_HAS_NO_PUBLICATION_AFTER_DECRYPTING"] = "request.encrypted has not defined vote, comment, commentEdit, or commentModeration. At least one of them need to be defined";
    messages["ERR_CHALLENGE_REQUEST_ENCRYPTED_HAS_MULTIPLE_PUBLICATIONS_AFTER_DECRYPTING"] = "request.encrypted has multiple publication fields. The user is only allowed one publication per request";
    messages["ERR_CHALLENGE_ANSWER_IS_INVALID_JSON"] = "challenganswer.challengeAnswers is an invalid json";
    messages["ERR_CHALLENGE_ANSWER_IS_INVALID_SCHEMA"] = "challengeanswer.challengeAnswers is an invalid schema";
    messages["ERR_COMMENT_HAS_RESERVED_FIELD"] = "CommentPubsubMessagePublication has a reserved field";
    messages["ERR_VOTE_HAS_RESERVED_FIELD"] = "VotePubsubMessagePublication has a reserved field";
    messages["ERR_COMMENT_EDIT_HAS_RESERVED_FIELD"] = "CommentEditPubsubMessagePublication has a reserved field";
    messages["ERR_PUBLICATION_AUTHOR_HAS_RESERVED_FIELD"] = "request.publication.author has a reserved field";
    messages["ERR_COMMENT_EDIT_CAN_NOT_EDIT_COMMENT_IF_NOT_ORIGINAL_AUTHOR"] = "CommentEditPubsubPublication is attempting to edit a comment while not being the original author of the comment";
    messages["ERR_COMMENT_MODERATION_NO_COMMENT_TO_EDIT"] = "CommentModerationPubsubMessagePublication is attempting to moderate a comment that does not exist";
    messages["ERR_COMMENT_EDIT_NO_COMMENT_TO_EDIT"] = "CommentEditPubsubMessagePublication is attempting to edit a comment that does not exist";
    messages["ERR_COMMENT_MODERATION_HAS_RESERVED_FIELD"] = "CommentModerationPubsubMessagePublication has a reserved field";
    messages["ERR_COMMENT_MODERATION_ATTEMPTED_WITHOUT_BEING_MODERATOR"] = "CommentModerationPubsubMessagePublication signer is not a mod at this community";
    messages["ERR_COMMUNITY_EDIT_ATTEMPTED_TO_MODIFY_OWNER_EXCLUSIVE_PROPS"] = "CommunityEdit attempted to modify props meant only for the owner to edit";
    messages["ERR_COMMUNITY_EDIT_ATTEMPTED_TO_MODIFY_COMMUNITY_WITHOUT_BEING_OWNER_OR_ADMIN"] = "CommunityEdit attempted to modify community without being an owner or admin";
    messages["ERR_COMMUNITY_EDIT_ATTEMPTED_TO_NON_PUBLIC_PROPS"] = "CommunityEdit attempted to modify non public props or non existent. CommunityEdit is only allowed to edit props from CommunityIpfs schema";
    messages["ERR_PUBLICATION_TIMESTAMP_IS_NOT_IN_PROPER_RANGE"] = "Timestamp of publication is either too high or too low. It should be within 5 minutes range";
    messages["ERR_NOT_ALLOWED_TO_PUBLISH_UPVOTES"] = "community.features.noUpvotes is true which means no upvotes can be published to this community";
    messages["ERR_NOT_ALLOWED_TO_PUBLISH_DOWNVOTES"] = "community.features.noDownvotes is true which means no downvotes can be published to this community";
    messages["ERR_NOT_ALLOWED_TO_PUBLISH_POST_DOWNVOTES"] = "community.features.noPostDownvotes is true which means no downvotes can be published to posts";
    messages["ERR_NOT_ALLOWED_TO_PUBLISH_POST_UPVOTES"] = "community.features.noPostUpvotes is true which means no upvotes can be published to posts";
    messages["ERR_NOT_ALLOWED_TO_PUBLISH_REPLY_DOWNVOTES"] = "community.features.noReplyDownvotes is true which means no downvotes can be published to replies (depth > 0)";
    messages["ERR_NOT_ALLOWED_TO_PUBLISH_REPLY_UPVOTES"] = "community.features.noReplyUpvotes is true which means no upvotes can be published to replies (depth > 0)";
    messages["ERR_THERE_IS_NO_PREVIOUS_VOTE_TO_CANCEL"] = "vote=0 is for canceling a previous vote, but the author doesn't have a previous vote on this comment";
    messages["ERR_POST_FLAIRS_NOT_ALLOWED"] = "Post flairs are not allowed unless community.features.postFlairs is true";
    messages["ERR_POST_FLAIRS_REQUIRED"] = "Post flairs are required when community.features.requirePostFlairs is true";
    messages["ERR_POST_FLAIR_NOT_IN_ALLOWED_FLAIRS"] = "Post flair must be from the allowed flairs in community.flairs['post']";
    messages["ERR_AUTHOR_FLAIRS_NOT_ALLOWED"] = "Author flairs are not allowed unless community.features.authorFlairs is true";
    messages["ERR_AUTHOR_FLAIRS_REQUIRED"] = "Author flairs are required when community.features.requireAuthorFlairs is true";
    messages["ERR_AUTHOR_FLAIR_NOT_IN_ALLOWED_FLAIRS"] = "Author flair must be from the allowed flairs in community.flairs['author']";
    // Comment Edit errors
    messages["ERR_COMMUNITY_COMMENT_MOD_CAN_NOT_LOCK_REPLY"] = "Can't lock replies. Only posts";
    messages["ERR_COMMUNITY_COMMENT_MOD_CAN_NOT_ARCHIVE_REPLY"] = "Can't archive replies. Only posts";
    messages["ERR_COMMUNITY_COMMENT_EDIT_UNAUTHORIZED_FIELD"] = "CommentEdit includes a field that cannot be used";
    messages["ERR_PUBLISHING_EDIT_WITH_BOTH_MOD_AND_AUTHOR_FIELDS"] = "CommentEdit can't have both author and mod fields. Please publish a separate request for author and mod";
    // Resolver errors
    messages["ERR_FAILED_TO_RESOLVE_TEXT_RECORD"] = "Failed to resolve text record";
    messages["ERR_NO_CHAIN_PROVIDER_FOR_CHAIN_TICKER"] = "no chain provider options set for chain ticker";
    messages["ERR_NO_RESOLVER_FOR_NAME"] = "No name resolver can handle this address";
    messages["ERR_DOMAIN_TXT_RECORD_NOT_FOUND"] = "Domain resolver did not find the text record";
    messages["ERR_DOMAIN_COMMUNITY_ADDRESS_TXT_RECORD_POINT_TO_DIFFERENT_ADDRESS"] = "community-address text record of domain is pointing to a different address than community.signer.address";
    messages["ERR_RESOLVED_TEXT_RECORD_TO_NON_IPNS"] = "Resolved the text record value to a string that is non IPNS";
    messages["ERR_COMMUNITY_DOMAIN_HAS_NO_TEXT_RECORD"] = "Domain resolver did not find the text record community-address";
    // Local community errors
    messages["ERR_LOCAL_COMMUNITY_HAS_NO_SIGNER_IN_INTERNAL_STATE"] = "community.signer needs to be defined before proceeding";
    messages["ERR_COMMUNITY_STATE_LOCKED"] = "The internal state of the community in DB is locked";
    messages["ERR_COMMUNITY_CREATION_LOCKED"] = "Community creation is locked";
    messages["ERR_COMMUNITY_ALREADY_STARTED"] = "Community already started";
    messages["ERR_FAILED_TO_IMPORT_IPFS_KEY"] = "Community failed to import IPFS key";
    messages["ERR_LOCAL_COMMUNITY_PRODUCED_INVALID_RECORD"] = "The local community has produced a new IPNS record with invalid signature. This is a critical error";
    messages["ERR_FAILED_TO_PARSE_LOCAL_RAW_IPNS_RECORD"] = "Failed to parse the local IPNS record within our kubo node";
    messages["ERR_FAILED_TO_LOAD_LOCAL_RAW_IPNS_RECORD"] = "Failed to load local IPNS record from within our kubo node";
    messages["ERR_FAILED_TO_IMPORT_CHALLENGE_FILE_FACTORY"] = "Failed to import challenge file factory";
    messages["ERR_FAILED_TO_IMPORT_CHALLENGE_FILE"] = "Failed to import challenge file";
    messages["ERR_INVALID_RESULT_FROM_GET_CHALLENGE_FUNCTION"] = "invalid getChallenge response from community challenge";
    messages["ERR_LOCAL_COMMUNITY_RECORD_TOO_LARGE"] = "Local community has produced a record that is too large. This is a critical error and a bug in pkc-js";
    messages["ERR_CAN_NOT_LOAD_DB_IF_LOCAL_COMMUNITY_ALREADY_STARTED_IN_ANOTHER_PROCESS"] = "Can't load a local community that's already started in another process. You need to use the same PKC instance to load the community";
    messages["ERR_CAN_NOT_EDIT_A_LOCAL_COMMUNITY_THAT_IS_ALREADY_STARTED_IN_ANOTHER_PROCESS"] = "Can't edit a local community that's already started in another process. You need to use the same PKC instance to edit the community";
    messages["CAN_NOT_LOAD_LOCAL_COMMUNITY_IF_DB_DOES_NOT_EXIST"] = "Can't load the local community because its DB does not exist in dataPath";
    messages["ERR_COMMUNITY_START_FAILED_UNKNOWN_ERROR"] = "Community start failed with unknown error";
    messages["ERR_COMMUNITY_ALREADY_STARTED_IN_SAME_PKC_INSTANCE"] = "Community already started in the same PKC instance. You can check pkc._startedCommunities to see all started communities";
    messages["ERR_PAGE_GENERATED_IS_OVER_EXPECTED_SIZE"] = "Page generated is over expected size. This is a critical error and a bug in pkc-js";
    // Pubsub errors
    messages["ERR_PUBSUB_FAILED_TO_SUBSCRIBE"] = "Failed to subscribe on pubsub";
    messages["ERR_PUBSUB_FAILED_TO_UNSUBSCRIBE"] = "Failed to unsubscribe on pubsub";
    messages["ERR_PUBSUB_FAILED_TO_PUBLISH"] = "Failed to publish on pubsub";
    messages["ERR_PUBSUB_DID_NOT_RECEIVE_RESPONSE_AFTER_PUBLISHING_CHALLENGE_REQUEST"] = "Did not receive response to challenge request in the specified time";
    messages["ERR_ALL_PUBSUB_PROVIDERS_THROW_ERRORS"] = "All pubsub providers throw an error and unable to publish or subscribe";
    messages["ERR_CHALLENGE_REQUEST_RECEIVED_NO_RESPONSE_FROM_ANY_PROVIDER"] = "The challenge request has been published over the pubsub topic but no response was received";
    messages["ERR_PUBLICATION_DID_NOT_RECEIVE_RESPONSE"] = "Publication did not receive any response to challenge request";
    // RPC errors
    messages["ERR_RPC_AUTH_REQUIRED"] = "RPC server rejected the connection. The auth key is either missing or wrong. Set the correct auth key in the RPC URL (e.g., ws://host:port/your-auth-key)";
    messages["ERR_FAILED_TO_OPEN_CONNECTION_TO_RPC"] = "Failed to open connection to RPC";
    messages["ERR_FAILED_TO_CREATE_WS_RPC_SERVER"] = "Failed to create WebSocket RPC server";
    messages["ERR_RPC_CLIENT_ATTEMPTING_TO_START_A_REMOTE_COMMUNITY"] = "Attempting to start a community that is not local";
    messages["ERR_RPC_CLIENT_TRYING_TO_STOP_COMMUNITY_THAT_IS_NOT_RUNNING"] = "RPC client is attempting to stop a local community that is not running";
    messages["ERR_RPC_CLIENT_TRYING_TO_STOP_REMOTE_COMMUNITY"] = "RPC client is attempting to stop a remote community";
    messages["ERR_RPC_CLIENT_TRYING_TO_EDIT_REMOTE_COMMUNITY"] = "RPC client is attempting to edit remote community";
    messages["ERR_RPC_CLIENT_TRYING_TO_DELETE_REMOTE_COMMUNITY"] = "RPC client is attempting to delete remote community";
    messages["ERR_GENERIC_RPC_CLIENT_CALL_ERROR"] = "RPC client received an unknown error when executing call over websocket";
    messages["ERR_RPC_CLIENT_CHALLENGE_NAME_NOT_AVAILABLE_ON_SERVER"] = "The challenge name is not available on the RPC server. Available challenges are listed in details.availableChallenges";
    messages["ERR_ROLE_ADDRESS_NAME_COULD_NOT_BE_RESOLVED"] = "Role address name could not be resolved";
    // Community export errors
    messages["ERR_COMMUNITY_NOT_LOCAL"] = "community.export() can only be called on a LocalCommunity on this daemon";
    messages["ERR_COMMUNITY_NOT_FOUND"] = "Community is unknown to this daemon \u2014 neither name nor publicKey matches a community";
    messages["ERR_PRIVATE_KEY_EXPORT_NOT_ALLOWED"] = "The RPC server is configured to disallow exporting community private keys (allowPrivateKeyExport=false). To export with includePrivateKey=true, restart the RPC server with allowPrivateKeyExport=true";
    messages["ERR_EXPORT_PATH_NOT_SUPPORTED_OVER_RPC"] = "exportPath is only supported in embedded mode; download from the record's url instead";
    messages["ERR_EXPORT_PATH_TARGETS_LIVE_DB"] = "exportPath resolves to the live community database; refusing to overwrite it";
    messages["ERR_EXPORT_CANCELLED"] = "Community export was cancelled via AbortSignal";
    messages["ERR_EXPORT_BACKUP_FAILED"] = "Community export failed during the sqlite backup";
    messages["ERR_DOWNLOAD_EXPORT_ID_NOT_FOUND"] = "No export with that exportId exists on this RPC server";
    messages["ERR_CHALLENGE_RESULT_OVERRIDES_COMMENT_SIGNED_FIELD"] = "A challenge result attempted to set comment.<field> that is in CommentSignedPropertyNames (would invalidate the author's signature on CommentIpfs)";
    messages["ERR_CHALLENGE_RESULT_OVERRIDES_RESERVED_COMMENT_UPDATE_FIELD"] = "A challenge result attempted to set commentUpdate.<field> that is in CommentUpdateChallengeReservedFieldNames (community-computed field)";
    messages["ERR_CHALLENGE_RESULT_OVERRIDES_NON_COMMUNITY_AUTHOR_KEY"] = "A challenge result attempted to set commentUpdate.author.<field> with a key other than 'community' \u2014 challenges may only extend commentUpdate.author.community";
    messages["ERR_CHALLENGE_RESULT_OVERRIDES_RESERVED_COMMUNITY_AUTHOR_FIELD"] = "A challenge result attempted to set commentUpdate.author.community.<field> that is in CommunityAuthorChallengeReservedFieldNames (community-computed or mod-settable field)";
})(messages || (messages = {}));
//# sourceMappingURL=errors.js.map