nats.h

Go to the documentation of this file.

// Copyright 2015-2024 The NATS Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef NATS_H_
#define NATS_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <inttypes.h>
#include <stdio.h>
 
#include "status.h"
#include "version.h"
 
#if defined(_WIN32)
  #include <winsock2.h>
  #if defined(nats_EXPORTS)
    #define NATS_EXTERN __declspec(dllexport)
  #elif defined(nats_IMPORTS)
    #define NATS_EXTERN __declspec(dllimport)
  #else
    #define NATS_EXTERN
  #endif
 
  typedef SOCKET      natsSock;
#else
  #define NATS_EXTERN
  typedef int         natsSock;
#endif
 
#define NATS_DEFAULT_URL "nats://localhost:4222"
 
 #define JSMsgSize    "Nats-Msg-Size"
 
 #define JSMsgRollup            "Nats-Rollup"
 
 #define JSMsgRollupSubject     "sub"
 
 #define JSMsgRollupAll         "all"
 
 // Headers for republished messages and direct get.
 #define JSStream       "Nats-Stream"
 #define JSSequence     "Nats-Sequence"
 #define JSLastSequence "Nats-Last-Sequence"
 #define JSTimeStamp    "Nats-Time-Stamp"
 #define JSSubject      "Nats-Subject"
 
//
// Types.
//
typedef struct __natsConnection     natsConnection;
 
typedef struct __natsStatistics     natsStatistics;
 
typedef struct __natsSubscription   natsSubscription;
 
typedef struct __natsMsg            natsMsg;
 
typedef struct __natsOptions        natsOptions;
 
typedef char                        natsInbox;
 
 
typedef struct __natsClientConfig
{
        int64_t DefaultWriteDeadline;
 
        int64_t LockSpinCount;
 
        // Subscription message delivery thread control
        bool DefaultToThreadPool;
        int ThreadPoolMax;
 
        // Reply message delivery thread control
        bool DefaultRepliesToThreadPool;
        bool UseSeparatePoolForReplies;
        int ReplyThreadPoolMax;
} natsClientConfig;
 
typedef struct natsMsgList
{
        natsMsg         **Msgs;
        int             Count;
 
} natsMsgList;
 
typedef struct natsMetadata
{
        // User-provided metadata for the stream, encoded as an array of {"key", "value",...}
        const char **List;
        // Number of key/value pairs in Metadata, 1/2 of the length of the array.
        int Count;
} natsMetadata;
 
typedef struct __jsCtx                  jsCtx;
 
typedef struct jsPubOptions
{
        int64_t         MaxWait;                
        const char      *MsgId;                 
        const char      *ExpectStream;          
        const char      *ExpectLastMsgId;       
        uint64_t        ExpectLastSeq;          
        uint64_t        ExpectLastSubjectSeq;   
        bool            ExpectNoMessage;        
 
} jsPubOptions;
 
typedef enum
{
        js_LimitsPolicy = 0,    
        js_InterestPolicy,      
        js_WorkQueuePolicy,     
 
} jsRetentionPolicy;
 
typedef enum
{
        js_DiscardOld = 0,  
        js_DiscardNew,      
 
} jsDiscardPolicy;
 
typedef enum
{
        js_FileStorage = 0, 
        js_MemoryStorage,   
 
} jsStorageType;
 
typedef enum
{
        js_StorageCompressionNone = 0, 
        js_StorageCompressionS2,   
} jsStorageCompression;
 
typedef enum
{
        js_DeliverAll = 0,          
        js_DeliverLast,             
        js_DeliverNew,              
        js_DeliverByStartSequence,  
        js_DeliverByStartTime,      
        js_DeliverLastPerSubject,   
 
} jsDeliverPolicy;
 
typedef enum
{
        js_AckExplicit = 0,     
        js_AckNone,             
        js_AckAll,              
 
 
} jsAckPolicy;
 
typedef enum
{
        js_ReplayInstant = 0,   
        js_ReplayOriginal,      
 
} jsReplayPolicy;
 
 
typedef struct jsPlacement
{
        const char      *Cluster;
        const char      **Tags;
        int             TagsLen;
 
} jsPlacement;
 
typedef struct jsExternalStream
{
        const char      *APIPrefix;
        const char      *DeliverPrefix;
 
} jsExternalStream;
 
typedef struct jsStreamSource
{
        const char              *Name;
        uint64_t                OptStartSeq;
        int64_t                 OptStartTime;   
        const char              *FilterSubject;
        jsExternalStream        *External;
        // Domain and External are mutually exclusive.
        // If Domain is set, an External value will be created with
        // the APIPrefix constructed based on the Domain value.
        const char              *Domain;
 
} jsStreamSource;
 
typedef struct jsRePublish
{
        const char              *Source;
        const char              *Destination;
        bool                    HeadersOnly;
 
} jsRePublish;
 
typedef struct jsSubjectTransformConfig
{
        const char *Source;
        const char *Destination;
} jsSubjectTransformConfig;
 
typedef struct jsStreamConsumerLimits
{
        int64_t InactiveThreshold;
        int MaxAckPending;
} jsStreamConsumerLimits;
 
typedef struct jsStreamConfig {
        const char              *Name;
        const char              *Description;
        const char              **Subjects;
        int                     SubjectsLen;
        jsRetentionPolicy       Retention;
        int64_t                 MaxConsumers;
        int64_t                 MaxMsgs;
        int64_t                 MaxBytes;
        int64_t                 MaxAge;
        int64_t                 MaxMsgsPerSubject;
        int32_t                 MaxMsgSize;
        jsDiscardPolicy         Discard;
        jsStorageType           Storage;
        int64_t                 Replicas;
        bool                    NoAck;
        const char              *Template;
        int64_t                 Duplicates;
        jsPlacement             *Placement;
        jsStreamSource          *Mirror;
        jsStreamSource          **Sources;
        int                     SourcesLen;
        bool                    Sealed;         
        bool                    DenyDelete;     
        bool                    DenyPurge;      
 
        bool                    AllowRollup;
 
        jsRePublish             *RePublish;
 
        bool                    AllowDirect;
 
        bool                    MirrorDirect;
 
        bool                    DiscardNewPerSubject;
 
        natsMetadata            Metadata;
 
        jsStorageCompression    Compression;
 
        uint64_t                FirstSeq;
 
        jsSubjectTransformConfig SubjectTransform;
 
        jsStreamConsumerLimits  ConsumerLimits;
} jsStreamConfig;
 
typedef struct jsLostStreamData
{
        uint64_t                *Msgs;
        int                     MsgsLen;
        uint64_t                Bytes;
 
} jsLostStreamData;
 
typedef struct jsStreamStateSubject
{
        const char              *Subject;
        uint64_t                Msgs;
 
} jsStreamStateSubject;
 
typedef struct jsStreamStateSubjects
{
        jsStreamStateSubject    *List;
        int                     Count;
 
} jsStreamStateSubjects;
 
typedef struct jsStreamState
{
        uint64_t                Msgs;
        uint64_t                Bytes;
        uint64_t                FirstSeq;
        int64_t                 FirstTime;      
        uint64_t                LastSeq;
        int64_t                 LastTime;       
        int64_t                 NumSubjects;
        jsStreamStateSubjects   *Subjects;
        uint64_t                NumDeleted;
        uint64_t                *Deleted;
        int                     DeletedLen;
        jsLostStreamData        *Lost;
        int64_t                 Consumers;
 
} jsStreamState;
 
typedef struct jsPeerInfo
{
        char        *Name;
        bool        Current;
        bool        Offline;
        int64_t     Active;
        uint64_t    Lag;
 
} jsPeerInfo;
 
typedef struct jsClusterInfo
{
        char            *Name;
        char            *Leader;
        jsPeerInfo      **Replicas;
        int             ReplicasLen;
 
} jsClusterInfo;
 
typedef struct jsStreamSourceInfo
{
        char                    *Name;
        jsExternalStream        *External;
        uint64_t                Lag;
        int64_t                 Active;
        const char *            FilterSubject;
        jsSubjectTransformConfig *SubjectTransforms;
        int                     SubjectTransformsLen;
 
} jsStreamSourceInfo;
 
typedef struct jsStreamAlternate
{
        const char              *Name;
        const char              *Domain;
        const char              *Cluster;
 
} jsStreamAlternate;
 
typedef struct jsStreamInfo
{
        jsStreamConfig          *Config;
        int64_t                 Created;        
        jsStreamState           State;
        jsClusterInfo           *Cluster;
        jsStreamSourceInfo      *Mirror;
        jsStreamSourceInfo      **Sources;
        int                     SourcesLen;
        jsStreamAlternate       **Alternates;
        int                     AlternatesLen;
 
} jsStreamInfo;
 
typedef struct jsStreamInfoList
{
        jsStreamInfo    **List;
        int             Count;
 
} jsStreamInfoList;
 
