jetstream_errors_generated.go

// 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
JSAccountResourcesExceededErrErrorIdentifier=10002

// JSBadRequestErr bad request
JSBadRequestErrErrorIdentifier=10003

// JSClusterIncompleteErr incomplete results
JSClusterIncompleteErrErrorIdentifier=10004

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

// JSClusterNotActiveErr JetStream not in clustered mode
JSClusterNotActiveErrErrorIdentifier=10006

// JSClusterNotAssignedErr JetStream cluster not assigned to this server
JSClusterNotAssignedErrErrorIdentifier=10007

// JSClusterNotAvailErr JetStream system temporarily unavailable
JSClusterNotAvailErrErrorIdentifier=10008

// JSClusterNotLeaderErr JetStream cluster can not handle request
JSClusterNotLeaderErrErrorIdentifier=10009

// JSClusterPeerNotMemberErr peer not a member
JSClusterPeerNotMemberErrErrorIdentifier=10040

// JSClusterRequiredErr JetStream clustering support required
JSClusterRequiredErrErrorIdentifier=10010

// JSClusterServerNotMemberErr server is not a member of the cluster
JSClusterServerNotMemberErrErrorIdentifier=10044

// JSClusterTagsErr tags placement not supported for operation
JSClusterTagsErrErrorIdentifier=10011

// JSClusterUnSupportFeatureErr not currently supported in clustered mode
JSClusterUnSupportFeatureErrErrorIdentifier=10036

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

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

// JSConsumerConfigRequiredErr consumer config required
JSConsumerConfigRequiredErrErrorIdentifier=10078

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

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

// JSConsumerCreateFilterSubjectMismatchErr Consumer create request did not match filtered subject from create subject
JSConsumerCreateFilterSubjectMismatchErrErrorIdentifier=10131

// JSConsumerDeliverCycleErr consumer deliver subject forms a cycle
JSConsumerDeliverCycleErrErrorIdentifier=10081

// JSConsumerDeliverToWildcardsErr consumer deliver subject has wildcards
JSConsumerDeliverToWildcardsErrErrorIdentifier=10079

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

// JSConsumerDirectRequiresEphemeralErr consumer direct requires an ephemeral consumer
JSConsumerDirectRequiresEphemeralErrErrorIdentifier=10091

// JSConsumerDirectRequiresPushErr consumer direct requires a push based consumer
JSConsumerDirectRequiresPushErrErrorIdentifier=10090

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

// JSConsumerDuplicateFilterSubjects consumer cannot have both FilterSubject and FilterSubjects specified
JSConsumerDuplicateFilterSubjectsErrorIdentifier=10136

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

// JSConsumerDurableNameNotMatchSubjectErr consumer name in subject does not match durable name in request
JSConsumerDurableNameNotMatchSubjectErrErrorIdentifier=10017

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

// JSConsumerEmptyFilter consumer filter in FilterSubjects cannot be empty
JSConsumerEmptyFilterErrorIdentifier=10139

// JSConsumerEmptyGroupName Group name cannot be an empty string
JSConsumerEmptyGroupNameErrorIdentifier=10161

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

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

// JSConsumerExistingActiveErr consumer already exists and is still active
JSConsumerExistingActiveErrErrorIdentifier=10105

// JSConsumerFCRequiresPushErr consumer flow control requires a push based consumer
JSConsumerFCRequiresPushErrErrorIdentifier=10089

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

// JSConsumerHBRequiresPushErr consumer idle heartbeat requires a push based consumer
JSConsumerHBRequiresPushErrErrorIdentifier=10088

// JSConsumerInactiveThresholdExcess consumer inactive threshold exceeds system limit of {limit}
JSConsumerInactiveThresholdExcessErrorIdentifier=10153

// JSConsumerInvalidDeliverSubject invalid push consumer deliver subject
JSConsumerInvalidDeliverSubjectErrorIdentifier=10112

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

// JSConsumerInvalidPolicyErrF Generic delivery policy error ({err})
JSConsumerInvalidPolicyErrFErrorIdentifier=10094

