nats-io / nats-server / 12840970505

// Generated code, do not edit. See errors.json and run go generate to update

package server

import "strings"

const (

        // JSAccountResourcesExceededErr resource limits exceeded for account

        JSAccountResourcesExceededErr ErrorIdentifier = 10002

        // JSBadRequestErr bad request

        JSBadRequestErr ErrorIdentifier = 10003

        // JSClusterIncompleteErr incomplete results

        JSClusterIncompleteErr ErrorIdentifier = 10004

        // JSClusterNoPeersErrF Error causing no peers to be available ({err})

        JSClusterNoPeersErrF ErrorIdentifier = 10005

        // JSClusterNotActiveErr JetStream not in clustered mode

        JSClusterNotActiveErr ErrorIdentifier = 10006

        // JSClusterNotAssignedErr JetStream cluster not assigned to this server

        JSClusterNotAssignedErr ErrorIdentifier = 10007

        // JSClusterNotAvailErr JetStream system temporarily unavailable

        JSClusterNotAvailErr ErrorIdentifier = 10008

        // JSClusterNotLeaderErr JetStream cluster can not handle request

        JSClusterNotLeaderErr ErrorIdentifier = 10009

        // JSClusterPeerNotMemberErr peer not a member

        JSClusterPeerNotMemberErr ErrorIdentifier = 10040

        // JSClusterRequiredErr JetStream clustering support required

        JSClusterRequiredErr ErrorIdentifier = 10010

        // JSClusterServerNotMemberErr server is not a member of the cluster

        JSClusterServerNotMemberErr ErrorIdentifier = 10044

        // JSClusterTagsErr tags placement not supported for operation

        JSClusterTagsErr ErrorIdentifier = 10011

        // JSClusterUnSupportFeatureErr not currently supported in clustered mode

        JSClusterUnSupportFeatureErr ErrorIdentifier = 10036

        // JSConsumerAlreadyExists action CREATE is used for a existing consumer with a different config (consumer already exists)

        JSConsumerAlreadyExists ErrorIdentifier = 10148

        // JSConsumerBadDurableNameErr durable name can not contain '.', '*', '>'

        JSConsumerBadDurableNameErr ErrorIdentifier = 10103

        // JSConsumerConfigRequiredErr consumer config required

        JSConsumerConfigRequiredErr ErrorIdentifier = 10078

        // JSConsumerCreateDurableAndNameMismatch Consumer Durable and Name have to be equal if both are provided

        JSConsumerCreateDurableAndNameMismatch ErrorIdentifier = 10132

        // JSConsumerCreateErrF General consumer creation failure string ({err})

        JSConsumerCreateErrF ErrorIdentifier = 10012

        // JSConsumerCreateFilterSubjectMismatchErr Consumer create request did not match filtered subject from create subject

        JSConsumerCreateFilterSubjectMismatchErr ErrorIdentifier = 10131

        // JSConsumerDeliverCycleErr consumer deliver subject forms a cycle

        JSConsumerDeliverCycleErr ErrorIdentifier = 10081

        // JSConsumerDeliverToWildcardsErr consumer deliver subject has wildcards

        JSConsumerDeliverToWildcardsErr ErrorIdentifier = 10079

        // JSConsumerDescriptionTooLongErrF consumer description is too long, maximum allowed is {max}

        JSConsumerDescriptionTooLongErrF ErrorIdentifier = 10107

        // JSConsumerDirectRequiresEphemeralErr consumer direct requires an ephemeral consumer

        JSConsumerDirectRequiresEphemeralErr ErrorIdentifier = 10091

        // JSConsumerDirectRequiresPushErr consumer direct requires a push based consumer

        JSConsumerDirectRequiresPushErr ErrorIdentifier = 10090

        // JSConsumerDoesNotExist action UPDATE is used for a nonexisting consumer (consumer does not exist)

        JSConsumerDoesNotExist ErrorIdentifier = 10149

        // JSConsumerDuplicateFilterSubjects consumer cannot have both FilterSubject and FilterSubjects specified

        JSConsumerDuplicateFilterSubjects ErrorIdentifier = 10136

        // JSConsumerDurableNameNotInSubjectErr consumer expected to be durable but no durable name set in subject

        JSConsumerDurableNameNotInSubjectErr ErrorIdentifier = 10016

        // JSConsumerDurableNameNotMatchSubjectErr consumer name in subject does not match durable name in request

        JSConsumerDurableNameNotMatchSubjectErr ErrorIdentifier = 10017

        // JSConsumerDurableNameNotSetErr consumer expected to be durable but a durable name was not set

        JSConsumerDurableNameNotSetErr ErrorIdentifier = 10018

        // JSConsumerEmptyFilter consumer filter in FilterSubjects cannot be empty

        JSConsumerEmptyFilter ErrorIdentifier = 10139

        // JSConsumerEmptyGroupName Group name cannot be an empty string

        JSConsumerEmptyGroupName ErrorIdentifier = 10161

        // JSConsumerEphemeralWithDurableInSubjectErr consumer expected to be ephemeral but detected a durable name set in subject

        JSConsumerEphemeralWithDurableInSubjectErr ErrorIdentifier = 10019

        // JSConsumerEphemeralWithDurableNameErr consumer expected to be ephemeral but a durable name was set in request

        JSConsumerEphemeralWithDurableNameErr ErrorIdentifier = 10020

        // JSConsumerExistingActiveErr consumer already exists and is still active

        JSConsumerExistingActiveErr ErrorIdentifier = 10105

        // JSConsumerFCRequiresPushErr consumer flow control requires a push based consumer

        JSConsumerFCRequiresPushErr ErrorIdentifier = 10089

        // JSConsumerFilterNotSubsetErr consumer filter subject is not a valid subset of the interest subjects

        JSConsumerFilterNotSubsetErr ErrorIdentifier = 10093

        // JSConsumerHBRequiresPushErr consumer idle heartbeat requires a push based consumer

        JSConsumerHBRequiresPushErr ErrorIdentifier = 10088

        // JSConsumerInactiveThresholdExcess consumer inactive threshold exceeds system limit of {limit}

        JSConsumerInactiveThresholdExcess ErrorIdentifier = 10153

        // JSConsumerInvalidDeliverSubject invalid push consumer deliver subject

        JSConsumerInvalidDeliverSubject ErrorIdentifier = 10112

        // JSConsumerInvalidGroupNameErr Valid priority group name must match A-Z, a-z, 0-9, -_/=)+ and may not exceed 16 characters

        JSConsumerInvalidGroupNameErr ErrorIdentifier = 10162

        // JSConsumerInvalidPolicyErrF Generic delivery policy error ({err})

        JSConsumerInvalidPolicyErrF ErrorIdentifier = 10094

        // JSConsumerInvalidPriorityGroupErr Provided priority group does not exist for this consumer

        JSConsumerInvalidPriorityGroupErr ErrorIdentifier = 10160

        // JSConsumerInvalidSamplingErrF failed to parse consumer sampling configuration: {err}

        JSConsumerInvalidSamplingErrF ErrorIdentifier = 10095

        // JSConsumerMaxDeliverBackoffErr max deliver is required to be > length of backoff values

        JSConsumerMaxDeliverBackoffErr ErrorIdentifier = 10116

        // JSConsumerMaxPendingAckExcessErrF consumer max ack pending exceeds system limit of {limit}

        JSConsumerMaxPendingAckExcessErrF ErrorIdentifier = 10121

        // JSConsumerMaxPendingAckPolicyRequiredErr consumer requires ack policy for max ack pending

        JSConsumerMaxPendingAckPolicyRequiredErr ErrorIdentifier = 10082

        // JSConsumerMaxRequestBatchExceededF consumer max request batch exceeds server limit of {limit}

        JSConsumerMaxRequestBatchExceededF ErrorIdentifier = 10125

        // JSConsumerMaxRequestBatchNegativeErr consumer max request batch needs to be > 0

        JSConsumerMaxRequestBatchNegativeErr ErrorIdentifier = 10114

        // JSConsumerMaxRequestExpiresToSmall consumer max request expires needs to be >= 1ms

        JSConsumerMaxRequestExpiresToSmall ErrorIdentifier = 10115

        // JSConsumerMaxWaitingNegativeErr consumer max waiting needs to be positive

        JSConsumerMaxWaitingNegativeErr ErrorIdentifier = 10087

        // JSConsumerMetadataLengthErrF consumer metadata exceeds maximum size of {limit}

        JSConsumerMetadataLengthErrF ErrorIdentifier = 10135

        // JSConsumerMultipleFiltersNotAllowed consumer with multiple subject filters cannot use subject based API

        JSConsumerMultipleFiltersNotAllowed ErrorIdentifier = 10137

        // JSConsumerNameContainsPathSeparatorsErr Consumer name can not contain path separators

        JSConsumerNameContainsPathSeparatorsErr ErrorIdentifier = 10127

        // JSConsumerNameExistErr consumer name already in use

        JSConsumerNameExistErr ErrorIdentifier = 10013

        // JSConsumerNameTooLongErrF consumer name is too long, maximum allowed is {max}

        JSConsumerNameTooLongErrF ErrorIdentifier = 10102

        // JSConsumerNotFoundErr consumer not found

        JSConsumerNotFoundErr ErrorIdentifier = 10014

        // JSConsumerOfflineErr consumer is offline

        JSConsumerOfflineErr ErrorIdentifier = 10119

        // JSConsumerOnMappedErr consumer direct on a mapped consumer

        JSConsumerOnMappedErr ErrorIdentifier = 10092

        // JSConsumerOverlappingSubjectFilters consumer subject filters cannot overlap

        JSConsumerOverlappingSubjectFilters ErrorIdentifier = 10138

        // JSConsumerPriorityPolicyWithoutGroup Setting PriorityPolicy requires at least one PriorityGroup to be set

        JSConsumerPriorityPolicyWithoutGroup ErrorIdentifier = 10159

        // JSConsumerPullNotDurableErr consumer in pull mode requires a durable name

        JSConsumerPullNotDurableErr ErrorIdentifier = 10085

        // JSConsumerPullRequiresAckErr consumer in pull mode requires explicit ack policy on workqueue stream

        JSConsumerPullRequiresAckErr ErrorIdentifier = 10084

        // JSConsumerPullWithRateLimitErr consumer in pull mode can not have rate limit set

        JSConsumerPullWithRateLimitErr ErrorIdentifier = 10086

        // JSConsumerPushMaxWaitingErr consumer in push mode can not set max waiting

        JSConsumerPushMaxWaitingErr ErrorIdentifier = 10080

        // JSConsumerReplacementWithDifferentNameErr consumer replacement durable config not the same

        JSConsumerReplacementWithDifferentNameErr ErrorIdentifier = 10106

        // JSConsumerReplicasExceedsStream consumer config replica count exceeds parent stream

        JSConsumerReplicasExceedsStream ErrorIdentifier = 10126

        // JSConsumerReplicasShouldMatchStream consumer config replicas must match interest retention stream's replicas

        JSConsumerReplicasShouldMatchStream ErrorIdentifier = 10134

        // JSConsumerSmallHeartbeatErr consumer idle heartbeat needs to be >= 100ms

        JSConsumerSmallHeartbeatErr ErrorIdentifier = 10083

        // JSConsumerStoreFailedErrF error creating store for consumer: {err}

        JSConsumerStoreFailedErrF ErrorIdentifier = 10104

        // JSConsumerWQConsumerNotDeliverAllErr consumer must be deliver all on workqueue stream

        JSConsumerWQConsumerNotDeliverAllErr ErrorIdentifier = 10101

        // JSConsumerWQConsumerNotUniqueErr filtered consumer not unique on workqueue stream

        JSConsumerWQConsumerNotUniqueErr ErrorIdentifier = 10100

        // JSConsumerWQMultipleUnfilteredErr multiple non-filtered consumers not allowed on workqueue stream

        JSConsumerWQMultipleUnfilteredErr ErrorIdentifier = 10099

        // JSConsumerWQRequiresExplicitAckErr workqueue stream requires explicit ack

        JSConsumerWQRequiresExplicitAckErr ErrorIdentifier = 10098

        // JSConsumerWithFlowControlNeedsHeartbeats consumer with flow control also needs heartbeats

        JSConsumerWithFlowControlNeedsHeartbeats ErrorIdentifier = 10108

        // JSInsufficientResourcesErr insufficient resources

        JSInsufficientResourcesErr ErrorIdentifier = 10023

        // JSInvalidJSONErr invalid JSON: {err}

        JSInvalidJSONErr ErrorIdentifier = 10025

        // JSMaximumConsumersLimitErr maximum consumers limit reached

        JSMaximumConsumersLimitErr ErrorIdentifier = 10026

        // JSMaximumStreamsLimitErr maximum number of streams reached

        JSMaximumStreamsLimitErr ErrorIdentifier = 10027

        // JSMemoryResourcesExceededErr insufficient memory resources available

        JSMemoryResourcesExceededErr ErrorIdentifier = 10028

        // JSMessageTTLDisabledErr per-message TTL is disabled

        JSMessageTTLDisabledErr ErrorIdentifier = 10166

        // JSMessageTTLInvalidErr invalid per-message TTL

        JSMessageTTLInvalidErr ErrorIdentifier = 10165

        // JSMirrorConsumerSetupFailedErrF generic mirror consumer setup failure string ({err})

        JSMirrorConsumerSetupFailedErrF ErrorIdentifier = 10029

        // JSMirrorInvalidStreamName mirrored stream name is invalid

        JSMirrorInvalidStreamName ErrorIdentifier = 10142

        // JSMirrorInvalidSubjectFilter mirror transform source: {err}

        JSMirrorInvalidSubjectFilter ErrorIdentifier = 10151

        // JSMirrorInvalidTransformDestination mirror transform: {err}

        JSMirrorInvalidTransformDestination ErrorIdentifier = 10154

        // JSMirrorMaxMessageSizeTooBigErr stream mirror must have max message size >= source

        JSMirrorMaxMessageSizeTooBigErr ErrorIdentifier = 10030

        // JSMirrorMultipleFiltersNotAllowed mirror with multiple subject transforms cannot also have a single subject filter

        JSMirrorMultipleFiltersNotAllowed ErrorIdentifier = 10150

        // JSMirrorOverlappingSubjectFilters mirror subject filters can not overlap

        JSMirrorOverlappingSubjectFilters ErrorIdentifier = 10152

        // JSMirrorWithFirstSeqErr stream mirrors can not have first sequence configured

        JSMirrorWithFirstSeqErr ErrorIdentifier = 10143

        // JSMirrorWithSourcesErr stream mirrors can not also contain other sources

        JSMirrorWithSourcesErr ErrorIdentifier = 10031

        // JSMirrorWithStartSeqAndTimeErr stream mirrors can not have both start seq and start time configured

        JSMirrorWithStartSeqAndTimeErr ErrorIdentifier = 10032

        // JSMirrorWithSubjectFiltersErr stream mirrors can not contain filtered subjects

        JSMirrorWithSubjectFiltersErr ErrorIdentifier = 10033

        // JSMirrorWithSubjectsErr stream mirrors can not contain subjects

        JSMirrorWithSubjectsErr ErrorIdentifier = 10034

        // JSNoAccountErr account not found

        JSNoAccountErr ErrorIdentifier = 10035

        // JSNoLimitsErr no JetStream default or applicable tiered limit present

        JSNoLimitsErr ErrorIdentifier = 10120

        // JSNoMessageFoundErr no message found

        JSNoMessageFoundErr ErrorIdentifier = 10037

        // JSNotEmptyRequestErr expected an empty request payload

        JSNotEmptyRequestErr ErrorIdentifier = 10038

        // JSNotEnabledErr JetStream not enabled

        JSNotEnabledErr ErrorIdentifier = 10076

        // JSNotEnabledForAccountErr JetStream not enabled for account

        JSNotEnabledForAccountErr ErrorIdentifier = 10039

        // JSPedanticErrF pedantic mode: {err}

        JSPedanticErrF ErrorIdentifier = 10157

        // JSPeerRemapErr peer remap failed

        JSPeerRemapErr ErrorIdentifier = 10075

        // JSRaftGeneralErrF General RAFT error string ({err})

        JSRaftGeneralErrF ErrorIdentifier = 10041

        // JSReplicasCountCannotBeNegative replicas count cannot be negative

        JSReplicasCountCannotBeNegative ErrorIdentifier = 10133

        // JSRestoreSubscribeFailedErrF JetStream unable to subscribe to restore snapshot {subject}: {err}

        JSRestoreSubscribeFailedErrF ErrorIdentifier = 10042

        // JSSequenceNotFoundErrF sequence {seq} not found

        JSSequenceNotFoundErrF ErrorIdentifier = 10043

        // JSSnapshotDeliverSubjectInvalidErr deliver subject not valid

        JSSnapshotDeliverSubjectInvalidErr ErrorIdentifier = 10015

        // JSSourceConsumerSetupFailedErrF General source consumer setup failure string ({err})

        JSSourceConsumerSetupFailedErrF ErrorIdentifier = 10045

        // JSSourceDuplicateDetected source stream, filter and transform (plus external if present) must form a unique combination (duplicate source configuration detected)

        JSSourceDuplicateDetected ErrorIdentifier = 10140

        // JSSourceInvalidStreamName sourced stream name is invalid

        JSSourceInvalidStreamName ErrorIdentifier = 10141

        // JSSourceInvalidSubjectFilter source transform source: {err}

        JSSourceInvalidSubjectFilter ErrorIdentifier = 10145

        // JSSourceInvalidTransformDestination source transform: {err}

        JSSourceInvalidTransformDestination ErrorIdentifier = 10146

        // JSSourceMaxMessageSizeTooBigErr stream source must have max message size >= target

        JSSourceMaxMessageSizeTooBigErr ErrorIdentifier = 10046

        // JSSourceMultipleFiltersNotAllowed source with multiple subject transforms cannot also have a single subject filter

        JSSourceMultipleFiltersNotAllowed ErrorIdentifier = 10144

        // JSSourceOverlappingSubjectFilters source filters can not overlap

        JSSourceOverlappingSubjectFilters ErrorIdentifier = 10147

        // JSStorageResourcesExceededErr insufficient storage resources available

        JSStorageResourcesExceededErr ErrorIdentifier = 10047

        // JSStreamAssignmentErrF Generic stream assignment error string ({err})

        JSStreamAssignmentErrF ErrorIdentifier = 10048

        // JSStreamCreateErrF Generic stream creation error string ({err})

        JSStreamCreateErrF ErrorIdentifier = 10049

        // JSStreamDeleteErrF General stream deletion error string ({err})

        JSStreamDeleteErrF ErrorIdentifier = 10050

        // JSStreamDuplicateMessageConflict duplicate message id is in process

        JSStreamDuplicateMessageConflict ErrorIdentifier = 10158

        // JSStreamExpectedLastSeqPerSubjectNotReady expected last sequence per subject temporarily unavailable

        JSStreamExpectedLastSeqPerSubjectNotReady ErrorIdentifier = 10163

        // JSStreamExternalApiOverlapErrF stream external api prefix {prefix} must not overlap with {subject}

        JSStreamExternalApiOverlapErrF ErrorIdentifier = 10021

        // JSStreamExternalDelPrefixOverlapsErrF stream external delivery prefix {prefix} overlaps with stream subject {subject}

        JSStreamExternalDelPrefixOverlapsErrF ErrorIdentifier = 10022

        // JSStreamGeneralErrorF General stream failure string ({err})

        JSStreamGeneralErrorF ErrorIdentifier = 10051

        // JSStreamHeaderExceedsMaximumErr header size exceeds maximum allowed of 64k

        JSStreamHeaderExceedsMaximumErr ErrorIdentifier = 10097

        // JSStreamInfoMaxSubjectsErr subject details would exceed maximum allowed

        JSStreamInfoMaxSubjectsErr ErrorIdentifier = 10117

        // JSStreamInvalidConfigF Stream configuration validation error string ({err})

        JSStreamInvalidConfigF ErrorIdentifier = 10052

        // JSStreamInvalidErr stream not valid

        JSStreamInvalidErr ErrorIdentifier = 10096

        // JSStreamInvalidExternalDeliverySubjErrF stream external delivery prefix {prefix} must not contain wildcards

        JSStreamInvalidExternalDeliverySubjErrF ErrorIdentifier = 10024

        // JSStreamLimitsErrF General stream limits exceeded error string ({err})

        JSStreamLimitsErrF ErrorIdentifier = 10053

        // JSStreamMaxBytesRequired account requires a stream config to have max bytes set

        JSStreamMaxBytesRequired ErrorIdentifier = 10113

        // JSStreamMaxStreamBytesExceeded stream max bytes exceeds account limit max stream bytes

        JSStreamMaxStreamBytesExceeded ErrorIdentifier = 10122

        // JSStreamMessageExceedsMaximumErr message size exceeds maximum allowed

        JSStreamMessageExceedsMaximumErr ErrorIdentifier = 10054

        // JSStreamMirrorNotUpdatableErr stream mirror configuration can not be updated

        JSStreamMirrorNotUpdatableErr ErrorIdentifier = 10055

        // JSStreamMismatchErr stream name in subject does not match request

        JSStreamMismatchErr ErrorIdentifier = 10056

        // JSStreamMoveAndScaleErr can not move and scale a stream in a single update

        JSStreamMoveAndScaleErr ErrorIdentifier = 10123

        // JSStreamMoveInProgressF stream move already in progress: {msg}

        JSStreamMoveInProgressF ErrorIdentifier = 10124

        // JSStreamMoveNotInProgress stream move not in progress

        JSStreamMoveNotInProgress ErrorIdentifier = 10129

        // JSStreamMsgDeleteFailedF Generic message deletion failure error string ({err})

        JSStreamMsgDeleteFailedF ErrorIdentifier = 10057

        // JSStreamNameContainsPathSeparatorsErr Stream name can not contain path separators

        JSStreamNameContainsPathSeparatorsErr ErrorIdentifier = 10128

        // JSStreamNameExistErr stream name already in use with a different configuration

        JSStreamNameExistErr ErrorIdentifier = 10058

        // JSStreamNameExistRestoreFailedErr stream name already in use, cannot restore

        JSStreamNameExistRestoreFailedErr ErrorIdentifier = 10130

        // JSStreamNotFoundErr stream not found

        JSStreamNotFoundErr ErrorIdentifier = 10059

        // JSStreamNotMatchErr expected stream does not match

        JSStreamNotMatchErr ErrorIdentifier = 10060

        // JSStreamOfflineErr stream is offline

        JSStreamOfflineErr ErrorIdentifier = 10118

        // JSStreamPurgeFailedF Generic stream purge failure error string ({err})

        JSStreamPurgeFailedF ErrorIdentifier = 10110

        // JSStreamReplicasNotSupportedErr replicas > 1 not supported in non-clustered mode

        JSStreamReplicasNotSupportedErr ErrorIdentifier = 10074

        // JSStreamReplicasNotUpdatableErr Replicas configuration can not be updated

        JSStreamReplicasNotUpdatableErr ErrorIdentifier = 10061

        // JSStreamRestoreErrF restore failed: {err}

        JSStreamRestoreErrF ErrorIdentifier = 10062

        // JSStreamRollupFailedF Generic stream rollup failure error string ({err})

        JSStreamRollupFailedF ErrorIdentifier = 10111

        // JSStreamSealedErr invalid operation on sealed stream

        JSStreamSealedErr ErrorIdentifier = 10109

        // JSStreamSequenceNotMatchErr expected stream sequence does not match

        JSStreamSequenceNotMatchErr ErrorIdentifier = 10063

        // JSStreamSnapshotErrF snapshot failed: {err}

        JSStreamSnapshotErrF ErrorIdentifier = 10064

        // JSStreamStoreFailedF Generic error when storing a message failed ({err})

        JSStreamStoreFailedF ErrorIdentifier = 10077

        // JSStreamSubjectOverlapErr subjects overlap with an existing stream

        JSStreamSubjectOverlapErr ErrorIdentifier = 10065

        // JSStreamTemplateCreateErrF Generic template creation failed string ({err})

        JSStreamTemplateCreateErrF ErrorIdentifier = 10066

        // JSStreamTemplateDeleteErrF Generic stream template deletion failed error string ({err})

        JSStreamTemplateDeleteErrF ErrorIdentifier = 10067

        // JSStreamTemplateNotFoundErr template not found

        JSStreamTemplateNotFoundErr ErrorIdentifier = 10068

        // JSStreamTransformInvalidDestination stream transform: {err}

        JSStreamTransformInvalidDestination ErrorIdentifier = 10156

        // JSStreamTransformInvalidSource stream transform source: {err}

        JSStreamTransformInvalidSource ErrorIdentifier = 10155

        // JSStreamUpdateErrF Generic stream update error string ({err})

        JSStreamUpdateErrF ErrorIdentifier = 10069

        // JSStreamWrongLastMsgIDErrF wrong last msg ID: {id}

        JSStreamWrongLastMsgIDErrF ErrorIdentifier = 10070

        // JSStreamWrongLastSequenceConstantErr wrong last sequence

        JSStreamWrongLastSequenceConstantErr ErrorIdentifier = 10164

        // JSStreamWrongLastSequenceErrF wrong last sequence: {seq}

        JSStreamWrongLastSequenceErrF ErrorIdentifier = 10071

        // JSTempStorageFailedErr JetStream unable to open temp storage for restore

        JSTempStorageFailedErr ErrorIdentifier = 10072

        // JSTemplateNameNotMatchSubjectErr template name in subject does not match request

        JSTemplateNameNotMatchSubjectErr ErrorIdentifier = 10073

)