typedef struct jsStreamNamesList
{
        char    **List;
        int     Count;
 
} jsStreamNamesList;
 
typedef struct jsConsumerConfig
{
        const char              *Name;
        const char              *Durable;
        const char              *Description;
        jsDeliverPolicy         DeliverPolicy;
        uint64_t                OptStartSeq;
        int64_t                 OptStartTime;           
        jsAckPolicy             AckPolicy;
        int64_t                 AckWait;
        int64_t                 MaxDeliver;
        int64_t                 *BackOff;               
        int                     BackOffLen;
        const char              *FilterSubject;
        jsReplayPolicy          ReplayPolicy;
        uint64_t                RateLimit;
        const char              *SampleFrequency;
        int64_t                 MaxWaiting;
        int64_t                 MaxAckPending;
        bool                    FlowControl;
        int64_t                 Heartbeat;              
        bool                    HeadersOnly;
 
        // Pull based options.
        int64_t                 MaxRequestBatch;        
        int64_t                 MaxRequestExpires;      
        int64_t                 MaxRequestMaxBytes;     
 
        // Push based options.
        const char              *DeliverSubject;
        const char              *DeliverGroup;
 
        // Ephemeral inactivity threshold.
        int64_t                 InactiveThreshold;      
 
        // Generally inherited by parent stream and other markers, now can be configured directly.
        int64_t                 Replicas;
        // Force memory storage.
        bool                    MemoryStorage;
 
        // Configuration options introduced in 2.10
 
        const char              **FilterSubjects;       
        int                     FilterSubjectsLen;
        natsMetadata            Metadata;               
 
        // Configuration options introduced in 2.11
 
        int64_t                 PauseUntil;             
} jsConsumerConfig;
 
typedef struct jsConsumerSequenceMismatch
{
        uint64_t        Stream;         
        uint64_t        ConsumerClient; 
        uint64_t        ConsumerServer; 
 
} jsConsumerSequenceMismatch;
 
typedef struct jsSubOptions
{
        const char              *Stream;        
        const char              *Consumer;      
        const char              *Queue;         
        bool                    ManualAck;      
        jsConsumerConfig        Config;         
        bool                    Ordered;        
 
} jsSubOptions;
 
typedef struct jsSequencePair
{
        uint64_t        Consumer;
        uint64_t        Stream;
 
} jsSequencePair;
 
typedef struct jsSequenceInfo
{
        uint64_t        Consumer;
        uint64_t        Stream;
        int64_t         Last;           
 
} jsSequenceInfo;
 
typedef struct jsConsumerInfo
{
        char                    *Stream;
        char                    *Name;
        int64_t                 Created;                
        jsConsumerConfig        *Config;
        jsSequenceInfo          Delivered;
        jsSequenceInfo          AckFloor;
        int64_t                 NumAckPending;
        int64_t                 NumRedelivered;
        int64_t                 NumWaiting;
        uint64_t                NumPending;
        jsClusterInfo           *Cluster;
        bool                    PushBound;
        bool                    Paused;
        int64_t                 PauseRemaining;        
} jsConsumerInfo;
 
typedef struct jsConsumerInfoList
{
        jsConsumerInfo  **List;
        int             Count;
 
} jsConsumerInfoList;
 
typedef struct jsConsumerNamesList
{
        char    **List;
        int     Count;
 
} jsConsumerNamesList;
 
typedef struct jsConsumerPauseResponse
{
        bool            Paused;
        int64_t         PauseUntil;     
        int64_t         PauseRemaining; 
} jsConsumerPauseResponse;
 
typedef struct jsAPIStats
{
        uint64_t Total;
        uint64_t Errors;
 
} jsAPIStats;
 
typedef struct  jsAccountLimits
{
        int64_t MaxMemory;
        int64_t MaxStore;
        int64_t MaxStreams;
        int64_t MaxConsumers;
        int64_t MaxAckPending;
        int64_t MemoryMaxStreamBytes;
        int64_t StoreMaxStreamBytes;
        bool    MaxBytesRequired;
 
} jsAccountLimits;
 
typedef struct jsTier
{
        const char              *Name;
        uint64_t                Memory;
        uint64_t                Store;
        int64_t                 Streams;
        int64_t                 Consumers;
        jsAccountLimits         Limits;
 
} jsTier;
 
typedef struct jsAccountInfo
{
        uint64_t                Memory;
        uint64_t                Store;
        int64_t                 Streams;
        int64_t                 Consumers;
        char                    *Domain;
        jsAPIStats              API;
        jsAccountLimits         Limits;
        jsTier                  **Tiers;
        int                     TiersLen;
 
} jsAccountInfo;
 
typedef struct jsMsgMetaData
{
        jsSequencePair  Sequence;
        uint64_t        NumDelivered;
        uint64_t        NumPending;
        int64_t         Timestamp;
        char            *Stream;
        char            *Consumer;
        char            *Domain;
 
} jsMsgMetaData;
 
typedef struct jsPubAck
{
        char            *Stream;
        uint64_t        Sequence;
        char            *Domain;
        bool            Duplicate;
 
} jsPubAck;
 
typedef struct jsPubAckErr
{
        natsMsg         *Msg;
        natsStatus      Err;
        jsErrCode       ErrCode;
        const char      *ErrText;
 
} jsPubAckErr;
 
#ifndef BUILD_IN_DOXYGEN
// Forward declarations
typedef void (*jsPubAckErrHandler)(jsCtx *js, jsPubAckErr *pae, void *closure);
typedef void (*jsPubAckHandler)(jsCtx *js, natsMsg *msg, jsPubAck *pa, jsPubAckErr *pae, void *closure);
#endif
 
typedef struct jsDirectGetMsgOptions
{
        uint64_t        Sequence;               
        const char      *NextBySubject;         
        const char      *LastBySubject;         
 
} jsDirectGetMsgOptions;
 
typedef struct jsFetchRequest
{
        int64_t         Expires;        
        int             Batch;          
        int64_t         MaxBytes;       
        bool            NoWait;         
        int64_t         Heartbeat;      
 
} jsFetchRequest;
 
typedef void (*jsFetchCompleteHandler)(natsConnection *nc, natsSubscription *sub, natsStatus s, void *closure);
 
typedef bool (*jsFetchNextHandler)(int *messages, int64_t *maxBytes, natsSubscription *sub, void *closure);
 
typedef struct jsOptions
{
        const char              *Prefix;                        
        const char              *Domain;                        
        int64_t                 Wait;                           
 
        struct jsOptionsPublishAsync
        {
                int64_t                 MaxPending;             
 
                // If jsPubAckHandler is specified, the callback will be invoked
                // for every asynchronous published message, either as a positive
                // result, or with the error encountered when publishing that
                // message. If this callback is specified, ErrHandler (see below)
                // will be ignored.
                jsPubAckHandler         AckHandler;             
                void                    *AckHandlerClosure;     
 
                // This callback is invoked for messages published asynchronously
                // when an error is returned by the server or if the library has
                // timed-out waiting for an acknowledgment back from the server
                // (if publish uses the jsPubOptions.MaxWait).
                jsPubAckErrHandler      ErrHandler;             
                void                    *ErrHandlerClosure;     
 
                int64_t                 StallWait;              
 
        } PublishAsync; 
 
        struct jsOptionsPullSubscribeAsync
        {
                int64_t                 Timeout;        
                int                     MaxMessages;    
                int64_t                 MaxBytes;       
 
                bool                    NoWait;
 
                jsFetchCompleteHandler  CompleteHandler;
                void                    *CompleteHandlerClosure;
 
                int64_t                 Heartbeat;
 
                int                     FetchSize;
 
                int                     KeepAhead;
 
                jsFetchNextHandler      NextHandler;
                void                    *NextHandlerClosure;
 
        } PullSubscribeAsync; 
 
 
        struct jsOptionsStream
        {
                struct jsOptionsStreamPurge
                {
                        const char      *Subject;       
                        uint64_t        Sequence;       
                        uint64_t        Keep;           
 
                } Purge;                                
 
                struct jsOptionsStreamInfo
                {
                        bool            DeletedDetails;         
                        const char      *SubjectsFilter;        
 
                } Info;                                 
 
        } Stream;                                       
 
} jsOptions;
 
typedef struct __kvStore                kvStore;
 
typedef struct __kvEntry                kvEntry;
 
typedef struct __kvStatus               kvStatus;
 
typedef struct __kvWatcher              kvWatcher;
 
typedef enum
{
        kvOp_Unknown = 0,
        kvOp_Put,
        kvOp_Delete,
        kvOp_Purge,
 
} kvOperation;
 
typedef struct kvConfig
{
        const char      *Bucket;
        const char      *Description;
        int32_t         MaxValueSize;
        uint8_t         History;
        int64_t         TTL;
        int64_t         MaxBytes;
        jsStorageType   StorageType;
        int             Replicas;
        jsRePublish     *RePublish;
        jsStreamSource  *Mirror;
        jsStreamSource  **Sources;
        int             SourcesLen;
 
} kvConfig;
 