// JSConsumerInvalidPriorityGroupErr Provided priority group does not exist for this consumer
JSConsumerInvalidPriorityGroupErrErrorIdentifier=10160

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

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

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

// JSConsumerMaxPendingAckPolicyRequiredErr consumer requires ack policy for max ack pending
JSConsumerMaxPendingAckPolicyRequiredErrErrorIdentifier=10082

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

// JSConsumerMaxRequestBatchNegativeErr consumer max request batch needs to be > 0
JSConsumerMaxRequestBatchNegativeErrErrorIdentifier=10114

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

// JSConsumerMaxWaitingNegativeErr consumer max waiting needs to be positive
JSConsumerMaxWaitingNegativeErrErrorIdentifier=10087

// JSConsumerMetadataLengthErrF consumer metadata exceeds maximum size of {limit}
JSConsumerMetadataLengthErrFErrorIdentifier=10135

// JSConsumerMultipleFiltersNotAllowed consumer with multiple subject filters cannot use subject based API
JSConsumerMultipleFiltersNotAllowedErrorIdentifier=10137

// JSConsumerNameContainsPathSeparatorsErr Consumer name can not contain path separators
JSConsumerNameContainsPathSeparatorsErrErrorIdentifier=10127

// JSConsumerNameExistErr consumer name already in use
JSConsumerNameExistErrErrorIdentifier=10013

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

// JSConsumerNotFoundErr consumer not found
JSConsumerNotFoundErrErrorIdentifier=10014

// JSConsumerOfflineErr consumer is offline
JSConsumerOfflineErrErrorIdentifier=10119

// JSConsumerOnMappedErr consumer direct on a mapped consumer
JSConsumerOnMappedErrErrorIdentifier=10092

// JSConsumerOverlappingSubjectFilters consumer subject filters cannot overlap
JSConsumerOverlappingSubjectFiltersErrorIdentifier=10138

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

// JSConsumerPullNotDurableErr consumer in pull mode requires a durable name
JSConsumerPullNotDurableErrErrorIdentifier=10085

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

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

// JSConsumerPushMaxWaitingErr consumer in push mode can not set max waiting
JSConsumerPushMaxWaitingErrErrorIdentifier=10080

// JSConsumerReplacementWithDifferentNameErr consumer replacement durable config not the same
JSConsumerReplacementWithDifferentNameErrErrorIdentifier=10106

// JSConsumerReplicasExceedsStream consumer config replica count exceeds parent stream
JSConsumerReplicasExceedsStreamErrorIdentifier=10126

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

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

// JSConsumerStoreFailedErrF error creating store for consumer: {err}
JSConsumerStoreFailedErrFErrorIdentifier=10104

// JSConsumerWQConsumerNotDeliverAllErr consumer must be deliver all on workqueue stream
JSConsumerWQConsumerNotDeliverAllErrErrorIdentifier=10101

// JSConsumerWQConsumerNotUniqueErr filtered consumer not unique on workqueue stream
JSConsumerWQConsumerNotUniqueErrErrorIdentifier=10100

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

// JSConsumerWQRequiresExplicitAckErr workqueue stream requires explicit ack
JSConsumerWQRequiresExplicitAckErrErrorIdentifier=10098

// JSConsumerWithFlowControlNeedsHeartbeats consumer with flow control also needs heartbeats
JSConsumerWithFlowControlNeedsHeartbeatsErrorIdentifier=10108

// JSInsufficientResourcesErr insufficient resources
JSInsufficientResourcesErrErrorIdentifier=10023

// JSInvalidJSONErr invalid JSON: {err}
JSInvalidJSONErrErrorIdentifier=10025

// JSMaximumConsumersLimitErr maximum consumers limit reached
JSMaximumConsumersLimitErrErrorIdentifier=10026

// JSMaximumStreamsLimitErr maximum number of streams reached
JSMaximumStreamsLimitErrErrorIdentifier=10027

// JSMemoryResourcesExceededErr insufficient memory resources available
JSMemoryResourcesExceededErrErrorIdentifier=10028