var (

        ApiErrors = map[ErrorIdentifier]*ApiError{

                JSAccountResourcesExceededErr:              {Code: 400, ErrCode: 10002, Description: "resource limits exceeded for account"},

                JSBadRequestErr:                            {Code: 400, ErrCode: 10003, Description: "bad request"},

                JSClusterIncompleteErr:                     {Code: 503, ErrCode: 10004, Description: "incomplete results"},

                JSClusterNoPeersErrF:                       {Code: 400, ErrCode: 10005, Description: "{err}"},

                JSClusterNotActiveErr:                      {Code: 500, ErrCode: 10006, Description: "JetStream not in clustered mode"},

                JSClusterNotAssignedErr:                    {Code: 500, ErrCode: 10007, Description: "JetStream cluster not assigned to this server"},

                JSClusterNotAvailErr:                       {Code: 503, ErrCode: 10008, Description: "JetStream system temporarily unavailable"},

                JSClusterNotLeaderErr:                      {Code: 500, ErrCode: 10009, Description: "JetStream cluster can not handle request"},

                JSClusterPeerNotMemberErr:                  {Code: 400, ErrCode: 10040, Description: "peer not a member"},

                JSClusterRequiredErr:                       {Code: 503, ErrCode: 10010, Description: "JetStream clustering support required"},

                JSClusterServerNotMemberErr:                {Code: 400, ErrCode: 10044, Description: "server is not a member of the cluster"},

                JSClusterTagsErr:                           {Code: 400, ErrCode: 10011, Description: "tags placement not supported for operation"},

                JSClusterUnSupportFeatureErr:               {Code: 503, ErrCode: 10036, Description: "not currently supported in clustered mode"},

                JSConsumerAlreadyExists:                    {Code: 400, ErrCode: 10148, Description: "consumer already exists"},

                JSConsumerBadDurableNameErr:                {Code: 400, ErrCode: 10103, Description: "durable name can not contain '.', '*', '>'"},

                JSConsumerConfigRequiredErr:                {Code: 400, ErrCode: 10078, Description: "consumer config required"},

                JSConsumerCreateDurableAndNameMismatch:     {Code: 400, ErrCode: 10132, Description: "Consumer Durable and Name have to be equal if both are provided"},

                JSConsumerCreateErrF:                       {Code: 500, ErrCode: 10012, Description: "{err}"},

                JSConsumerCreateFilterSubjectMismatchErr:   {Code: 400, ErrCode: 10131, Description: "Consumer create request did not match filtered subject from create subject"},

                JSConsumerDeliverCycleErr:                  {Code: 400, ErrCode: 10081, Description: "consumer deliver subject forms a cycle"},

                JSConsumerDeliverToWildcardsErr:            {Code: 400, ErrCode: 10079, Description: "consumer deliver subject has wildcards"},

                JSConsumerDescriptionTooLongErrF:           {Code: 400, ErrCode: 10107, Description: "consumer description is too long, maximum allowed is {max}"},

                JSConsumerDirectRequiresEphemeralErr:       {Code: 400, ErrCode: 10091, Description: "consumer direct requires an ephemeral consumer"},

                JSConsumerDirectRequiresPushErr:            {Code: 400, ErrCode: 10090, Description: "consumer direct requires a push based consumer"},

                JSConsumerDoesNotExist:                     {Code: 400, ErrCode: 10149, Description: "consumer does not exist"},

                JSConsumerDuplicateFilterSubjects:          {Code: 400, ErrCode: 10136, Description: "consumer cannot have both FilterSubject and FilterSubjects specified"},

                JSConsumerDurableNameNotInSubjectErr:       {Code: 400, ErrCode: 10016, Description: "consumer expected to be durable but no durable name set in subject"},

                JSConsumerDurableNameNotMatchSubjectErr:    {Code: 400, ErrCode: 10017, Description: "consumer name in subject does not match durable name in request"},

                JSConsumerDurableNameNotSetErr:             {Code: 400, ErrCode: 10018, Description: "consumer expected to be durable but a durable name was not set"},

                JSConsumerEmptyFilter:                      {Code: 400, ErrCode: 10139, Description: "consumer filter in FilterSubjects cannot be empty"},

                JSConsumerEmptyGroupName:                   {Code: 400, ErrCode: 10161, Description: "Group name cannot be an empty string"},

                JSConsumerEphemeralWithDurableInSubjectErr: {Code: 400, ErrCode: 10019, Description: "consumer expected to be ephemeral but detected a durable name set in subject"},

                JSConsumerEphemeralWithDurableNameErr:      {Code: 400, ErrCode: 10020, Description: "consumer expected to be ephemeral but a durable name was set in request"},

                JSConsumerExistingActiveErr:                {Code: 400, ErrCode: 10105, Description: "consumer already exists and is still active"},

                JSConsumerFCRequiresPushErr:                {Code: 400, ErrCode: 10089, Description: "consumer flow control requires a push based consumer"},

                JSConsumerFilterNotSubsetErr:               {Code: 400, ErrCode: 10093, Description: "consumer filter subject is not a valid subset of the interest subjects"},

                JSConsumerHBRequiresPushErr:                {Code: 400, ErrCode: 10088, Description: "consumer idle heartbeat requires a push based consumer"},

                JSConsumerInactiveThresholdExcess:          {Code: 400, ErrCode: 10153, Description: "consumer inactive threshold exceeds system limit of {limit}"},

                JSConsumerInvalidDeliverSubject:            {Code: 400, ErrCode: 10112, Description: "invalid push consumer deliver subject"},

                JSConsumerInvalidGroupNameErr:              {Code: 400, ErrCode: 10162, Description: "Valid priority group name must match A-Z, a-z, 0-9, -_/=)+ and may not exceed 16 characters"},

                JSConsumerInvalidPolicyErrF:                {Code: 400, ErrCode: 10094, Description: "{err}"},

                JSConsumerInvalidPriorityGroupErr:          {Code: 400, ErrCode: 10160, Description: "Provided priority group does not exist for this consumer"},

                JSConsumerInvalidSamplingErrF:              {Code: 400, ErrCode: 10095, Description: "failed to parse consumer sampling configuration: {err}"},

                JSConsumerMaxDeliverBackoffErr:             {Code: 400, ErrCode: 10116, Description: "max deliver is required to be > length of backoff values"},

                JSConsumerMaxPendingAckExcessErrF:          {Code: 400, ErrCode: 10121, Description: "consumer max ack pending exceeds system limit of {limit}"},

                JSConsumerMaxPendingAckPolicyRequiredErr:   {Code: 400, ErrCode: 10082, Description: "consumer requires ack policy for max ack pending"},

                JSConsumerMaxRequestBatchExceededF:         {Code: 400, ErrCode: 10125, Description: "consumer max request batch exceeds server limit of {limit}"},

                JSConsumerMaxRequestBatchNegativeErr:       {Code: 400, ErrCode: 10114, Description: "consumer max request batch needs to be > 0"},

                JSConsumerMaxRequestExpiresToSmall:         {Code: 400, ErrCode: 10115, Description: "consumer max request expires needs to be >= 1ms"},

                JSConsumerMaxWaitingNegativeErr:            {Code: 400, ErrCode: 10087, Description: "consumer max waiting needs to be positive"},

                JSConsumerMetadataLengthErrF:               {Code: 400, ErrCode: 10135, Description: "consumer metadata exceeds maximum size of {limit}"},

                JSConsumerMultipleFiltersNotAllowed:        {Code: 400, ErrCode: 10137, Description: "consumer with multiple subject filters cannot use subject based API"},

                JSConsumerNameContainsPathSeparatorsErr:    {Code: 400, ErrCode: 10127, Description: "Consumer name can not contain path separators"},

                JSConsumerNameExistErr:                     {Code: 400, ErrCode: 10013, Description: "consumer name already in use"},

                JSConsumerNameTooLongErrF:                  {Code: 400, ErrCode: 10102, Description: "consumer name is too long, maximum allowed is {max}"},

                JSConsumerNotFoundErr:                      {Code: 404, ErrCode: 10014, Description: "consumer not found"},

                JSConsumerOfflineErr:                       {Code: 500, ErrCode: 10119, Description: "consumer is offline"},

                JSConsumerOnMappedErr:                      {Code: 400, ErrCode: 10092, Description: "consumer direct on a mapped consumer"},

                JSConsumerOverlappingSubjectFilters:        {Code: 400, ErrCode: 10138, Description: "consumer subject filters cannot overlap"},

                JSConsumerPriorityPolicyWithoutGroup:       {Code: 400, ErrCode: 10159, Description: "Setting PriorityPolicy requires at least one PriorityGroup to be set"},

                JSConsumerPullNotDurableErr:                {Code: 400, ErrCode: 10085, Description: "consumer in pull mode requires a durable name"},

                JSConsumerPullRequiresAckErr:               {Code: 400, ErrCode: 10084, Description: "consumer in pull mode requires explicit ack policy on workqueue stream"},

                JSConsumerPullWithRateLimitErr:             {Code: 400, ErrCode: 10086, Description: "consumer in pull mode can not have rate limit set"},

                JSConsumerPushMaxWaitingErr:                {Code: 400, ErrCode: 10080, Description: "consumer in push mode can not set max waiting"},

                JSConsumerReplacementWithDifferentNameErr:  {Code: 400, ErrCode: 10106, Description: "consumer replacement durable config not the same"},

                JSConsumerReplicasExceedsStream:            {Code: 400, ErrCode: 10126, Description: "consumer config replica count exceeds parent stream"},

                JSConsumerReplicasShouldMatchStream:        {Code: 400, ErrCode: 10134, Description: "consumer config replicas must match interest retention stream's replicas"},

                JSConsumerSmallHeartbeatErr:                {Code: 400, ErrCode: 10083, Description: "consumer idle heartbeat needs to be >= 100ms"},

                JSConsumerStoreFailedErrF:                  {Code: 500, ErrCode: 10104, Description: "error creating store for consumer: {err}"},

                JSConsumerWQConsumerNotDeliverAllErr:       {Code: 400, ErrCode: 10101, Description: "consumer must be deliver all on workqueue stream"},

                JSConsumerWQConsumerNotUniqueErr:           {Code: 400, ErrCode: 10100, Description: "filtered consumer not unique on workqueue stream"},

                JSConsumerWQMultipleUnfilteredErr:          {Code: 400, ErrCode: 10099, Description: "multiple non-filtered consumers not allowed on workqueue stream"},

                JSConsumerWQRequiresExplicitAckErr:         {Code: 400, ErrCode: 10098, Description: "workqueue stream requires explicit ack"},

                JSConsumerWithFlowControlNeedsHeartbeats:   {Code: 400, ErrCode: 10108, Description: "consumer with flow control also needs heartbeats"},

                JSInsufficientResourcesErr:                 {Code: 503, ErrCode: 10023, Description: "insufficient resources"},

                JSInvalidJSONErr:                           {Code: 400, ErrCode: 10025, Description: "invalid JSON: {err}"},

                JSMaximumConsumersLimitErr:                 {Code: 400, ErrCode: 10026, Description: "maximum consumers limit reached"},

                JSMaximumStreamsLimitErr:                   {Code: 400, ErrCode: 10027, Description: "maximum number of streams reached"},

                JSMemoryResourcesExceededErr:               {Code: 500, ErrCode: 10028, Description: "insufficient memory resources available"},

                JSMessageTTLDisabledErr:                    {Code: 400, ErrCode: 10166, Description: "per-message TTL is disabled"},

                JSMessageTTLInvalidErr:                     {Code: 400, ErrCode: 10165, Description: "invalid per-message TTL"},

                JSMirrorConsumerSetupFailedErrF:            {Code: 500, ErrCode: 10029, Description: "{err}"},

                JSMirrorInvalidStreamName:                  {Code: 400, ErrCode: 10142, Description: "mirrored stream name is invalid"},

                JSMirrorInvalidSubjectFilter:               {Code: 400, ErrCode: 10151, Description: "mirror transform source: {err}"},

                JSMirrorInvalidTransformDestination:        {Code: 400, ErrCode: 10154, Description: "mirror transform: {err}"},

                JSMirrorMaxMessageSizeTooBigErr:            {Code: 400, ErrCode: 10030, Description: "stream mirror must have max message size >= source"},

                JSMirrorMultipleFiltersNotAllowed:          {Code: 400, ErrCode: 10150, Description: "mirror with multiple subject transforms cannot also have a single subject filter"},

                JSMirrorOverlappingSubjectFilters:          {Code: 400, ErrCode: 10152, Description: "mirror subject filters can not overlap"},

                JSMirrorWithFirstSeqErr:                    {Code: 400, ErrCode: 10143, Description: "stream mirrors can not have first sequence configured"},

                JSMirrorWithSourcesErr:                     {Code: 400, ErrCode: 10031, Description: "stream mirrors can not also contain other sources"},

                JSMirrorWithStartSeqAndTimeErr:             {Code: 400, ErrCode: 10032, Description: "stream mirrors can not have both start seq and start time configured"},

                JSMirrorWithSubjectFiltersErr:              {Code: 400, ErrCode: 10033, Description: "stream mirrors can not contain filtered subjects"},

                JSMirrorWithSubjectsErr:                    {Code: 400, ErrCode: 10034, Description: "stream mirrors can not contain subjects"},

                JSNoAccountErr:                             {Code: 503, ErrCode: 10035, Description: "account not found"},

                JSNoLimitsErr:                              {Code: 400, ErrCode: 10120, Description: "no JetStream default or applicable tiered limit present"},

                JSNoMessageFoundErr:                        {Code: 404, ErrCode: 10037, Description: "no message found"},

                JSNotEmptyRequestErr:                       {Code: 400, ErrCode: 10038, Description: "expected an empty request payload"},

                JSNotEnabledErr:                            {Code: 503, ErrCode: 10076, Description: "JetStream not enabled"},

                JSNotEnabledForAccountErr:                  {Code: 503, ErrCode: 10039, Description: "JetStream not enabled for account"},

                JSPedanticErrF:                             {Code: 400, ErrCode: 10157, Description: "pedantic mode: {err}"},

                JSPeerRemapErr:                             {Code: 503, ErrCode: 10075, Description: "peer remap failed"},

                JSRaftGeneralErrF:                          {Code: 500, ErrCode: 10041, Description: "{err}"},

                JSReplicasCountCannotBeNegative:            {Code: 400, ErrCode: 10133, Description: "replicas count cannot be negative"},

                JSRestoreSubscribeFailedErrF:               {Code: 500, ErrCode: 10042, Description: "JetStream unable to subscribe to restore snapshot {subject}: {err}"},

                JSSequenceNotFoundErrF:                     {Code: 400, ErrCode: 10043, Description: "sequence {seq} not found"},

                JSSnapshotDeliverSubjectInvalidErr:         {Code: 400, ErrCode: 10015, Description: "deliver subject not valid"},

                JSSourceConsumerSetupFailedErrF:            {Code: 500, ErrCode: 10045, Description: "{err}"},

                JSSourceDuplicateDetected:                  {Code: 400, ErrCode: 10140, Description: "duplicate source configuration detected"},

                JSSourceInvalidStreamName:                  {Code: 400, ErrCode: 10141, Description: "sourced stream name is invalid"},

                JSSourceInvalidSubjectFilter:               {Code: 400, ErrCode: 10145, Description: "source transform source: {err}"},

                JSSourceInvalidTransformDestination:        {Code: 400, ErrCode: 10146, Description: "source transform: {err}"},

                JSSourceMaxMessageSizeTooBigErr:            {Code: 400, ErrCode: 10046, Description: "stream source must have max message size >= target"},

                JSSourceMultipleFiltersNotAllowed:          {Code: 400, ErrCode: 10144, Description: "source with multiple subject transforms cannot also have a single subject filter"},

                JSSourceOverlappingSubjectFilters:          {Code: 400, ErrCode: 10147, Description: "source filters can not overlap"},

                JSStorageResourcesExceededErr:              {Code: 500, ErrCode: 10047, Description: "insufficient storage resources available"},

                JSStreamAssignmentErrF:                     {Code: 500, ErrCode: 10048, Description: "{err}"},

                JSStreamCreateErrF:                         {Code: 500, ErrCode: 10049, Description: "{err}"},

                JSStreamDeleteErrF:                         {Code: 500, ErrCode: 10050, Description: "{err}"},

                JSStreamDuplicateMessageConflict:           {Code: 409, ErrCode: 10158, Description: "duplicate message id is in process"},

                JSStreamExpectedLastSeqPerSubjectNotReady:  {Code: 503, ErrCode: 10163, Description: "expected last sequence per subject temporarily unavailable"},

                JSStreamExternalApiOverlapErrF:             {Code: 400, ErrCode: 10021, Description: "stream external api prefix {prefix} must not overlap with {subject}"},

                JSStreamExternalDelPrefixOverlapsErrF:      {Code: 400, ErrCode: 10022, Description: "stream external delivery prefix {prefix} overlaps with stream subject {subject}"},

                JSStreamGeneralErrorF:                      {Code: 500, ErrCode: 10051, Description: "{err}"},

                JSStreamHeaderExceedsMaximumErr:            {Code: 400, ErrCode: 10097, Description: "header size exceeds maximum allowed of 64k"},

                JSStreamInfoMaxSubjectsErr:                 {Code: 500, ErrCode: 10117, Description: "subject details would exceed maximum allowed"},

                JSStreamInvalidConfigF:                     {Code: 500, ErrCode: 10052, Description: "{err}"},

                JSStreamInvalidErr:                         {Code: 500, ErrCode: 10096, Description: "stream not valid"},

                JSStreamInvalidExternalDeliverySubjErrF:    {Code: 400, ErrCode: 10024, Description: "stream external delivery prefix {prefix} must not contain wildcards"},

                JSStreamLimitsErrF:                         {Code: 500, ErrCode: 10053, Description: "{err}"},

                JSStreamMaxBytesRequired:                   {Code: 400, ErrCode: 10113, Description: "account requires a stream config to have max bytes set"},

                JSStreamMaxStreamBytesExceeded:             {Code: 400, ErrCode: 10122, Description: "stream max bytes exceeds account limit max stream bytes"},

                JSStreamMessageExceedsMaximumErr:           {Code: 400, ErrCode: 10054, Description: "message size exceeds maximum allowed"},

                JSStreamMirrorNotUpdatableErr:              {Code: 400, ErrCode: 10055, Description: "stream mirror configuration can not be updated"},

                JSStreamMismatchErr:                        {Code: 400, ErrCode: 10056, Description: "stream name in subject does not match request"},

                JSStreamMoveAndScaleErr:                    {Code: 400, ErrCode: 10123, Description: "can not move and scale a stream in a single update"},

                JSStreamMoveInProgressF:                    {Code: 400, ErrCode: 10124, Description: "stream move already in progress: {msg}"},

                JSStreamMoveNotInProgress:                  {Code: 400, ErrCode: 10129, Description: "stream move not in progress"},

                JSStreamMsgDeleteFailedF:                   {Code: 500, ErrCode: 10057, Description: "{err}"},

                JSStreamNameContainsPathSeparatorsErr:      {Code: 400, ErrCode: 10128, Description: "Stream name can not contain path separators"},

                JSStreamNameExistErr:                       {Code: 400, ErrCode: 10058, Description: "stream name already in use with a different configuration"},

                JSStreamNameExistRestoreFailedErr:          {Code: 400, ErrCode: 10130, Description: "stream name already in use, cannot restore"},

                JSStreamNotFoundErr:                        {Code: 404, ErrCode: 10059, Description: "stream not found"},

                JSStreamNotMatchErr:                        {Code: 400, ErrCode: 10060, Description: "expected stream does not match"},

                JSStreamOfflineErr:                         {Code: 500, ErrCode: 10118, Description: "stream is offline"},

                JSStreamPurgeFailedF:                       {Code: 500, ErrCode: 10110, Description: "{err}"},

                JSStreamReplicasNotSupportedErr:            {Code: 500, ErrCode: 10074, Description: "replicas > 1 not supported in non-clustered mode"},

                JSStreamReplicasNotUpdatableErr:            {Code: 400, ErrCode: 10061, Description: "Replicas configuration can not be updated"},

                JSStreamRestoreErrF:                        {Code: 500, ErrCode: 10062, Description: "restore failed: {err}"},

                JSStreamRollupFailedF:                      {Code: 500, ErrCode: 10111, Description: "{err}"},

                JSStreamSealedErr:                          {Code: 400, ErrCode: 10109, Description: "invalid operation on sealed stream"},

                JSStreamSequenceNotMatchErr:                {Code: 503, ErrCode: 10063, Description: "expected stream sequence does not match"},

                JSStreamSnapshotErrF:                       {Code: 500, ErrCode: 10064, Description: "snapshot failed: {err}"},

                JSStreamStoreFailedF:                       {Code: 503, ErrCode: 10077, Description: "{err}"},

                JSStreamSubjectOverlapErr:                  {Code: 400, ErrCode: 10065, Description: "subjects overlap with an existing stream"},

                JSStreamTemplateCreateErrF:                 {Code: 500, ErrCode: 10066, Description: "{err}"},

                JSStreamTemplateDeleteErrF:                 {Code: 500, ErrCode: 10067, Description: "{err}"},

                JSStreamTemplateNotFoundErr:                {Code: 404, ErrCode: 10068, Description: "template not found"},

                JSStreamTransformInvalidDestination:        {Code: 400, ErrCode: 10156, Description: "stream transform: {err}"},

                JSStreamTransformInvalidSource:             {Code: 400, ErrCode: 10155, Description: "stream transform source: {err}"},

                JSStreamUpdateErrF:                         {Code: 500, ErrCode: 10069, Description: "{err}"},

                JSStreamWrongLastMsgIDErrF:                 {Code: 400, ErrCode: 10070, Description: "wrong last msg ID: {id}"},

                JSStreamWrongLastSequenceConstantErr:       {Code: 400, ErrCode: 10164, Description: "wrong last sequence"},

                JSStreamWrongLastSequenceErrF:              {Code: 400, ErrCode: 10071, Description: "wrong last sequence: {seq}"},

                JSTempStorageFailedErr:                     {Code: 500, ErrCode: 10072, Description: "JetStream unable to open temp storage for restore"},

                JSTemplateNameNotMatchSubjectErr:           {Code: 400, ErrCode: 10073, Description: "template name in subject does not match request"},

        }

        // ErrJetStreamNotClustered Deprecated by JSClusterNotActiveErr ApiError, use IsNatsError() for comparisons

        ErrJetStreamNotClustered = ApiErrors[JSClusterNotActiveErr]

        // ErrJetStreamNotAssigned Deprecated by JSClusterNotAssignedErr ApiError, use IsNatsError() for comparisons

        ErrJetStreamNotAssigned = ApiErrors[JSClusterNotAssignedErr]

        // ErrJetStreamNotLeader Deprecated by JSClusterNotLeaderErr ApiError, use IsNatsError() for comparisons

        ErrJetStreamNotLeader = ApiErrors[JSClusterNotLeaderErr]

        // ErrJetStreamConsumerAlreadyUsed Deprecated by JSConsumerNameExistErr ApiError, use IsNatsError() for comparisons

        ErrJetStreamConsumerAlreadyUsed = ApiErrors[JSConsumerNameExistErr]

        // ErrJetStreamResourcesExceeded Deprecated by JSInsufficientResourcesErr ApiError, use IsNatsError() for comparisons

        ErrJetStreamResourcesExceeded = ApiErrors[JSInsufficientResourcesErr]

        // ErrMemoryResourcesExceeded Deprecated by JSMemoryResourcesExceededErr ApiError, use IsNatsError() for comparisons

        ErrMemoryResourcesExceeded = ApiErrors[JSMemoryResourcesExceededErr]

        // ErrJetStreamNotEnabled Deprecated by JSNotEnabledErr ApiError, use IsNatsError() for comparisons

        ErrJetStreamNotEnabled = ApiErrors[JSNotEnabledErr]

        // ErrStorageResourcesExceeded Deprecated by JSStorageResourcesExceededErr ApiError, use IsNatsError() for comparisons

        ErrStorageResourcesExceeded = ApiErrors[JSStorageResourcesExceededErr]

        // ErrJetStreamStreamAlreadyUsed Deprecated by JSStreamNameExistErr ApiError, use IsNatsError() for comparisons

        ErrJetStreamStreamAlreadyUsed = ApiErrors[JSStreamNameExistErr]

        // ErrJetStreamStreamNotFound Deprecated by JSStreamNotFoundErr ApiError, use IsNatsError() for comparisons

        ErrJetStreamStreamNotFound = ApiErrors[JSStreamNotFoundErr]

        // ErrReplicasNotSupported Deprecated by JSStreamReplicasNotSupportedErr ApiError, use IsNatsError() for comparisons

        ErrReplicasNotSupported = ApiErrors[JSStreamReplicasNotSupportedErr]

)