typedef struct kvWatchOptions
{
        bool            IgnoreDeletes;
        bool            IncludeHistory;
        bool            MetaOnly;
        int64_t         Timeout;        
 
} kvWatchOptions;
 
typedef struct kvPurgeOptions
{
        // How long to wait (in milliseconds) for some operations to complete.
        int64_t         Timeout;
 
        // When calling kvStore_PurgeDeletes(), all keys that have a delete or
        // purge marker as the last entry are gathered and then those keys
        // are purged of their content, including the marker.
        // Starting with NATS C client v3.3.0, if this option is not specified,
        // only the markers older than 30 minutes will be deleted. Use this
        // option to set the limit or a negative value to force removal of
        // markers regardless of their age.
        // The value is expressed as a time in nanoseconds.
        int64_t         DeleteMarkersOlderThan;
 
} kvPurgeOptions;
 
typedef struct kvEntryList
{
        kvEntry         **Entries;
        int             Count;
 
} kvEntryList;
 
typedef struct kvKeysList
{
        char            **Keys;
        int             Count;
 
} kvKeysList;
 
#if defined(NATS_HAS_STREAMING)
typedef struct __stanConnection     stanConnection;
 
typedef struct __stanSubscription   stanSubscription;
 
typedef struct __stanMsg            stanMsg;
 
typedef struct __stanConnOptions    stanConnOptions;
 
typedef struct __stanSubOptions     stanSubOptions;
#endif
 // end of typesGroup
 
//
// Callbacks.
//
 
typedef void (*natsMsgHandler)(
        natsConnection *nc, natsSubscription *sub, natsMsg *msg, void *closure);
 
typedef void (*natsConnectionHandler)(
        natsConnection  *nc, void *closure);
 
typedef void (*natsErrHandler)(
        natsConnection *nc, natsSubscription *subscription, natsStatus err,
        void *closure);
 
typedef natsStatus (*natsEvLoop_Attach)(
        void            **userData,
        void            *loop,
        natsConnection  *nc,
        natsSock        socket);
 
typedef natsStatus (*natsEvLoop_ReadAddRemove)(
        void            *userData,
        bool            add);
 
typedef natsStatus (*natsEvLoop_WriteAddRemove)(
        void            *userData,
        bool            add);
 
typedef natsStatus (*natsEvLoop_Detach)(
        void            *userData);
 
typedef natsStatus (*natsUserJWTHandler)(
        char            **userJWT,
        char            **customErrTxt,
        void            *closure);
 
 
typedef natsStatus (*natsSignatureHandler)(
        char            **customErrTxt,
        unsigned char   **signature,
        int             *signatureLength,
        const char      *nonce,
        void            *closure);
 
typedef const char* (*natsTokenHandler)(void *closure);
 
 
typedef void (*natsOnCompleteCB)(void *closure);
 
typedef int64_t (*natsCustomReconnectDelayHandler)(natsConnection *nc, int attempts, void *closure);
 
#ifdef BUILD_IN_DOXYGEN
typedef void (*jsPubAckErrHandler)(jsCtx *js, jsPubAckErr *pae, void *closure);
 
typedef void (*jsPubAckHandler)(jsCtx *js, natsMsg *msg, jsPubAck *pa, jsPubAckErr *pae, void *closure);
#endif
 
#if defined(NATS_HAS_STREAMING)
typedef void (*stanPubAckHandler)(const char *guid, const char *error, void *closure);
 
typedef void (*stanMsgHandler)(
        stanConnection *sc, stanSubscription *sub, const char *channel, stanMsg *msg, void *closure);
 
typedef void (*stanConnectionLostHandler)(
        stanConnection *sc, const char* errorTxt, void *closure);
#endif
 // end of callbacksGroup
 
//
// Functions.
//
natsStatus
nats_OpenWithConfig(natsClientConfig *config);
 
NATS_EXTERN natsStatus
nats_Open(int64_t lockSpinCount);
 
 
NATS_EXTERN const char*
nats_GetVersion(void);
 
NATS_EXTERN uint32_t
nats_GetVersionNumber(void);
 
#ifdef BUILD_IN_DOXYGEN
NATS_EXTERN bool nats_CheckCompatibility(void);
#else
 
#define nats_CheckCompatibility() nats_CheckCompatibilityImpl(NATS_VERSION_REQUIRED_NUMBER, \
                                                              NATS_VERSION_NUMBER, \
                                                              NATS_VERSION_STRING)
 
NATS_EXTERN bool
nats_CheckCompatibilityImpl(uint32_t reqVerNumber, uint32_t verNumber, const char *verString);
 
#endif
 
NATS_EXTERN int64_t
nats_Now(void);
 
NATS_EXTERN int64_t
nats_NowInNanoSeconds(void);
 
NATS_EXTERN void
nats_Sleep(int64_t sleepTime);
 
NATS_EXTERN const char*
nats_GetLastError(natsStatus *status);
 
NATS_EXTERN natsStatus
nats_GetLastErrorStack(char *buffer, size_t bufLen);
 
NATS_EXTERN void
nats_PrintLastErrorStack(FILE *file);
 
NATS_EXTERN natsStatus
nats_SetMessageDeliveryPoolSize(int max);
 
NATS_EXTERN void
nats_ReleaseThreadMemory(void);
 
NATS_EXTERN natsStatus
nats_Sign(const char    *encodedSeed,
          const char    *input,
          unsigned char **signature,
          int           *signatureLength);
 
NATS_EXTERN void
nats_Close(void);
 
NATS_EXTERN natsStatus
nats_CloseAndWait(int64_t timeout);
 // end of libraryGroup
 
NATS_EXTERN const char*
natsStatus_GetText(natsStatus s);
 // end of statusGroup
 
NATS_EXTERN natsStatus
natsStatistics_Create(natsStatistics **newStats);
 
NATS_EXTERN natsStatus
natsStatistics_GetCounts(const natsStatistics *stats,
                         uint64_t *inMsgs, uint64_t *inBytes,
                         uint64_t *outMsgs, uint64_t *outBytes,
                         uint64_t *reconnects);
 
NATS_EXTERN void
natsStatistics_Destroy(natsStatistics *stats);
 // end of statsGroup
 
NATS_EXTERN natsStatus
natsOptions_Create(natsOptions **newOpts);
 
/*
 * The above is for doxygen. The proper syntax for username/password
 * is without the '\' character:
 *
 * nats://localhost:4222
 * nats://user@localhost:4222
 * nats://user:password@localhost:4222
 */
NATS_EXTERN natsStatus
natsOptions_SetURL(natsOptions *opts, const char *url);
 
NATS_EXTERN natsStatus
natsOptions_SetServers(natsOptions *opts, const char** servers, int serversCount);
 
NATS_EXTERN natsStatus
natsOptions_SetUserInfo(natsOptions *opts, const char *user, const char *password);
 
NATS_EXTERN natsStatus
natsOptions_SetToken(natsOptions *opts, const char *token);
 
NATS_EXTERN natsStatus
natsOptions_SetTokenHandler(natsOptions *opts, natsTokenHandler tokenCb,
                            void *closure);
 
NATS_EXTERN natsStatus
natsOptions_SetNoRandomize(natsOptions *opts, bool noRandomize);
 
NATS_EXTERN natsStatus
natsOptions_SetTimeout(natsOptions *opts, int64_t timeout);
 
NATS_EXTERN natsStatus
natsOptions_SetName(natsOptions *opts, const char *name);
 
NATS_EXTERN natsStatus
natsOptions_SetSecure(natsOptions *opts, bool secure);
 
NATS_EXTERN natsStatus
natsOptions_TLSHandshakeFirst(natsOptions *opts);
 
NATS_EXTERN natsStatus
natsOptions_LoadCATrustedCertificates(natsOptions *opts, const char *fileName);
 
NATS_EXTERN natsStatus
natsOptions_SetCATrustedCertificates(natsOptions *opts, const char *certificates);
 
NATS_EXTERN natsStatus
natsOptions_LoadCertificatesChain(natsOptions *opts,
                                  const char *certsFileName,
                                  const char *keyFileName);
 
NATS_EXTERN natsStatus
natsOptions_SetCertificatesChain(natsOptions *opts,
                                 const char *cert,
                                 const char *key);
 
NATS_EXTERN natsStatus
natsOptions_SetCiphers(natsOptions *opts, const char *ciphers);
 
NATS_EXTERN natsStatus
natsOptions_SetCipherSuites(natsOptions *opts, const char *ciphers);
 
NATS_EXTERN natsStatus
natsOptions_SetExpectedHostname(natsOptions *opts, const char *hostname);
 
NATS_EXTERN natsStatus
natsOptions_SkipServerVerification(natsOptions *opts, bool skip);
 