// JSMessageTTLDisabledErr per-message TTL is disabled
JSMessageTTLDisabledErrErrorIdentifier=10166

// JSMessageTTLInvalidErr invalid per-message TTL
JSMessageTTLInvalidErrErrorIdentifier=10165

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

// JSMirrorInvalidStreamName mirrored stream name is invalid
JSMirrorInvalidStreamNameErrorIdentifier=10142

// JSMirrorInvalidSubjectFilter mirror transform source: {err}
JSMirrorInvalidSubjectFilterErrorIdentifier=10151

// JSMirrorInvalidTransformDestination mirror transform: {err}
JSMirrorInvalidTransformDestinationErrorIdentifier=10154

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

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

// JSMirrorOverlappingSubjectFilters mirror subject filters can not overlap
JSMirrorOverlappingSubjectFiltersErrorIdentifier=10152

// JSMirrorWithFirstSeqErr stream mirrors can not have first sequence configured
JSMirrorWithFirstSeqErrErrorIdentifier=10143

// JSMirrorWithSourcesErr stream mirrors can not also contain other sources
JSMirrorWithSourcesErrErrorIdentifier=10031

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

// JSMirrorWithSubjectFiltersErr stream mirrors can not contain filtered subjects
JSMirrorWithSubjectFiltersErrErrorIdentifier=10033

// JSMirrorWithSubjectsErr stream mirrors can not contain subjects
JSMirrorWithSubjectsErrErrorIdentifier=10034

// JSNoAccountErr account not found
JSNoAccountErrErrorIdentifier=10035

// JSNoLimitsErr no JetStream default or applicable tiered limit present
JSNoLimitsErrErrorIdentifier=10120

// JSNoMessageFoundErr no message found
JSNoMessageFoundErrErrorIdentifier=10037

// JSNotEmptyRequestErr expected an empty request payload
JSNotEmptyRequestErrErrorIdentifier=10038

// JSNotEnabledErr JetStream not enabled
JSNotEnabledErrErrorIdentifier=10076

// JSNotEnabledForAccountErr JetStream not enabled for account
JSNotEnabledForAccountErrErrorIdentifier=10039

// JSPedanticErrF pedantic mode: {err}
JSPedanticErrFErrorIdentifier=10157

// JSPeerRemapErr peer remap failed
JSPeerRemapErrErrorIdentifier=10075

// JSRaftGeneralErrF General RAFT error string ({err})
JSRaftGeneralErrFErrorIdentifier=10041

// JSReplicasCountCannotBeNegative replicas count cannot be negative
JSReplicasCountCannotBeNegativeErrorIdentifier=10133

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

// JSSequenceNotFoundErrF sequence {seq} not found
JSSequenceNotFoundErrFErrorIdentifier=10043

// JSSnapshotDeliverSubjectInvalidErr deliver subject not valid
JSSnapshotDeliverSubjectInvalidErrErrorIdentifier=10015

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

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

// JSSourceInvalidStreamName sourced stream name is invalid
JSSourceInvalidStreamNameErrorIdentifier=10141

// JSSourceInvalidSubjectFilter source transform source: {err}
JSSourceInvalidSubjectFilterErrorIdentifier=10145

// JSSourceInvalidTransformDestination source transform: {err}
JSSourceInvalidTransformDestinationErrorIdentifier=10146

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

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

// JSSourceOverlappingSubjectFilters source filters can not overlap
JSSourceOverlappingSubjectFiltersErrorIdentifier=10147

// JSStorageResourcesExceededErr insufficient storage resources available
JSStorageResourcesExceededErrErrorIdentifier=10047

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

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

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

// JSStreamDuplicateMessageConflict duplicate message id is in process
JSStreamDuplicateMessageConflictErrorIdentifier=10158

// JSStreamExpectedLastSeqPerSubjectNotReady expected last sequence per subject temporarily unavailable
JSStreamExpectedLastSeqPerSubjectNotReadyErrorIdentifier=10163

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