// NewJSAccountResourcesExceededError creates a new JSAccountResourcesExceededErr error: "resource limits exceeded for account"

}

// NewJSBadRequestError creates a new JSBadRequestErr error: "bad request"

}

// NewJSClusterIncompleteError creates a new JSClusterIncompleteErr error: "incomplete results"

}

// NewJSClusterNoPeersError creates a new JSClusterNoPeersErrF error: "{err}"

}

// NewJSClusterNotActiveError creates a new JSClusterNotActiveErr error: "JetStream not in clustered mode"

}

// NewJSClusterNotAssignedError creates a new JSClusterNotAssignedErr error: "JetStream cluster not assigned to this server"

}

// NewJSClusterNotAvailError creates a new JSClusterNotAvailErr error: "JetStream system temporarily unavailable"

}

// NewJSClusterNotLeaderError creates a new JSClusterNotLeaderErr error: "JetStream cluster can not handle request"

}

// NewJSClusterPeerNotMemberError creates a new JSClusterPeerNotMemberErr error: "peer not a member"

}

// NewJSClusterRequiredError creates a new JSClusterRequiredErr error: "JetStream clustering support required"

}

// NewJSClusterServerNotMemberError creates a new JSClusterServerNotMemberErr error: "server is not a member of the cluster"

}