NATS_EXTERN natsStatus
natsOptions_SetVerbose(natsOptions *opts, bool verbose);
 
NATS_EXTERN natsStatus
natsOptions_SetPedantic(natsOptions *opts, bool pedantic);
 
NATS_EXTERN natsStatus
natsOptions_SetPingInterval(natsOptions *opts, int64_t interval);
 
NATS_EXTERN natsStatus
natsOptions_SetMaxPingsOut(natsOptions *opts, int maxPingsOut);
 
NATS_EXTERN natsStatus
natsOptions_SetIOBufSize(natsOptions *opts, int ioBufSize);
 
NATS_EXTERN natsStatus
natsOptions_SetAllowReconnect(natsOptions *opts, bool allow);
 
NATS_EXTERN natsStatus
natsOptions_SetMaxReconnect(natsOptions *opts, int maxReconnect);
 
NATS_EXTERN natsStatus
natsOptions_SetReconnectWait(natsOptions *opts, int64_t reconnectWait);
 
NATS_EXTERN natsStatus
natsOptions_SetReconnectJitter(natsOptions *opts, int64_t jitter, int64_t jitterTLS);
 
NATS_EXTERN natsStatus
natsOptions_SetCustomReconnectDelay(natsOptions *opts,
                                    natsCustomReconnectDelayHandler cb,
                                    void *closure);
 
NATS_EXTERN natsStatus
natsOptions_SetReconnectBufSize(natsOptions *opts, int reconnectBufSize);
 
NATS_EXTERN natsStatus
natsOptions_SetMaxPendingMsgs(natsOptions *opts, int maxPending);
 
NATS_EXTERN natsStatus
natsOptions_SetMaxPendingBytes(natsOptions* opts, int64_t maxPending);
 
NATS_EXTERN natsStatus
natsOptions_SetErrorHandler(natsOptions *opts, natsErrHandler errHandler,
                            void *closure);
 
NATS_EXTERN natsStatus
natsOptions_SetClosedCB(natsOptions *opts, natsConnectionHandler closedCb,
                        void *closure);
 
NATS_EXTERN natsStatus
natsOptions_SetDisconnectedCB(natsOptions *opts,
                              natsConnectionHandler disconnectedCb,
                              void *closure);
 
NATS_EXTERN natsStatus
natsOptions_SetReconnectedCB(natsOptions *opts,
                             natsConnectionHandler reconnectedCb,
                             void *closure);
 
NATS_EXTERN natsStatus
natsOptions_SetDiscoveredServersCB(natsOptions *opts,
                                   natsConnectionHandler discoveredServersCb,
                                   void *closure);
 
NATS_EXTERN natsStatus
natsOptions_SetIgnoreDiscoveredServers(natsOptions *opts, bool ignore);
 
NATS_EXTERN natsStatus
natsOptions_SetLameDuckModeCB(natsOptions *opts,
                              natsConnectionHandler lameDuckCb,
                              void *closure);
 
NATS_EXTERN natsStatus
natsOptions_SetEventLoop(natsOptions *opts,
                         void *loop,
                         natsEvLoop_Attach          attachCb,
                         natsEvLoop_ReadAddRemove   readCb,
                         natsEvLoop_WriteAddRemove  writeCb,
                         natsEvLoop_Detach          detachCb);
 
NATS_EXTERN natsStatus
natsOptions_UseGlobalMessageDelivery(natsOptions *opts, bool global);
 
NATS_EXTERN natsStatus
natsOptions_IPResolutionOrder(natsOptions *opts, int order);
 
NATS_EXTERN natsStatus
natsOptions_SetSendAsap(natsOptions *opts, bool sendAsap);
 
NATS_EXTERN natsStatus
natsOptions_UseOldRequestStyle(natsOptions *opts, bool useOldStyle);
 
NATS_EXTERN natsStatus
natsOptions_SetFailRequestsOnDisconnect(natsOptions *opts, bool failRequests);
 
NATS_EXTERN natsStatus
natsOptions_SetNoEcho(natsOptions *opts, bool noEcho);
 
NATS_EXTERN natsStatus
natsOptions_SetRetryOnFailedConnect(natsOptions *opts, bool retry,
        natsConnectionHandler connectedCb, void* closure);
 
NATS_EXTERN natsStatus
natsOptions_SetUserCredentialsCallbacks(natsOptions *opts,
                                        natsUserJWTHandler      ujwtCB,
                                        void                    *ujwtClosure,
                                        natsSignatureHandler    sigCB,
                                        void                    *sigClosure);
 
NATS_EXTERN natsStatus
natsOptions_SetUserCredentialsFromFiles(natsOptions *opts,
                                        const char *userOrChainedFile,
                                        const char *seedFile);
 
NATS_EXTERN natsStatus
natsOptions_SetUserCredentialsFromMemory(natsOptions *opts,
                                         const char *jwtAndSeedContent);
 
NATS_EXTERN natsStatus
natsOptions_SetNKey(natsOptions             *opts,
                    const char              *pubKey,
                    natsSignatureHandler    sigCB,
                    void                    *sigClosure);
 
NATS_EXTERN natsStatus
natsOptions_SetNKeyFromSeed(natsOptions *opts,
                            const char  *pubKey,
                            const char  *seedFile);
 
NATS_EXTERN natsStatus
natsOptions_SetWriteDeadline(natsOptions *opts, int64_t deadline);
 
NATS_EXTERN natsStatus
natsOptions_DisableNoResponders(natsOptions *opts, bool disabled);
 
NATS_EXTERN natsStatus
natsOptions_SetCustomInboxPrefix(natsOptions *opts, const char *inboxPrefix);
 
NATS_EXTERN natsStatus
natsOptions_SetMessageBufferPadding(natsOptions *opts, int paddingSize);
 
NATS_EXTERN void
natsOptions_Destroy(natsOptions *opts);
 // end of optsGroup
 
#if defined(NATS_HAS_STREAMING)
NATS_EXTERN natsStatus
stanConnOptions_Create(stanConnOptions **newOpts);
 
NATS_EXTERN natsStatus
stanConnOptions_SetURL(stanConnOptions *opts, const char *url);
 
NATS_EXTERN natsStatus
stanConnOptions_SetNATSOptions(stanConnOptions *opts, natsOptions *nOpts);
 
NATS_EXTERN natsStatus
stanConnOptions_SetConnectionWait(stanConnOptions *opts, int64_t wait);
 
NATS_EXTERN natsStatus
stanConnOptions_SetPubAckWait(stanConnOptions *opts, int64_t wait);
 
NATS_EXTERN natsStatus
stanConnOptions_SetDiscoveryPrefix(stanConnOptions *opts, const char *prefix);
 
 
NATS_EXTERN natsStatus
stanConnOptions_SetMaxPubAcksInflight(stanConnOptions *opts, int maxPubAcksInflight, float percentage);
 
NATS_EXTERN natsStatus
stanConnOptions_SetPings(stanConnOptions *opts, int interval, int maxOut);
 
NATS_EXTERN natsStatus
stanConnOptions_SetConnectionLostHandler(stanConnOptions *opts, stanConnectionLostHandler handler, void *closure);
 
NATS_EXTERN void
stanConnOptions_Destroy(stanConnOptions *opts);
 // end of stanConnOptsGroup
 
NATS_EXTERN natsStatus
stanSubOptions_Create(stanSubOptions **newOpts);
 
NATS_EXTERN natsStatus
stanSubOptions_SetDurableName(stanSubOptions *opts, const char *durableName);
 
NATS_EXTERN natsStatus
stanSubOptions_SetAckWait(stanSubOptions *opts, int64_t wait);
 
NATS_EXTERN natsStatus
stanSubOptions_SetMaxInflight(stanSubOptions *opts, int maxInflight);
 
NATS_EXTERN natsStatus
stanSubOptions_StartAtSequence(stanSubOptions *opts, uint64_t seq);
 
NATS_EXTERN natsStatus
stanSubOptions_StartAtTime(stanSubOptions *opts, int64_t time);
 
NATS_EXTERN natsStatus
stanSubOptions_StartAtTimeDelta(stanSubOptions *opts, int64_t delta);
 
NATS_EXTERN natsStatus
stanSubOptions_StartWithLastReceived(stanSubOptions *opts);
 
NATS_EXTERN natsStatus
stanSubOptions_DeliverAllAvailable(stanSubOptions *opts);
 
NATS_EXTERN natsStatus
stanSubOptions_SetManualAckMode(stanSubOptions *opts, bool manual);
 
NATS_EXTERN void
stanSubOptions_Destroy(stanSubOptions *opts);
 // end of stanSubOptsGroup
#endif
 
NATS_EXTERN natsStatus
natsInbox_Create(natsInbox **newInbox);
 
NATS_EXTERN void
natsInbox_Destroy(natsInbox *inbox);
 // end of inboxGroup
 
NATS_EXTERN void
natsMsgList_Destroy(natsMsgList *list);
 
