@waku/core 0.0.31-1887f4f.0 → 0.0.31-39f8920.0

package/bundle/{version_0-SMRUXDNR.js → version_0-CNRKFufI.js}

@@ -1,4 +1,4 @@
-import { a as allocUnsafe, f as fromString, b as alloc$1, L as Logger, e as determinePubsubTopic } from './index-COT0phC8.js';
+import { a as allocUnsafe, f as fromString, b as alloc$1, L as Logger, g as determinePubsubTopic } from './index-Gts2Ddu_.js';
 
 /* eslint-disable no-fallthrough */
 const N1 = Math.pow(2, 7);
@@ -920,7 +920,7 @@ function decodeMessage(buf, codec, opts) {
  * A general purpose buffer pool
  */
 function pool(size) {
-    const SIZE = size ?? 8192;
+    const SIZE = 8192;
     const MAX = SIZE >>> 1;
     let slab;
     let offset = SIZE;
@@ -1433,12 +1433,17 @@ function message$1(encode, decode) {
  * npm i protons-runtime
  * ```
  */
-class CodeError extends Error {
-    code;
-    constructor(message, code, options) {
-        super(message, options);
-        this.code = code;
-    }
+/**
+ * Thrown when a repeated field has too many elements
+ */
+class MaxLengthError extends Error {
+    /**
+     * This will be removed in a future release
+     *
+     * @deprecated use the `.name` property instead
+     */
+    code = 'ERR_MAX_LENGTH';
+    name = 'MaxLengthError';
 }
 
 /* eslint-disable import/export */
@@ -1746,7 +1751,7 @@ var FilterRequest;
                         }
                         case 3: {
                             if (opts.limits?.contentFilters != null && obj.contentFilters.length === opts.limits.contentFilters) {
-                                throw new CodeError('decode error - map field "contentFilters" had too many elements', 'ERR_MAX_LENGTH');
+                                throw new MaxLengthError('Decode error - map field "contentFilters" had too many elements');
                             }
                             obj.contentFilters.push(FilterRequest.ContentFilter.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.contentFilters$
@@ -1799,7 +1804,7 @@ var MessagePush$1;
                     switch (tag >>> 3) {
                         case 1: {
                             if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) {
-                                throw new CodeError('decode error - map field "messages" had too many elements', 'ERR_MAX_LENGTH');
+                                throw new MaxLengthError('Decode error - map field "messages" had too many elements');
                             }
                             obj.messages.push(WakuMessage$3.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.messages$
@@ -2218,7 +2223,7 @@ var FilterSubscribeRequest;
                         }
                         case 11: {
                             if (opts.limits?.contentTopics != null && obj.contentTopics.length === opts.limits.contentTopics) {
-                                throw new CodeError('decode error - map field "contentTopics" had too many elements', 'ERR_MAX_LENGTH');
+                                throw new MaxLengthError('Decode error - map field "contentTopics" had too many elements');
                             }
                             obj.contentTopics.push(reader.string());
                             break;
@@ -2940,113 +2945,26 @@ var WakuMessage$1;
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
-var Index;
-(function (Index) {
+var WakuMessageKeyValue;
+(function (WakuMessageKeyValue) {
     let _codec;
-    Index.codec = () => {
+    WakuMessageKeyValue.codec = () => {
         if (_codec == null) {
             _codec = message$1((obj, w, opts = {}) => {
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if ((obj.digest != null && obj.digest.byteLength > 0)) {
+                if (obj.messageHash != null) {
                     w.uint32(10);
-                    w.bytes(obj.digest);
-                }
-                if ((obj.receiverTime != null && obj.receiverTime !== 0n)) {
-                    w.uint32(16);
-                    w.sint64(obj.receiverTime);
-                }
-                if ((obj.senderTime != null && obj.senderTime !== 0n)) {
-                    w.uint32(24);
-                    w.sint64(obj.senderTime);
-                }
-                if ((obj.pubsubTopic != null && obj.pubsubTopic !== '')) {
-                    w.uint32(34);
-                    w.string(obj.pubsubTopic);
-                }
-                if (opts.lengthDelimited !== false) {
-                    w.ldelim();
-                }
-            }, (reader, length, opts = {}) => {
-                const obj = {
-                    digest: alloc$1(0),
-                    receiverTime: 0n,
-                    senderTime: 0n,
-                    pubsubTopic: ''
-                };
-                const end = length == null ? reader.len : reader.pos + length;
-                while (reader.pos < end) {
-                    const tag = reader.uint32();
-                    switch (tag >>> 3) {
-                        case 1: {
-                            obj.digest = reader.bytes();
-                            break;
-                        }
-                        case 2: {
-                            obj.receiverTime = reader.sint64();
-                            break;
-                        }
-                        case 3: {
-                            obj.senderTime = reader.sint64();
-                            break;
-                        }
-                        case 4: {
-                            obj.pubsubTopic = reader.string();
-                            break;
-                        }
-                        default: {
-                            reader.skipType(tag & 7);
-                            break;
-                        }
-                    }
+                    w.bytes(obj.messageHash);
                 }
-                return obj;
-            });
-        }
-        return _codec;
-    };
-    Index.encode = (obj) => {
-        return encodeMessage(obj, Index.codec());
-    };
-    Index.decode = (buf, opts) => {
-        return decodeMessage(buf, Index.codec(), opts);
-    };
-})(Index || (Index = {}));
-var PagingInfo;
-(function (PagingInfo) {
-    (function (Direction) {
-        Direction["BACKWARD"] = "BACKWARD";
-        Direction["FORWARD"] = "FORWARD";
-    })(PagingInfo.Direction || (PagingInfo.Direction = {}));
-    let __DirectionValues;
-    (function (__DirectionValues) {
-        __DirectionValues[__DirectionValues["BACKWARD"] = 0] = "BACKWARD";
-        __DirectionValues[__DirectionValues["FORWARD"] = 1] = "FORWARD";
-    })(__DirectionValues || (__DirectionValues = {}));
-    (function (Direction) {
-        Direction.codec = () => {
-            return enumeration(__DirectionValues);
-        };
-    })(PagingInfo.Direction || (PagingInfo.Direction = {}));
-    let _codec;
-    PagingInfo.codec = () => {
-        if (_codec == null) {
-            _codec = message$1((obj, w, opts = {}) => {
-                if (opts.lengthDelimited !== false) {
-                    w.fork();
-                }
-                if (obj.pageSize != null) {
-                    w.uint32(8);
-                    w.uint64(obj.pageSize);
-                }
-                if (obj.cursor != null) {
+                if (obj.message != null) {
                     w.uint32(18);
-                    Index.codec().encode(obj.cursor, w);
+                    WakuMessage.codec().encode(obj.message, w);
                 }
-                if (obj.direction != null) {
-                    w.uint32(24);
-                    PagingInfo.Direction.codec().encode(obj.direction, w);
+                if (obj.pubsubTopic != null) {
+                    w.uint32(26);
+                    w.string(obj.pubsubTopic);
                 }
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
@@ -3058,17 +2976,17 @@ var PagingInfo;
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
                         case 1: {
-                            obj.pageSize = reader.uint64();
+                            obj.messageHash = reader.bytes();
                             break;
                         }
                         case 2: {
-                            obj.cursor = Index.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.cursor
+                            obj.message = WakuMessage.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.message
                             });
                             break;
                         }
                         case 3: {
-                            obj.direction = PagingInfo.Direction.codec().decode(reader);
+                            obj.pubsubTopic = reader.string();
                             break;
                         }
                         default: {
@@ -3082,217 +3000,125 @@ var PagingInfo;
         }
         return _codec;
     };
-    PagingInfo.encode = (obj) => {
-        return encodeMessage(obj, PagingInfo.codec());
+    WakuMessageKeyValue.encode = (obj) => {
+        return encodeMessage(obj, WakuMessageKeyValue.codec());
     };
-    PagingInfo.decode = (buf, opts) => {
-        return decodeMessage(buf, PagingInfo.codec(), opts);
+    WakuMessageKeyValue.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMessageKeyValue.codec(), opts);
     };
-})(PagingInfo || (PagingInfo = {}));
-var ContentFilter;
-(function (ContentFilter) {
+})(WakuMessageKeyValue || (WakuMessageKeyValue = {}));
+var StoreQueryRequest$1;
+(function (StoreQueryRequest) {
     let _codec;
-    ContentFilter.codec = () => {
+    StoreQueryRequest.codec = () => {
         if (_codec == null) {
             _codec = message$1((obj, w, opts = {}) => {
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if ((obj.contentTopic != null && obj.contentTopic !== '')) {
+                if ((obj.requestId != null && obj.requestId !== '')) {
                     w.uint32(10);
-                    w.string(obj.contentTopic);
+                    w.string(obj.requestId);
                 }
-                if (opts.lengthDelimited !== false) {
-                    w.ldelim();
+                if ((obj.includeData != null && obj.includeData !== false)) {
+                    w.uint32(16);
+                    w.bool(obj.includeData);
                 }
-            }, (reader, length, opts = {}) => {
-                const obj = {
-                    contentTopic: ''
-                };
-                const end = length == null ? reader.len : reader.pos + length;
-                while (reader.pos < end) {
-                    const tag = reader.uint32();
-                    switch (tag >>> 3) {
-                        case 1: {
-                            obj.contentTopic = reader.string();
-                            break;
-                        }
-                        default: {
-                            reader.skipType(tag & 7);
-                            break;
-                        }
+                if (obj.pubsubTopic != null) {
+                    w.uint32(82);
+                    w.string(obj.pubsubTopic);
+                }
+                if (obj.contentTopics != null) {
+                    for (const value of obj.contentTopics) {
+                        w.uint32(90);
+                        w.string(value);
                     }
                 }
-                return obj;
-            });
-        }
-        return _codec;
-    };
-    ContentFilter.encode = (obj) => {
-        return encodeMessage(obj, ContentFilter.codec());
-    };
-    ContentFilter.decode = (buf, opts) => {
-        return decodeMessage(buf, ContentFilter.codec(), opts);
-    };
-})(ContentFilter || (ContentFilter = {}));
-var HistoryQuery;
-(function (HistoryQuery) {
-    let _codec;
-    HistoryQuery.codec = () => {
-        if (_codec == null) {
-            _codec = message$1((obj, w, opts = {}) => {
-                if (opts.lengthDelimited !== false) {
-                    w.fork();
+                if (obj.timeStart != null) {
+                    w.uint32(96);
+                    w.sint64(obj.timeStart);
                 }
-                if (obj.pubsubTopic != null) {
-                    w.uint32(18);
-                    w.string(obj.pubsubTopic);
+                if (obj.timeEnd != null) {
+                    w.uint32(104);
+                    w.sint64(obj.timeEnd);
                 }
-                if (obj.contentFilters != null) {
-                    for (const value of obj.contentFilters) {
-                        w.uint32(26);
-                        ContentFilter.codec().encode(value, w);
+                if (obj.messageHashes != null) {
+                    for (const value of obj.messageHashes) {
+                        w.uint32(162);
+                        w.bytes(value);
                     }
                 }
-                if (obj.pagingInfo != null) {
-                    w.uint32(34);
-                    PagingInfo.codec().encode(obj.pagingInfo, w);
+                if (obj.paginationCursor != null) {
+                    w.uint32(410);
+                    w.bytes(obj.paginationCursor);
                 }
-                if (obj.startTime != null) {
-                    w.uint32(40);
-                    w.sint64(obj.startTime);
+                if ((obj.paginationForward != null && obj.paginationForward !== false)) {
+                    w.uint32(416);
+                    w.bool(obj.paginationForward);
                 }
-                if (obj.endTime != null) {
-                    w.uint32(48);
-                    w.sint64(obj.endTime);
+                if (obj.paginationLimit != null) {
+                    w.uint32(424);
+                    w.uint64(obj.paginationLimit);
                 }
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
             }, (reader, length, opts = {}) => {
                 const obj = {
-                    contentFilters: []
+                    requestId: '',
+                    includeData: false,
+                    contentTopics: [],
+                    messageHashes: [],
+                    paginationForward: false
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 2: {
-                            obj.pubsubTopic = reader.string();
+                        case 1: {
+                            obj.requestId = reader.string();
                             break;
                         }
-                        case 3: {
-                            if (opts.limits?.contentFilters != null && obj.contentFilters.length === opts.limits.contentFilters) {
-                                throw new CodeError('decode error - map field "contentFilters" had too many elements', 'ERR_MAX_LENGTH');
-                            }
-                            obj.contentFilters.push(ContentFilter.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.contentFilters$
-                            }));
+                        case 2: {
+                            obj.includeData = reader.bool();
                             break;
                         }
-                        case 4: {
-                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.pagingInfo
-                            });
+                        case 10: {
+                            obj.pubsubTopic = reader.string();
                             break;
                         }
-                        case 5: {
-                            obj.startTime = reader.sint64();
+                        case 11: {
+                            if (opts.limits?.contentTopics != null && obj.contentTopics.length === opts.limits.contentTopics) {
+                                throw new MaxLengthError('Decode error - map field "contentTopics" had too many elements');
+                            }
+                            obj.contentTopics.push(reader.string());
                             break;
                         }
-                        case 6: {
-                            obj.endTime = reader.sint64();
+                        case 12: {
+                            obj.timeStart = reader.sint64();
                             break;
                         }
-                        default: {
-                            reader.skipType(tag & 7);
+                        case 13: {
+                            obj.timeEnd = reader.sint64();
                             break;
                         }
-                    }
-                }
-                return obj;
-            });
-        }
-        return _codec;
-    };
-    HistoryQuery.encode = (obj) => {
-        return encodeMessage(obj, HistoryQuery.codec());
-    };
-    HistoryQuery.decode = (buf, opts) => {
-        return decodeMessage(buf, HistoryQuery.codec(), opts);
-    };
-})(HistoryQuery || (HistoryQuery = {}));
-var HistoryResponse;
-(function (HistoryResponse) {
-    let HistoryError;
-    (function (HistoryError) {
-        HistoryError["NONE"] = "NONE";
-        HistoryError["INVALID_CURSOR"] = "INVALID_CURSOR";
-        HistoryError["TOO_MANY_REQUESTS"] = "TOO_MANY_REQUESTS";
-        HistoryError["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
-    })(HistoryError = HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
-    let __HistoryErrorValues;
-    (function (__HistoryErrorValues) {
-        __HistoryErrorValues[__HistoryErrorValues["NONE"] = 0] = "NONE";
-        __HistoryErrorValues[__HistoryErrorValues["INVALID_CURSOR"] = 1] = "INVALID_CURSOR";
-        __HistoryErrorValues[__HistoryErrorValues["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
-        __HistoryErrorValues[__HistoryErrorValues["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
-    })(__HistoryErrorValues || (__HistoryErrorValues = {}));
-    (function (HistoryError) {
-        HistoryError.codec = () => {
-            return enumeration(__HistoryErrorValues);
-        };
-    })(HistoryError = HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
-    let _codec;
-    HistoryResponse.codec = () => {
-        if (_codec == null) {
-            _codec = message$1((obj, w, opts = {}) => {
-                if (opts.lengthDelimited !== false) {
-                    w.fork();
-                }
-                if (obj.messages != null) {
-                    for (const value of obj.messages) {
-                        w.uint32(18);
-                        WakuMessage.codec().encode(value, w);
-                    }
-                }
-                if (obj.pagingInfo != null) {
-                    w.uint32(26);
-                    PagingInfo.codec().encode(obj.pagingInfo, w);
-                }
-                if (obj.error != null && __HistoryErrorValues[obj.error] !== 0) {
-                    w.uint32(32);
-                    HistoryResponse.HistoryError.codec().encode(obj.error, w);
-                }
-                if (opts.lengthDelimited !== false) {
-                    w.ldelim();
-                }
-            }, (reader, length, opts = {}) => {
-                const obj = {
-                    messages: [],
-                    error: HistoryError.NONE
-                };
-                const end = length == null ? reader.len : reader.pos + length;
-                while (reader.pos < end) {
-                    const tag = reader.uint32();
-                    switch (tag >>> 3) {
-                        case 2: {
-                            if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) {
-                                throw new CodeError('decode error - map field "messages" had too many elements', 'ERR_MAX_LENGTH');
+                        case 20: {
+                            if (opts.limits?.messageHashes != null && obj.messageHashes.length === opts.limits.messageHashes) {
+                                throw new MaxLengthError('Decode error - map field "messageHashes" had too many elements');
                             }
-                            obj.messages.push(WakuMessage.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.messages$
-                            }));
+                            obj.messageHashes.push(reader.bytes());
                             break;
                         }
-                        case 3: {
-                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.pagingInfo
-                            });
+                        case 51: {
+                            obj.paginationCursor = reader.bytes();
                             break;
                         }
-                        case 4: {
-                            obj.error = HistoryResponse.HistoryError.codec().decode(reader);
+                        case 52: {
+                            obj.paginationForward = reader.bool();
+                            break;
+                        }
+                        case 53: {
+                            obj.paginationLimit = reader.uint64();
                             break;
                         }
                         default: {
@@ -3306,17 +3132,17 @@ var HistoryResponse;
         }
         return _codec;
     };
-    HistoryResponse.encode = (obj) => {
-        return encodeMessage(obj, HistoryResponse.codec());
+    StoreQueryRequest.encode = (obj) => {
+        return encodeMessage(obj, StoreQueryRequest.codec());
     };
-    HistoryResponse.decode = (buf, opts) => {
-        return decodeMessage(buf, HistoryResponse.codec(), opts);
+    StoreQueryRequest.decode = (buf, opts) => {
+        return decodeMessage(buf, StoreQueryRequest.codec(), opts);
     };
-})(HistoryResponse || (HistoryResponse = {}));
-var HistoryRpc$1;
-(function (HistoryRpc) {
+})(StoreQueryRequest$1 || (StoreQueryRequest$1 = {}));
+var StoreQueryResponse$1;
+(function (StoreQueryResponse) {
     let _codec;
-    HistoryRpc.codec = () => {
+    StoreQueryResponse.codec = () => {
         if (_codec == null) {
             _codec = message$1((obj, w, opts = {}) => {
                 if (opts.lengthDelimited !== false) {
@@ -3326,20 +3152,31 @@ var HistoryRpc$1;
                     w.uint32(10);
                     w.string(obj.requestId);
                 }
-                if (obj.query != null) {
-                    w.uint32(18);
-                    HistoryQuery.codec().encode(obj.query, w);
+                if (obj.statusCode != null) {
+                    w.uint32(80);
+                    w.uint32(obj.statusCode);
                 }
-                if (obj.response != null) {
-                    w.uint32(26);
-                    HistoryResponse.codec().encode(obj.response, w);
+                if (obj.statusDesc != null) {
+                    w.uint32(90);
+                    w.string(obj.statusDesc);
+                }
+                if (obj.messages != null) {
+                    for (const value of obj.messages) {
+                        w.uint32(162);
+                        WakuMessageKeyValue.codec().encode(value, w);
+                    }
+                }
+                if (obj.paginationCursor != null) {
+                    w.uint32(410);
+                    w.bytes(obj.paginationCursor);
                 }
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
             }, (reader, length, opts = {}) => {
                 const obj = {
-                    requestId: ''
+                    requestId: '',
+                    messages: []
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -3349,16 +3186,25 @@ var HistoryRpc$1;
                             obj.requestId = reader.string();
                             break;
                         }
-                        case 2: {
-                            obj.query = HistoryQuery.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.query
-                            });
+                        case 10: {
+                            obj.statusCode = reader.uint32();
                             break;
                         }
-                        case 3: {
-                            obj.response = HistoryResponse.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.response
-                            });
+                        case 11: {
+                            obj.statusDesc = reader.string();
+                            break;
+                        }
+                        case 20: {
+                            if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) {
+                                throw new MaxLengthError('Decode error - map field "messages" had too many elements');
+                            }
+                            obj.messages.push(WakuMessageKeyValue.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.messages$
+                            }));
+                            break;
+                        }
+                        case 51: {
+                            obj.paginationCursor = reader.bytes();
                             break;
                         }
                         default: {
@@ -3372,13 +3218,13 @@ var HistoryRpc$1;
         }
         return _codec;
     };
-    HistoryRpc.encode = (obj) => {
-        return encodeMessage(obj, HistoryRpc.codec());
+    StoreQueryResponse.encode = (obj) => {
+        return encodeMessage(obj, StoreQueryResponse.codec());
     };
-    HistoryRpc.decode = (buf, opts) => {
-        return decodeMessage(buf, HistoryRpc.codec(), opts);
+    StoreQueryResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, StoreQueryResponse.codec(), opts);
     };
-})(HistoryRpc$1 || (HistoryRpc$1 = {}));
+})(StoreQueryResponse$1 || (StoreQueryResponse$1 = {}));
 var RateLimitProof;
 (function (RateLimitProof) {
     let _codec;
@@ -3698,7 +3544,7 @@ var PeerExchangeResponse;
                     switch (tag >>> 3) {
                         case 1: {
                             if (opts.limits?.peerInfos != null && obj.peerInfos.length === opts.limits.peerInfos) {
-                                throw new CodeError('decode error - map field "peerInfos" had too many elements', 'ERR_MAX_LENGTH');
+                                throw new MaxLengthError('Decode error - map field "peerInfos" had too many elements');
                             }
                             obj.peerInfos.push(PeerInfo.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.peerInfos$
@@ -3821,7 +3667,7 @@ var WakuMetadataRequest;
                         }
                         case 2: {
                             if (opts.limits?.shards != null && obj.shards.length === opts.limits.shards) {
-                                throw new CodeError('decode error - map field "shards" had too many elements', 'ERR_MAX_LENGTH');
+                                throw new MaxLengthError('Decode error - map field "shards" had too many elements');
                             }
                             obj.shards.push(reader.uint32());
                             break;
@@ -3880,7 +3726,7 @@ var WakuMetadataResponse;
                         }
                         case 2: {
                             if (opts.limits?.shards != null && obj.shards.length === opts.limits.shards) {
-                                throw new CodeError('decode error - map field "shards" had too many elements', 'ERR_MAX_LENGTH');
+                                throw new MaxLengthError('Decode error - map field "shards" had too many elements');
                             }
                             obj.shards.push(reader.uint32());
                             break;
@@ -4056,4 +3902,4 @@ var version_0 = /*#__PURE__*/Object.freeze({
     proto: message
 });
 
-export { DecodedMessage as D, Encoder as E, FilterSubscribeRequest as F, HistoryRpc$1 as H, MessagePush as M, PushRpc$1 as P, Version as V, WakuMetadataRequest as W, encode as a, FilterSubscribeResponse$1 as b, PushResponse as c, decode as d, encodingLength as e, PagingInfo as f, HistoryResponse as g, createEncoder as h, WakuMetadataResponse as i, createDecoder as j, Decoder as k, message as m, version_0 as v };
+export { DecodedMessage as D, Encoder as E, FilterSubscribeRequest as F, MessagePush as M, PushRpc$1 as P, StoreQueryRequest$1 as S, Version as V, WakuMetadataRequest as W, encode as a, FilterSubscribeResponse$1 as b, PushResponse as c, decode as d, encodingLength as e, StoreQueryResponse$1 as f, createEncoder as g, WakuMetadataResponse as h, createDecoder as i, Decoder as j, message as m, version_0 as v };