// JSStreamExternalDelPrefixOverlapsErrF stream external delivery prefix {prefix} overlaps with stream subject {subject}
JSStreamExternalDelPrefixOverlapsErrFErrorIdentifier=10022

// JSStreamGeneralErrorF General stream failure string ({err})
JSStreamGeneralErrorFErrorIdentifier=10051

// JSStreamHeaderExceedsMaximumErr header size exceeds maximum allowed of 64k
JSStreamHeaderExceedsMaximumErrErrorIdentifier=10097

// JSStreamInfoMaxSubjectsErr subject details would exceed maximum allowed
JSStreamInfoMaxSubjectsErrErrorIdentifier=10117

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

// JSStreamInvalidErr stream not valid
JSStreamInvalidErrErrorIdentifier=10096

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

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

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

// JSStreamMaxStreamBytesExceeded stream max bytes exceeds account limit max stream bytes
JSStreamMaxStreamBytesExceededErrorIdentifier=10122

// JSStreamMessageExceedsMaximumErr message size exceeds maximum allowed
JSStreamMessageExceedsMaximumErrErrorIdentifier=10054

// JSStreamMirrorNotUpdatableErr stream mirror configuration can not be updated
JSStreamMirrorNotUpdatableErrErrorIdentifier=10055

// JSStreamMismatchErr stream name in subject does not match request
JSStreamMismatchErrErrorIdentifier=10056

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

// JSStreamMoveInProgressF stream move already in progress: {msg}
JSStreamMoveInProgressFErrorIdentifier=10124

// JSStreamMoveNotInProgress stream move not in progress
JSStreamMoveNotInProgressErrorIdentifier=10129

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

// JSStreamNameContainsPathSeparatorsErr Stream name can not contain path separators
JSStreamNameContainsPathSeparatorsErrErrorIdentifier=10128

// JSStreamNameExistErr stream name already in use with a different configuration
JSStreamNameExistErrErrorIdentifier=10058

// JSStreamNameExistRestoreFailedErr stream name already in use, cannot restore
JSStreamNameExistRestoreFailedErrErrorIdentifier=10130

// JSStreamNotFoundErr stream not found
JSStreamNotFoundErrErrorIdentifier=10059

// JSStreamNotMatchErr expected stream does not match
JSStreamNotMatchErrErrorIdentifier=10060

// JSStreamOfflineErr stream is offline
JSStreamOfflineErrErrorIdentifier=10118

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

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

// JSStreamReplicasNotUpdatableErr Replicas configuration can not be updated
JSStreamReplicasNotUpdatableErrErrorIdentifier=10061

// JSStreamRestoreErrF restore failed: {err}
JSStreamRestoreErrFErrorIdentifier=10062

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

// JSStreamSealedErr invalid operation on sealed stream
JSStreamSealedErrErrorIdentifier=10109

// JSStreamSequenceNotMatchErr expected stream sequence does not match
JSStreamSequenceNotMatchErrErrorIdentifier=10063

// JSStreamSnapshotErrF snapshot failed: {err}
JSStreamSnapshotErrFErrorIdentifier=10064

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

// JSStreamSubjectOverlapErr subjects overlap with an existing stream
JSStreamSubjectOverlapErrErrorIdentifier=10065

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

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

// JSStreamTemplateNotFoundErr template not found
JSStreamTemplateNotFoundErrErrorIdentifier=10068

// JSStreamTooManyRequests too many requests
JSStreamTooManyRequestsErrorIdentifier=10167

// JSStreamTransformInvalidDestination stream transform: {err}
JSStreamTransformInvalidDestinationErrorIdentifier=10156

// JSStreamTransformInvalidSource stream transform source: {err}
JSStreamTransformInvalidSourceErrorIdentifier=10155

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

// JSStreamWrongLastMsgIDErrF wrong last msg ID: {id}
JSStreamWrongLastMsgIDErrFErrorIdentifier=10070

// JSStreamWrongLastSequenceConstantErr wrong last sequence
JSStreamWrongLastSequenceConstantErrErrorIdentifier=10164