NATS_EXTERN natsStatus
natsMsg_Create(natsMsg **newMsg, const char *subj, const char *reply,
               const char *data, int dataLen);
 
NATS_EXTERN const char*
natsMsg_GetSubject(const natsMsg *msg);
 
NATS_EXTERN const char*
natsMsg_GetReply(const natsMsg *msg);
 
NATS_EXTERN const char*
natsMsg_GetData(const natsMsg *msg);
 
NATS_EXTERN int
natsMsg_GetDataLength(const natsMsg *msg);
 
NATS_EXTERN natsStatus
natsMsgHeader_Set(natsMsg *msg, const char *key, const char *value);
 
NATS_EXTERN natsStatus
natsMsgHeader_Add(natsMsg *msg, const char *key, const char *value);
 
NATS_EXTERN natsStatus
natsMsgHeader_Get(natsMsg *msg, const char *key, const char **value);
 
NATS_EXTERN natsStatus
natsMsgHeader_Values(natsMsg *msg, const char *key, const char* **values, int *count);
 
NATS_EXTERN natsStatus
natsMsgHeader_Keys(natsMsg *msg, const char* **keys, int *count);
 
NATS_EXTERN natsStatus
natsMsgHeader_Delete(natsMsg *msg, const char *key);
 
NATS_EXTERN bool
natsMsg_IsNoResponders(natsMsg *msg);
 
NATS_EXTERN void
natsMsg_Destroy(natsMsg *msg);
 // end of msgGroup
 
#if defined(NATS_HAS_STREAMING)
NATS_EXTERN uint64_t
stanMsg_GetSequence(const stanMsg *msg);
 
NATS_EXTERN int64_t
stanMsg_GetTimestamp(const stanMsg *msg);
 
NATS_EXTERN bool
stanMsg_IsRedelivered(const stanMsg *msg);
 
NATS_EXTERN const char*
stanMsg_GetData(const stanMsg *msg);
 
NATS_EXTERN int
stanMsg_GetDataLength(const stanMsg *msg);
 
NATS_EXTERN void
stanMsg_Destroy(stanMsg *msg);
 // end of stanMsgGroup
#endif
 
NATS_EXTERN natsStatus
natsConnection_Connect(natsConnection **nc, natsOptions *options);
 
natsStatus
natsConnection_Reconnect(natsConnection *nc);
 
NATS_EXTERN void
natsConnection_ProcessReadEvent(natsConnection *nc);
 
NATS_EXTERN void
natsConnection_ProcessWriteEvent(natsConnection *nc);
 
NATS_EXTERN natsStatus
natsConnection_ConnectTo(natsConnection **nc, const char *urls);
 
NATS_EXTERN bool
natsConnection_IsClosed(natsConnection *nc);
 
NATS_EXTERN bool
natsConnection_IsReconnecting(natsConnection *nc);
 
NATS_EXTERN bool
natsConnection_IsDraining(natsConnection *nc);
 
NATS_EXTERN natsConnStatus
natsConnection_Status(natsConnection *nc);
 
NATS_EXTERN int
natsConnection_Buffered(natsConnection *nc);
 
NATS_EXTERN natsStatus
natsConnection_Flush(natsConnection *nc);
 
NATS_EXTERN natsStatus
natsConnection_FlushTimeout(natsConnection *nc, int64_t timeout);
 
NATS_EXTERN int64_t
natsConnection_GetMaxPayload(natsConnection *nc);
 
NATS_EXTERN natsStatus
natsConnection_GetStats(natsConnection *nc, natsStatistics *stats);
 
NATS_EXTERN natsStatus
natsConnection_GetConnectedUrl(natsConnection *nc, char *buffer, size_t bufferSize);
 
NATS_EXTERN natsStatus
natsConnection_GetConnectedServerId(natsConnection *nc, char *buffer, size_t bufferSize);
 
NATS_EXTERN natsStatus
natsConnection_GetServers(natsConnection *nc, char ***servers, int *count);
 
NATS_EXTERN natsStatus
natsConnection_GetDiscoveredServers(natsConnection *nc, char ***servers, int *count);
 
NATS_EXTERN natsStatus
natsConnection_GetLastError(natsConnection *nc, const char **lastError);
 
NATS_EXTERN natsStatus
natsConnection_GetClientID(natsConnection *nc, uint64_t *cid);
 
NATS_EXTERN natsStatus
natsConnection_Drain(natsConnection *nc);
 
NATS_EXTERN natsStatus
natsConnection_DrainTimeout(natsConnection *nc, int64_t timeout);
 
NATS_EXTERN natsStatus
natsConnection_Sign(natsConnection *nc,
                    const unsigned char *message, int messageLen,
                    unsigned char sig[64]);
 
NATS_EXTERN natsStatus
natsConnection_GetClientIP(natsConnection *nc, char **ip);
 
NATS_EXTERN natsStatus
natsConnection_GetRTT(natsConnection *nc, int64_t *rtt);
 
NATS_EXTERN natsStatus
natsConnection_HasHeaderSupport(natsConnection *nc);
 
NATS_EXTERN natsStatus
natsConnection_GetLocalIPAndPort(natsConnection *nc, char **ip, int *port);
 
NATS_EXTERN void
natsConnection_Close(natsConnection *nc);
 
NATS_EXTERN void
natsConnection_Destroy(natsConnection *nc);
 // end of connMgtGroup
 
NATS_EXTERN natsStatus
natsConnection_Publish(natsConnection *nc, const char *subj,
                       const void *data, int dataLen);
 
NATS_EXTERN natsStatus
natsConnection_PublishString(natsConnection *nc, const char *subj,
                             const char *str);
 
NATS_EXTERN natsStatus
natsConnection_PublishMsg(natsConnection *nc, natsMsg *msg);
 
NATS_EXTERN natsStatus
natsConnection_PublishRequest(natsConnection *nc, const char *subj,
                              const char *reply, const void *data, int dataLen);
 
NATS_EXTERN natsStatus
natsConnection_PublishRequestString(natsConnection *nc, const char *subj,
                                    const char *reply, const char *str);
 
NATS_EXTERN natsStatus
natsConnection_Request(natsMsg **replyMsg, natsConnection *nc, const char *subj,
                       const void *data, int dataLen, int64_t timeout);
 
NATS_EXTERN natsStatus
natsConnection_RequestString(natsMsg **replyMsg, natsConnection *nc,
                             const char *subj, const char *str,
                             int64_t timeout);
 
NATS_EXTERN natsStatus
natsConnection_RequestMsg(natsMsg **replyMsg, natsConnection *nc,
                          natsMsg *requestMsg, int64_t timeout);
 // end of connPubGroup
 
NATS_EXTERN natsStatus
natsConnection_Subscribe(natsSubscription **sub, natsConnection *nc,
                         const char *subject, natsMsgHandler cb,
                         void *cbClosure);
 
NATS_EXTERN natsStatus
natsConnection_SubscribeTimeout(natsSubscription **sub, natsConnection *nc,
                                const char *subject, int64_t timeout,
                                natsMsgHandler cb, void *cbClosure);
 
NATS_EXTERN natsStatus
natsConnection_SubscribeSync(natsSubscription **sub, natsConnection *nc,
                             const char *subject);
 
NATS_EXTERN natsStatus
natsConnection_QueueSubscribe(natsSubscription **sub, natsConnection *nc,
                              const char *subject, const char *queueGroup,
                              natsMsgHandler cb, void *cbClosure);
 
NATS_EXTERN natsStatus
natsConnection_QueueSubscribeTimeout(natsSubscription **sub, natsConnection *nc,
                   const char *subject, const char *queueGroup,
                   int64_t timeout, natsMsgHandler cb, void *cbClosure);
 
NATS_EXTERN natsStatus
natsConnection_QueueSubscribeSync(natsSubscription **sub, natsConnection *nc,
                                  const char *subject, const char *queueGroup);
 // end of connSubGroup
 // end of connGroup
 
NATS_EXTERN natsStatus
natsSubscription_NoDeliveryDelay(natsSubscription *sub);
 
NATS_EXTERN natsStatus
natsSubscription_NextMsg(natsMsg **nextMsg, natsSubscription *sub,
                         int64_t timeout);
 
NATS_EXTERN natsStatus
natsSubscription_Unsubscribe(natsSubscription *sub);
 
NATS_EXTERN natsStatus
natsSubscription_AutoUnsubscribe(natsSubscription *sub, int max);
 
NATS_EXTERN natsStatus
natsSubscription_QueuedMsgs(natsSubscription *sub, uint64_t *queuedMsgs);
 
NATS_EXTERN int64_t
natsSubscription_GetID(natsSubscription* sub);
 
NATS_EXTERN const char*
natsSubscription_GetSubject(natsSubscription* sub);
 
NATS_EXTERN natsStatus
natsSubscription_SetPendingLimits(natsSubscription *sub, int msgLimit, int bytesLimit);
 