// NewJSClusterTagsError creates a new JSClusterTagsErr error: "tags placement not supported for operation"

}

// NewJSClusterUnSupportFeatureError creates a new JSClusterUnSupportFeatureErr error: "not currently supported in clustered mode"

}

// NewJSConsumerAlreadyExistsError creates a new JSConsumerAlreadyExists error: "consumer already exists"

}

// NewJSConsumerBadDurableNameError creates a new JSConsumerBadDurableNameErr error: "durable name can not contain '.', '*', '>'"

}

// NewJSConsumerConfigRequiredError creates a new JSConsumerConfigRequiredErr error: "consumer config required"

}

// NewJSConsumerCreateDurableAndNameMismatchError creates a new JSConsumerCreateDurableAndNameMismatch error: "Consumer Durable and Name have to be equal if both are provided"

}

// NewJSConsumerCreateError creates a new JSConsumerCreateErrF error: "{err}"

}

// NewJSConsumerCreateFilterSubjectMismatchError creates a new JSConsumerCreateFilterSubjectMismatchErr error: "Consumer create request did not match filtered subject from create subject"

}

// NewJSConsumerDeliverCycleError creates a new JSConsumerDeliverCycleErr error: "consumer deliver subject forms a cycle"

}

// NewJSConsumerDeliverToWildcardsError creates a new JSConsumerDeliverToWildcardsErr error: "consumer deliver subject has wildcards"