// JSStreamWrongLastSequenceErrF wrong last sequence: {seq}
JSStreamWrongLastSequenceErrFErrorIdentifier=10071

// JSTempStorageFailedErr JetStream unable to open temp storage for restore
JSTempStorageFailedErrErrorIdentifier=10072

// JSTemplateNameNotMatchSubjectErr template name in subject does not match request
JSTemplateNameNotMatchSubjectErrErrorIdentifier=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"},
JSStreamTooManyRequests: {Code: 429, ErrCode: 10167, Description: "too many requests"},
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"
funcNewJSAccountResourcesExceededError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSAccountResourcesExceededErr]
}

// NewJSBadRequestError creates a new JSBadRequestErr error: "bad request"
funcNewJSBadRequestError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSBadRequestErr]
}

// NewJSClusterIncompleteError creates a new JSClusterIncompleteErr error: "incomplete results"
funcNewJSClusterIncompleteError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSClusterIncompleteErr]
}

// NewJSClusterNoPeersError creates a new JSClusterNoPeersErrF error: "{err}"
funcNewJSClusterNoPeersError(errerror, opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

e:=ApiErrors[JSClusterNoPeersErrF]
args:=e.toReplacerArgs([]interface{}{"{err}", err})
return&ApiError{
Code: e.Code,
ErrCode: e.ErrCode,
Description: strings.NewReplacer(args...).Replace(e.Description),
 }
}

// NewJSClusterNotActiveError creates a new JSClusterNotActiveErr error: "JetStream not in clustered mode"
funcNewJSClusterNotActiveError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSClusterNotActiveErr]
}

// NewJSClusterNotAssignedError creates a new JSClusterNotAssignedErr error: "JetStream cluster not assigned to this server"
funcNewJSClusterNotAssignedError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSClusterNotAssignedErr]
}

// NewJSClusterNotAvailError creates a new JSClusterNotAvailErr error: "JetStream system temporarily unavailable"
funcNewJSClusterNotAvailError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSClusterNotAvailErr]
}

// NewJSClusterNotLeaderError creates a new JSClusterNotLeaderErr error: "JetStream cluster can not handle request"
funcNewJSClusterNotLeaderError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSClusterNotLeaderErr]
}

// NewJSClusterPeerNotMemberError creates a new JSClusterPeerNotMemberErr error: "peer not a member"
funcNewJSClusterPeerNotMemberError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSClusterPeerNotMemberErr]
}

// NewJSClusterRequiredError creates a new JSClusterRequiredErr error: "JetStream clustering support required"
funcNewJSClusterRequiredError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSClusterRequiredErr]
}

// NewJSClusterServerNotMemberError creates a new JSClusterServerNotMemberErr error: "server is not a member of the cluster"
funcNewJSClusterServerNotMemberError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSClusterServerNotMemberErr]
}

// NewJSClusterTagsError creates a new JSClusterTagsErr error: "tags placement not supported for operation"
funcNewJSClusterTagsError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSClusterTagsErr]
}

// NewJSClusterUnSupportFeatureError creates a new JSClusterUnSupportFeatureErr error: "not currently supported in clustered mode"
funcNewJSClusterUnSupportFeatureError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSClusterUnSupportFeatureErr]
}

// NewJSConsumerAlreadyExistsError creates a new JSConsumerAlreadyExists error: "consumer already exists"
funcNewJSConsumerAlreadyExistsError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSConsumerAlreadyExists]
}

// NewJSConsumerBadDurableNameError creates a new JSConsumerBadDurableNameErr error: "durable name can not contain '.', '*', '>'"
funcNewJSConsumerBadDurableNameError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSConsumerBadDurableNameErr]
}

// NewJSConsumerConfigRequiredError creates a new JSConsumerConfigRequiredErr error: "consumer config required"
funcNewJSConsumerConfigRequiredError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSConsumerConfigRequiredErr]
}