NATS_EXTERN natsStatus
natsSubscription_GetPendingLimits(natsSubscription *sub, int *msgLimit, int *bytesLimit);
 
NATS_EXTERN natsStatus
natsSubscription_GetPending(natsSubscription *sub, int *msgs, int *bytes);
 
NATS_EXTERN natsStatus
natsSubscription_GetDelivered(natsSubscription *sub, int64_t *msgs);
 
NATS_EXTERN natsStatus
natsSubscription_GetDropped(natsSubscription *sub, int64_t *msgs);
 
NATS_EXTERN natsStatus
natsSubscription_GetMaxPending(natsSubscription *sub, int *msgs, int *bytes);
 
NATS_EXTERN natsStatus
natsSubscription_ClearMaxPending(natsSubscription *sub);
 
NATS_EXTERN natsStatus
natsSubscription_GetStats(natsSubscription *sub,
                          int     *pendingMsgs,
                          int     *pendingBytes,
                          int     *maxPendingMsgs,
                          int     *maxPendingBytes,
                          int64_t *deliveredMsgs,
                          int64_t *droppedMsgs);
 
NATS_EXTERN bool
natsSubscription_IsValid(natsSubscription *sub);
 
NATS_EXTERN natsStatus
natsSubscription_Drain(natsSubscription *sub);
 
NATS_EXTERN natsStatus
natsSubscription_DrainTimeout(natsSubscription *sub, int64_t timeout);
 
NATS_EXTERN natsStatus
natsSubscription_WaitForDrainCompletion(natsSubscription *sub, int64_t timeout);
 
NATS_EXTERN natsStatus
natsSubscription_DrainCompletionStatus(natsSubscription *sub);
 
NATS_EXTERN natsStatus
natsSubscription_SetOnCompleteCB(natsSubscription *sub, natsOnCompleteCB cb, void *closure);
 
NATS_EXTERN void
natsSubscription_Destroy(natsSubscription *sub);
 // end of subGroup
 
#if defined(NATS_HAS_STREAMING)
NATS_EXTERN natsStatus
stanConnection_Connect(stanConnection **sc, const char *clusterID, const char *clientID,
                       stanConnOptions *options);
 
NATS_EXTERN natsStatus
stanConnection_GetNATSConnection(stanConnection *sc, natsConnection **nc);
 
NATS_EXTERN void
stanConnection_ReleaseNATSConnection(stanConnection *sc);
 
NATS_EXTERN natsStatus
stanConnection_Close(stanConnection *sc);
 
NATS_EXTERN natsStatus
stanConnection_Destroy(stanConnection *sc);
 // end of stanConnMgtGroup
 
NATS_EXTERN natsStatus
stanConnection_Publish(stanConnection *sc, const char *channel,
                       const void *data, int dataLen);
 
NATS_EXTERN natsStatus
stanConnection_PublishAsync(stanConnection *sc, const char *channel,
                            const void *data, int dataLen,
                            stanPubAckHandler ah, void *ahClosure);
 // end of stanConnPubGroup
 
NATS_EXTERN natsStatus
stanConnection_Subscribe(stanSubscription **sub, stanConnection *sc,
                         const char *channel, stanMsgHandler cb,
                         void *cbClosure, stanSubOptions *options);
 
NATS_EXTERN natsStatus
stanConnection_QueueSubscribe(stanSubscription **sub, stanConnection *sc,
                              const char *channel, const char *queueGroup,
                              stanMsgHandler cb, void *cbClosure, stanSubOptions *options);
 // end of stanConnSubGroup
 // end of stanConnGroup
 
NATS_EXTERN natsStatus
stanSubscription_SetOnCompleteCB(stanSubscription *sub, natsOnCompleteCB cb, void *closure);
 
NATS_EXTERN natsStatus
stanSubscription_AckMsg(stanSubscription *sub, stanMsg *msg);
 
NATS_EXTERN natsStatus
stanSubscription_Unsubscribe(stanSubscription *sub);
 
NATS_EXTERN natsStatus
stanSubscription_Close(stanSubscription *sub);
 
NATS_EXTERN void
stanSubscription_Destroy(stanSubscription *sub);
 // end of stanSubGroup
#endif
 
NATS_EXTERN natsStatus
jsOptions_Init(jsOptions *opts);
 
NATS_EXTERN natsStatus
natsConnection_JetStream(jsCtx **js, natsConnection *nc, jsOptions *opts);
 
NATS_EXTERN void
jsCtx_Destroy(jsCtx *js);
 
NATS_EXTERN natsStatus
jsStreamConfig_Init(jsStreamConfig *cfg);
 
NATS_EXTERN natsStatus
jsPlacement_Init(jsPlacement *placement);
 
NATS_EXTERN natsStatus
jsStreamSource_Init(jsStreamSource *source);
 
NATS_EXTERN natsStatus
jsExternalStream_Init(jsExternalStream *external);
 
NATS_EXTERN natsStatus
jsRePublish_Init(jsRePublish *rp);
 