// NewJSConsumerCreateDurableAndNameMismatchError creates a new JSConsumerCreateDurableAndNameMismatch error: "Consumer Durable and Name have to be equal if both are provided"
funcNewJSConsumerCreateDurableAndNameMismatchError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSConsumerCreateDurableAndNameMismatch]
}

// NewJSConsumerCreateError creates a new JSConsumerCreateErrF error: "{err}"
funcNewJSConsumerCreateError(errerror, opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

e:=ApiErrors[JSConsumerCreateErrF]
args:=e.toReplacerArgs([]interface{}{"{err}", err})
return&ApiError{
Code: e.Code,
ErrCode: e.ErrCode,
Description: strings.NewReplacer(args...).Replace(e.Description),
 }
}

// NewJSConsumerCreateFilterSubjectMismatchError creates a new JSConsumerCreateFilterSubjectMismatchErr error: "Consumer create request did not match filtered subject from create subject"
funcNewJSConsumerCreateFilterSubjectMismatchError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSConsumerCreateFilterSubjectMismatchErr]
}

// NewJSConsumerDeliverCycleError creates a new JSConsumerDeliverCycleErr error: "consumer deliver subject forms a cycle"
funcNewJSConsumerDeliverCycleError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSConsumerDeliverCycleErr]
}

// NewJSConsumerDeliverToWildcardsError creates a new JSConsumerDeliverToWildcardsErr error: "consumer deliver subject has wildcards"
funcNewJSConsumerDeliverToWildcardsError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSConsumerDeliverToWildcardsErr]
}

// NewJSConsumerDescriptionTooLongError creates a new JSConsumerDescriptionTooLongErrF error: "consumer description is too long, maximum allowed is {max}"
funcNewJSConsumerDescriptionTooLongError(maxinterface{}, opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

e:=ApiErrors[JSConsumerDescriptionTooLongErrF]
args:=e.toReplacerArgs([]interface{}{"{max}", max})
return&ApiError{
Code: e.Code,
ErrCode: e.ErrCode,
Description: strings.NewReplacer(args...).Replace(e.Description),
 }
}

// NewJSConsumerDirectRequiresEphemeralError creates a new JSConsumerDirectRequiresEphemeralErr error: "consumer direct requires an ephemeral consumer"
funcNewJSConsumerDirectRequiresEphemeralError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSConsumerDirectRequiresEphemeralErr]
}

// NewJSConsumerDirectRequiresPushError creates a new JSConsumerDirectRequiresPushErr error: "consumer direct requires a push based consumer"
funcNewJSConsumerDirectRequiresPushError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSConsumerDirectRequiresPushErr]
}

// NewJSConsumerDoesNotExistError creates a new JSConsumerDoesNotExist error: "consumer does not exist"
funcNewJSConsumerDoesNotExistError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSConsumerDoesNotExist]
}

// NewJSConsumerDuplicateFilterSubjectsError creates a new JSConsumerDuplicateFilterSubjects error: "consumer cannot have both FilterSubject and FilterSubjects specified"
funcNewJSConsumerDuplicateFilterSubjectsError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSConsumerDuplicateFilterSubjects]
}

// NewJSConsumerDurableNameNotInSubjectError creates a new JSConsumerDurableNameNotInSubjectErr error: "consumer expected to be durable but no durable name set in subject"
funcNewJSConsumerDurableNameNotInSubjectError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSConsumerDurableNameNotInSubjectErr]
}

// NewJSConsumerDurableNameNotMatchSubjectError creates a new JSConsumerDurableNameNotMatchSubjectErr error: "consumer name in subject does not match durable name in request"
funcNewJSConsumerDurableNameNotMatchSubjectError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)
ifae, ok:=eopts.err.(*ApiError); ok {
returnae
 }

returnApiErrors[JSConsumerDurableNameNotMatchSubjectErr]
}

// NewJSConsumerDurableNameNotSetError creates a new JSConsumerDurableNameNotSetErr error: "consumer expected to be durable but a durable name was not set"
funcNewJSConsumerDurableNameNotSetError(opts...ErrorOption) *ApiError {
eopts:=parseOpts(opts)