NATS_EXTERN natsStatus
js_AddStream(jsStreamInfo **si, jsCtx *js, jsStreamConfig *cfg, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_UpdateStream(jsStreamInfo **si, jsCtx *js, jsStreamConfig *cfg, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_PurgeStream(jsCtx *js, const char *stream, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_DeleteStream(jsCtx *js, const char *stream, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_GetMsg(natsMsg **msg, jsCtx *js, const char *stream, uint64_t seq, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_GetLastMsg(natsMsg **msg, jsCtx *js, const char *stream, const char *subject, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
jsDirectGetMsgOptions_Init(jsDirectGetMsgOptions *opts);
 
NATS_EXTERN natsStatus
js_DirectGetMsg(natsMsg **msg, jsCtx *js, const char *stream, jsOptions *opts, jsDirectGetMsgOptions *dgOpts);
 
NATS_EXTERN natsStatus
js_DeleteMsg(jsCtx *js, const char *stream, uint64_t seq, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_EraseMsg(jsCtx *js, const char *stream, uint64_t seq, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_GetStreamInfo(jsStreamInfo **si, jsCtx *js, const char *stream, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN void
jsStreamInfo_Destroy(jsStreamInfo *si);
 
NATS_EXTERN natsStatus
js_Streams(jsStreamInfoList **list, jsCtx *js, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN void
jsStreamInfoList_Destroy(jsStreamInfoList *list);
 
NATS_EXTERN natsStatus
js_StreamNames(jsStreamNamesList **list, jsCtx *js, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN void
jsStreamNamesList_Destroy(jsStreamNamesList *list);
 
NATS_EXTERN natsStatus
jsConsumerConfig_Init(jsConsumerConfig *cc);
 
NATS_EXTERN natsStatus
js_AddConsumer(jsConsumerInfo **ci, jsCtx *js,
                   const char *stream, jsConsumerConfig *cfg,
                   jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_UpdateConsumer(jsConsumerInfo **ci, jsCtx *js,
                  const char *stream, jsConsumerConfig *cfg,
                  jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_GetConsumerInfo(jsConsumerInfo **ci, jsCtx *js,
                       const char *stream, const char *consumer,
                       jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_DeleteConsumer(jsCtx *js, const char *stream, const char *consumer,
                      jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_PauseConsumer(jsConsumerPauseResponse **new_cpr, jsCtx *js,
                 const char *stream, const char *consumer,
                 uint64_t pauseUntil, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN void
jsConsumerPauseResponse_Destroy(jsConsumerPauseResponse *cpr);
 
NATS_EXTERN void
jsConsumerInfo_Destroy(jsConsumerInfo *ci);
 
NATS_EXTERN natsStatus
js_Consumers(jsConsumerInfoList **list, jsCtx *js, const char *stream, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN void
jsConsumerInfoList_Destroy(jsConsumerInfoList *list);
 
NATS_EXTERN natsStatus
js_ConsumerNames(jsConsumerNamesList **list, jsCtx *js, const char *stream, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN void
jsConsumerNamesList_Destroy(jsConsumerNamesList *list);
 
NATS_EXTERN natsStatus
js_GetAccountInfo(jsAccountInfo **ai, jsCtx *js, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN void
jsAccountInfo_Destroy(jsAccountInfo *ai);
 // end of jsAssetsGroup
 
NATS_EXTERN natsStatus
jsPubOptions_Init(jsPubOptions *opts);
 
NATS_EXTERN natsStatus
js_Publish(jsPubAck **pubAck, jsCtx *js, const char *subj, const void *data, int dataLen,
           jsPubOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_PublishMsg(jsPubAck **pubAck, jsCtx *js, natsMsg *msg,
              jsPubOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN void
jsPubAck_Destroy(jsPubAck *pubAck);
 
NATS_EXTERN natsStatus
js_PublishAsync(jsCtx *js, const char *subj, const void *data, int dataLen,
                jsPubOptions *opts);
 
NATS_EXTERN natsStatus
js_PublishMsgAsync(jsCtx *js, natsMsg **msg, jsPubOptions *opts);
 
NATS_EXTERN natsStatus
js_PublishAsyncComplete(jsCtx *js, jsPubOptions *opts);
 
NATS_EXTERN natsStatus
js_PublishAsyncGetPendingList(natsMsgList *pending, jsCtx *js);
 // end of jsPubGroup
 
NATS_EXTERN natsStatus
jsSubOptions_Init(jsSubOptions *opts);
 
NATS_EXTERN natsStatus
js_Subscribe(natsSubscription **sub, jsCtx *js, const char *subject,
             natsMsgHandler cb, void* cbClosure,
             jsOptions *opts, jsSubOptions *subOpts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_SubscribeMulti(natsSubscription **sub, jsCtx *js, const char **subjects, int numSubjects,
             natsMsgHandler cb, void *cbClosure,
             jsOptions *opts, jsSubOptions *subOpts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_SubscribeSync(natsSubscription **sub, jsCtx *js, const char *subject,
                 jsOptions *opts, jsSubOptions *subOpts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_SubscribeSyncMulti(natsSubscription **sub, jsCtx *js, const char **subjects, int numSubjects,
                      jsOptions *opts, jsSubOptions *subOpts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
js_PullSubscribe(natsSubscription **sub, jsCtx *js, const char *subject, const char *durable,
                 jsOptions *opts, jsSubOptions *subOpts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
natsSubscription_Fetch(natsMsgList *list, natsSubscription *sub, int batch, int64_t timeout,
                       jsErrCode *errCode);
 
NATS_EXTERN natsStatus
jsFetchRequest_Init(jsFetchRequest *request);
 
NATS_EXTERN natsStatus
js_PullSubscribeAsync(natsSubscription **newsub, jsCtx *js, const char *subject, const char *durable,
                      natsMsgHandler msgCB, void *msgCBClosure,
                      jsOptions *jsOpts, jsSubOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
natsSubscription_FetchRequest(natsMsgList *list, natsSubscription *sub, jsFetchRequest *request);
 
NATS_EXTERN natsStatus
natsSubscription_GetConsumerInfo(jsConsumerInfo **ci, natsSubscription *sub,
                                 jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
natsSubscription_GetSequenceMismatch(jsConsumerSequenceMismatch *csm, natsSubscription *sub);
 // end of jsSubGroup
 
NATS_EXTERN natsStatus
natsMsg_GetMetaData(jsMsgMetaData **new_meta, natsMsg *msg);
 
NATS_EXTERN void
jsMsgMetaData_Destroy(jsMsgMetaData *meta);
 
NATS_EXTERN natsStatus
natsMsg_Ack(natsMsg *msg, jsOptions *opts);
 
NATS_EXTERN natsStatus
natsMsg_AckSync(natsMsg *msg, jsOptions *opts, jsErrCode *errCode);
 
NATS_EXTERN natsStatus
natsMsg_Nak(natsMsg *msg, jsOptions *opts);
 
NATS_EXTERN natsStatus
natsMsg_NakWithDelay(natsMsg *msg, int64_t delay, jsOptions *opts);
 
NATS_EXTERN natsStatus
natsMsg_InProgress(natsMsg *msg, jsOptions *opts);
 
NATS_EXTERN natsStatus
natsMsg_Term(natsMsg *msg, jsOptions *opts);
 
NATS_EXTERN uint64_t
natsMsg_GetSequence(natsMsg *msg);
 
NATS_EXTERN int64_t
natsMsg_GetTime(natsMsg *msg);
 // end of jsMsg
 // end of jsGroup
 
NATS_EXTERN natsStatus
kvConfig_Init(kvConfig *cfg);
 
NATS_EXTERN natsStatus
js_CreateKeyValue(kvStore **new_kv, jsCtx *js, kvConfig *cfg);
 
NATS_EXTERN natsStatus
js_KeyValue(kvStore **new_kv, jsCtx *js, const char *bucket);
 
NATS_EXTERN natsStatus
js_DeleteKeyValue(jsCtx *js, const char *bucket);
 
NATS_EXTERN void
kvStore_Destroy(kvStore *kv);
 // end of  kvGroupMgt
 
NATS_EXTERN const char*
kvEntry_Bucket(kvEntry *e);
 
NATS_EXTERN const char*
kvEntry_Key(kvEntry *e);
 
NATS_EXTERN const void*
kvEntry_Value(kvEntry *e);
 
NATS_EXTERN int
kvEntry_ValueLen(kvEntry *e);
 
NATS_EXTERN const char*
kvEntry_ValueString(kvEntry *e);
 
NATS_EXTERN uint64_t
kvEntry_Revision(kvEntry *e);
 
NATS_EXTERN int64_t
kvEntry_Created(kvEntry *e);
 
NATS_EXTERN uint64_t
kvEntry_Delta(kvEntry *e);
 
NATS_EXTERN kvOperation
kvEntry_Operation(kvEntry *e);
 
NATS_EXTERN void
kvEntry_Destroy(kvEntry *e);
 // end of kvEntry
 
NATS_EXTERN natsStatus
kvStore_Get(kvEntry **new_entry, kvStore *kv, const char *key);
 
NATS_EXTERN natsStatus
kvStore_GetRevision(kvEntry **new_entry, kvStore *kv, const char *key, uint64_t revision);
 
NATS_EXTERN natsStatus
kvStore_Put(uint64_t *rev, kvStore *kv, const char *key, const void *data, int len);
 
NATS_EXTERN natsStatus
kvStore_PutString(uint64_t *rev, kvStore *kv, const char *key, const char *data);
 
NATS_EXTERN natsStatus
kvStore_Create(uint64_t *rev, kvStore *kv, const char *key, const void *data, int len);
 
NATS_EXTERN natsStatus
kvStore_CreateString(uint64_t *rev, kvStore *kv, const char *key, const char *data);
 
NATS_EXTERN natsStatus
kvStore_Update(uint64_t *rev, kvStore *kv, const char *key, const void *data, int len, uint64_t last);
 
NATS_EXTERN natsStatus
kvStore_UpdateString(uint64_t *rev, kvStore *kv, const char *key, const char *data, uint64_t last);
 
NATS_EXTERN natsStatus
kvStore_Delete(kvStore *kv, const char *key);
 
NATS_EXTERN natsStatus
kvStore_Purge(kvStore *kv, const char *key, kvPurgeOptions *opts);
 
NATS_EXTERN natsStatus
kvWatchOptions_Init(kvWatchOptions *opts);
 
NATS_EXTERN natsStatus
kvPurgeOptions_Init(kvPurgeOptions *opts);
 
NATS_EXTERN natsStatus
kvStore_PurgeDeletes(kvStore *kv, kvPurgeOptions *opts);
 
NATS_EXTERN natsStatus
kvStore_Watch(kvWatcher **new_watcher, kvStore *kv, const char *keys, kvWatchOptions *opts);
 
NATS_EXTERN natsStatus
kvStore_WatchMulti(kvWatcher **new_watcher, kvStore *kv, const char **keys, int numKeys, kvWatchOptions *opts);
 
NATS_EXTERN natsStatus
kvStore_WatchAll(kvWatcher **new_watcher, kvStore *kv, kvWatchOptions *opts);
 
NATS_EXTERN natsStatus
kvStore_Keys(kvKeysList *list, kvStore *kv, kvWatchOptions *opts);
 
NATS_EXTERN natsStatus
kvStore_KeysWithFilters(kvKeysList *list, kvStore *kv, const char **filters, int numFilters, kvWatchOptions *opts);
 
NATS_EXTERN void
kvKeysList_Destroy(kvKeysList *list);
 
NATS_EXTERN natsStatus
kvStore_History(kvEntryList *list, kvStore *kv, const char *key, kvWatchOptions *opts);
 
NATS_EXTERN void
kvEntryList_Destroy(kvEntryList *list);
 
NATS_EXTERN const char*
kvStore_Bucket(kvStore *kv);
 
// PurgeDeletes
 
NATS_EXTERN natsStatus
kvStore_Status(kvStatus **new_status, kvStore *kv);
 
NATS_EXTERN natsStatus
kvWatcher_Next(kvEntry **new_entry, kvWatcher *w, int64_t timeout);
 
NATS_EXTERN natsStatus
kvWatcher_Stop(kvWatcher *w);
 
NATS_EXTERN void
kvWatcher_Destroy(kvWatcher *w);
 // end of kvWatcher
 
NATS_EXTERN const char*
kvStatus_Bucket(kvStatus *sts);
 
NATS_EXTERN uint64_t
kvStatus_Values(kvStatus *sts);
 
NATS_EXTERN int64_t
kvStatus_History(kvStatus *sts);
 
NATS_EXTERN int64_t
kvStatus_TTL(kvStatus *sts);
 
NATS_EXTERN int64_t
kvStatus_Replicas(kvStatus *sts);
 
NATS_EXTERN uint64_t
kvStatus_Bytes(kvStatus *sts);
 
NATS_EXTERN void
kvStatus_Destroy(kvStatus *sts);
 // end of kvStatus
 // end of kvGroup
 // end of funcGroup
 
//
// Microservices.
//
 
typedef struct micro_client_s microClient;
 
typedef struct __for_forward_compatibility_only microClientConfig;
 
typedef struct micro_endpoint_s microEndpoint;
 
typedef struct micro_endpoint_config_s microEndpointConfig;
 
typedef struct micro_endpoint_info_s microEndpointInfo;
 
typedef struct micro_endpoint_stats_s microEndpointStats;
 
typedef struct micro_error_s microError;
 
typedef struct micro_group_s microGroup;
 
typedef struct micro_group_config_s microGroupConfig;
 
typedef struct micro_request_s microRequest;
 
typedef struct micro_service_s microService;
 
typedef struct micro_service_config_s microServiceConfig;
 
typedef struct micro_service_info_s microServiceInfo;
 
typedef struct micro_service_stats_s microServiceStats;
 
 
extern NATS_EXTERN microError *micro_ErrorOutOfMemory;
extern NATS_EXTERN microError *micro_ErrorInvalidArg;
 // end of microTypes
 
typedef microError *(*microRequestHandler)(microRequest *req);
 
typedef void (*microErrorHandler)(microService *m, microEndpoint *ep, natsStatus s);
 
typedef void (*microDoneHandler)(microService *m);
 // end of microCallbacks
 
struct micro_endpoint_config_s
{
    const char *Name;
 
    const char *Subject;
 
    const char *QueueGroup;
 
    bool NoQueueGroup;
 
    natsMetadata Metadata;
 
    microRequestHandler Handler;
 
    void *State;
};
 
struct micro_endpoint_info_s
{
    const char *Name;
 
    const char *Subject;
 
    const char *QueueGroup;
 
    natsMetadata Metadata;
};
 
struct micro_endpoint_stats_s
{
    const char *Name;
    const char *Subject;
 
    const char *QueueGroup;
 
    int64_t NumRequests;
 
    int64_t NumErrors;
 
    int64_t ProcessingTimeSeconds;
 
    int64_t ProcessingTimeNanoseconds;
 
    int64_t AverageProcessingTimeNanoseconds;
 
    char LastErrorString[2048];
};
 
struct micro_group_config_s
{
    const char *Prefix;
 
    const char *QueueGroup;
 
    bool NoQueueGroup;
};
 
struct micro_service_config_s
{
    const char *Name;
 
    const char *Version;
 
    const char *Description;
 
    const char *QueueGroup;
 
    bool NoQueueGroup;
 
    natsMetadata Metadata;
 
    microEndpointConfig *Endpoint;
 
    microRequestHandler StatsHandler;
 
    microErrorHandler ErrHandler;
 
    microDoneHandler DoneHandler;
 
    void *State;
};
 
struct micro_service_info_s
{
    const char *Type;
 
    const char *Name;
 
    const char *Version;
 
    const char *Description;
 
    const char *Id;
 
    natsMetadata Metadata;
 
    microEndpointInfo *Endpoints;
 
    int EndpointsLen;
};
 
struct micro_service_stats_s
{
    const char *Type;
 
    const char *Name;
 
    const char *Version;
 
    const char *Id;
 
    int64_t Started;
 
    microEndpointStats *Endpoints;
 
    int EndpointsLen;
};
 // end of microStructs
 
#define MICRO_API_PREFIX "$SRV"
 
#define MICRO_INFO_RESPONSE_TYPE "io.nats.micro.v1.info_response"
 
#define MICRO_INFO_VERB "INFO"
 
#define MICRO_PING_RESPONSE_TYPE "io.nats.micro.v1.ping_response"
 
#define MICRO_PING_VERB "PING"
 
#define MICRO_STATS_RESPONSE_TYPE "io.nats.micro.v1.stats_response"
 
#define MICRO_STATS_VERB "STATS"
 
#define MICRO_STATUS_HDR "Nats-Status"
 
#define MICRO_ERROR_HDR "Nats-Service-Error"
 
#define MICRO_ERROR_CODE_HDR "Nats-Service-Error-Code"
 // end of microConstants
 
NATS_EXTERN microError *
micro_AddService(microService **new_microservice, natsConnection *nc, microServiceConfig *config);
 
NATS_EXTERN microError *
microService_AddEndpoint(microService *m, microEndpointConfig *config);
 
NATS_EXTERN microError *
microService_AddGroup(microGroup **new_group, microService *m, microGroupConfig *config);
 
NATS_EXTERN microError *
microService_Destroy(microService *m);
 
NATS_EXTERN natsConnection *
microService_GetConnection(microService *m);
 
NATS_EXTERN microError *
microService_GetInfo(microServiceInfo **new_info, microService *m);
 
NATS_EXTERN void *
microService_GetState(microService *m);
 
NATS_EXTERN microError *
microService_GetStats(microServiceStats **new_stats, microService *m);
 
NATS_EXTERN bool
microService_IsStopped(microService *m);
 
NATS_EXTERN microError *
microService_Run(microService *m);
 
NATS_EXTERN microError *microService_Stop(microService *m);
 // end of microServiceFunctions
 
NATS_EXTERN microError *
microGroup_AddGroup(microGroup **new_group, microGroup *parent, microGroupConfig *config);
 
NATS_EXTERN microError *
microGroup_AddEndpoint(microGroup *g, microEndpointConfig *config);
 // end of microGroupFunctions
 
NATS_EXTERN microError *
microRequest_AddHeader(microRequest *req, const char *key, const char *value);
 
NATS_EXTERN microError *
microRequest_DeleteHeader(microRequest *req, const char *key);
 
NATS_EXTERN natsConnection *
microRequest_GetConnection(microRequest *req);
 
NATS_EXTERN const char *
microRequest_GetData(microRequest *req);
 
NATS_EXTERN int
microRequest_GetDataLength(microRequest *req);
 
NATS_EXTERN void *
microRequest_GetEndpointState(microRequest *req);
 
NATS_EXTERN microError *
microRequest_GetHeaderKeys(microRequest *req, const char ***keys, int *count);
 
NATS_EXTERN microError *
microRequest_GetHeaderValue(microRequest *req, const char *key, const char **value);
 
NATS_EXTERN microError *
microRequest_GetHeaderValues(microRequest *req, const char *key, const char ***values, int *count);
 
NATS_EXTERN natsMsg *
microRequest_GetMsg(microRequest *req);
 
NATS_EXTERN const char *
microRequest_GetReply(microRequest *req);
 
NATS_EXTERN microService *
microRequest_GetService(microRequest *req);
 
NATS_EXTERN void *
microRequest_GetServiceState(microRequest *req);
 
NATS_EXTERN const char *
microRequest_GetSubject(microRequest *req);
 
NATS_EXTERN microError *
microRequest_Respond(microRequest *req, const char *data, size_t len);
 
NATS_EXTERN microError *
microRequest_RespondError(microRequest *req, microError *err);
 
NATS_EXTERN microError *
microRequest_RespondCustom(microRequest *req, microError *err, const char *data, size_t len);
 
NATS_EXTERN microError *
microRequest_SetHeader(microRequest *req, const char *key, const char *value);
 // end of microRequestFunctions
 
NATS_EXTERN microError *
micro_Errorf(const char *format, ...);
 
NATS_EXTERN microError *
micro_ErrorfCode(int code, const char *format, ...);
 
NATS_EXTERN microError *
micro_ErrorFromStatus(natsStatus s);
 
NATS_EXTERN int
microError_Code(microError *err);
 
NATS_EXTERN void
microError_Destroy(microError *err);
 
#define microError_Ignore(__err) microError_Destroy(__err)
 
NATS_EXTERN natsStatus
microError_Status(microError *err);
 
NATS_EXTERN const char *
microError_String(microError *err, char *buf, size_t len);
 
NATS_EXTERN microError *
microError_Wrapf(microError *err, const char *format, ...);
 // end of microErrorFunctions
 
NATS_EXTERN microError *
micro_NewClient(microClient **new_client, natsConnection *nc, microClientConfig *cfg);
 
NATS_EXTERN void
microClient_Destroy(microClient *client);
 
NATS_EXTERN microError *
microClient_DoRequest(natsMsg **reply, microClient *client, const char *subject, const char *data, int data_len);
 // end of microClientFunctions
 
NATS_EXTERN void
microServiceInfo_Destroy(microServiceInfo *info);
 
NATS_EXTERN void
microServiceStats_Destroy(microServiceStats *stats);
 // end of microCleanupFunctions
 // end of microFunctions
 // end of microGroup
 
#ifdef __cplusplus
}
#endif
 
#endif /* NATS_H_ */