@versori/run 0.0.1-alpha.9 → 0.1.0-alpha.10

package/esm/deps/jsr.io/@nats-io/jetstream/3.0.2/src/jsmstream_api.js

@@ -0,0 +1,578 @@
+/*
+ * Copyright 2021-2025 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.
+ */
+import { createInbox, Empty, errors, Feature, headers, InvalidArgumentError, MsgHdrsImpl, nanos, nuid, TD, } from "../../../nats-core/3.0.2/src/internal_mod.js";
+import { BaseApiClientImpl } from "./jsbaseclient_api.js";
+import { ListerImpl } from "./jslister.js";
+import { minValidation, validateStreamName } from "./jsutil.js";
+import { isBoundPushConsumerOptions, isOrderedPushConsumerOptions, } from "./types.js";
+import { AckPolicy, DeliverPolicy } from "./jsapi_types.js";
+import { PullConsumerImpl } from "./consumer.js";
+import { ConsumerAPIImpl } from "./jsmconsumer_api.js";
+import { PushConsumerImpl } from "./pushconsumer.js";
+import { JetStreamApiCodes, JetStreamApiError } from "./jserrors.js";
+export function convertStreamSourceDomain(s) {
+    if (s === undefined) {
+        return undefined;
+    }
+    const { domain } = s;
+    if (domain === undefined) {
+        return s;
+    }
+    const copy = Object.assign({}, s);
+    delete copy.domain;
+    if (domain === "") {
+        return copy;
+    }
+    if (copy.external) {
+        throw InvalidArgumentError.format(["domain", "external"], "are mutually exclusive");
+    }
+    copy.external = { api: `$JS.${domain}.API` };
+    return copy;
+}
+export class ConsumersImpl {
+    constructor(api) {
+        Object.defineProperty(this, "api", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "notified", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.api = api;
+        this.notified = false;
+    }
+    checkVersion() {
+        const fv = this.api.nc.features.get(Feature.JS_SIMPLIFICATION);
+        if (!fv.ok) {
+            return Promise.reject(new Error(`consumers framework is only supported on servers ${fv.min} or better`));
+        }
+        return Promise.resolve();
+    }
+    async getPushConsumer(stream, name) {
+        await this.checkVersion();
+        minValidation("stream", stream);
+        if (typeof name === "string") {
+            minValidation("name", name);
+            const ci = await this.api.info(stream, name);
+            if (typeof ci.config.deliver_subject !== "string") {
+                return Promise.reject(new Error("not a push consumer"));
+            }
+            return new PushConsumerImpl(this.api, ci);
+        }
+        else if (name === undefined) {
+            return this.getOrderedPushConsumer(stream);
+        }
+        else if (isOrderedPushConsumerOptions(name)) {
+            const opts = name;
+            return this.getOrderedPushConsumer(stream, opts);
+        }
+        return Promise.reject(new Error("unsupported push consumer type"));
+    }
+    async getOrderedPushConsumer(stream, opts = {}) {
+        opts = Object.assign({}, opts);
+        let { name_prefix, deliver_prefix, filter_subjects } = opts;
+        delete opts.deliver_prefix;
+        delete opts.name_prefix;
+        delete opts.filter_subjects;
+        if (typeof opts.opt_start_seq === "number") {
+            opts.deliver_policy = DeliverPolicy.StartSequence;
+        }
+        if (typeof opts.opt_start_time === "string") {
+            opts.deliver_policy = DeliverPolicy.StartTime;
+        }
+        name_prefix = name_prefix || `oc_${nuid.next()}`;
+        minValidation("name_prefix", name_prefix);
+        deliver_prefix = deliver_prefix ||
+            createInbox(this.api.nc.options.inboxPrefix);
+        minValidation("deliver_prefix", name_prefix);
+        const cc = Object.assign({}, opts);
+        cc.ack_policy = AckPolicy.None;
+        cc.inactive_threshold = nanos(5 * 60 * 1000);
+        cc.num_replicas = 1;
+        cc.max_deliver = 1;
+        cc.flow_control = true;
+        cc.idle_heartbeat = nanos(30_000);
+        if (Array.isArray(filter_subjects)) {
+            cc.filter_subjects = filter_subjects;
+        }
+        if (typeof filter_subjects === "string") {
+            cc.filter_subject = filter_subjects;
+        }
+        if (typeof cc.filter_subjects === "undefined" &&
+            typeof cc.filter_subject === "undefined") {
+            cc.filter_subject = ">";
+        }
+        cc.name = `${name_prefix}_1`;
+        cc.deliver_subject = `${deliver_prefix}.1`;
+        const ci = await this.api.add(stream, cc);
+        const iopts = {
+            name_prefix,
+            deliver_prefix,
+            ordered: true,
+        };
+        return new PushConsumerImpl(this.api, ci, iopts);
+    }
+    getBoundPushConsumer(opts) {
+        if (isBoundPushConsumerOptions(opts)) {
+            const ci = { config: opts };
+            return Promise.resolve(new PushConsumerImpl(this.api, ci, { bound: true }));
+        }
+        else {
+            return Promise.reject(errors.InvalidArgumentError.format("deliver_subject", "is required"));
+        }
+    }
+    async get(stream, name) {
+        await this.checkVersion();
+        if (typeof name === "string") {
+            const ci = await this.api.info(stream, name);
+            if (typeof ci.config.deliver_subject === "string") {
+                return Promise.reject(new Error("not a pull consumer"));
+            }
+            else {
+                return new PullConsumerImpl(this.api, ci);
+            }
+        }
+        else {
+            return this.ordered(stream, name);
+        }
+    }
+    getConsumerFromInfo(ci) {
+        if (typeof ci.config.deliver_subject === "string") {
+            throw new Error("not a pull consumer");
+        }
+        return new PullConsumerImpl(this.api, ci);
+    }
+    async ordered(stream, opts = {}) {
+        await this.checkVersion();
+        const impl = this.api;
+        const sapi = new StreamAPIImpl(impl.nc, impl.opts);
+        await sapi.info(stream);
+        if (typeof opts.name_prefix === "string") {
+            minValidation("name_prefix", opts.name_prefix);
+        }
+        opts.name_prefix = opts.name_prefix || nuid.next();
+        const name = `${opts.name_prefix}_1`;
+        const config = {
+            name,
+            deliver_policy: DeliverPolicy.StartSequence,
+            opt_start_seq: opts.opt_start_seq || 1,
+            ack_policy: AckPolicy.None,
+            inactive_threshold: nanos(5 * 60 * 1000),
+            num_replicas: 1,
+            max_deliver: 1,
+            mem_storage: true,
+        };
+        if (opts.headers_only === true) {
+            config.headers_only = true;
+        }
+        if (Array.isArray(opts.filter_subjects)) {
+            config.filter_subjects = opts.filter_subjects;
+        }
+        if (typeof opts.filter_subjects === "string") {
+            config.filter_subject = opts.filter_subjects;
+        }
+        if (opts.replay_policy) {
+            config.replay_policy = opts.replay_policy;
+        }
+        config.deliver_policy = opts.deliver_policy ||
+            DeliverPolicy.StartSequence;
+        if (opts.deliver_policy === DeliverPolicy.All ||
+            opts.deliver_policy === DeliverPolicy.LastPerSubject ||
+            opts.deliver_policy === DeliverPolicy.New ||
+            opts.deliver_policy === DeliverPolicy.Last) {
+            delete config.opt_start_seq;
+            config.deliver_policy = opts.deliver_policy;
+        }
+        // this requires a filter subject - we only set if they didn't
+        // set anything, and to be pre-2.10 we set it as filter_subject
+        if (config.deliver_policy === DeliverPolicy.LastPerSubject) {
+            if (typeof config.filter_subjects === "undefined" &&
+                typeof config.filter_subject === "undefined") {
+                config.filter_subject = ">";
+            }
+        }
+        if (opts.opt_start_time) {
+            delete config.opt_start_seq;
+            config.deliver_policy = DeliverPolicy.StartTime;
+            config.opt_start_time = opts.opt_start_time;
+        }
+        if (opts.inactive_threshold) {
+            config.inactive_threshold = nanos(opts.inactive_threshold);
+        }
+        const ci = await this.api.add(stream, config);
+        return Promise.resolve(new PullConsumerImpl(this.api, ci, opts));
+    }
+}
+export class StreamImpl {
+    constructor(api, info) {
+        Object.defineProperty(this, "api", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_info", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.api = api;
+        this._info = info;
+    }
+    get name() {
+        return this._info.config.name;
+    }
+    alternates() {
+        return this.info()
+            .then((si) => {
+            return si.alternates ? si.alternates : [];
+        });
+    }
+    async best() {
+        await this.info();
+        if (this._info.alternates) {
+            const asi = await this.api.info(this._info.alternates[0].name);
+            return new StreamImpl(this.api, asi);
+        }
+        else {
+            return this;
+        }
+    }
+    info(cached = false, opts) {
+        if (cached) {
+            return Promise.resolve(this._info);
+        }
+        return this.api.info(this.name, opts)
+            .then((si) => {
+            this._info = si;
+            return this._info;
+        });
+    }
+    getConsumer(name) {
+        return new ConsumersImpl(new ConsumerAPIImpl(this.api.nc, this.api.opts))
+            .get(this.name, name);
+    }
+    getPushConsumer(name) {
+        return new ConsumersImpl(new ConsumerAPIImpl(this.api.nc, this.api.opts))
+            .getPushConsumer(this.name, name);
+    }
+    getMessage(query) {
+        return this.api.getMessage(this.name, query);
+    }
+    deleteMessage(seq, erase) {
+        return this.api.deleteMessage(this.name, seq, erase);
+    }
+}
+export class StreamAPIImpl extends BaseApiClientImpl {
+    constructor(nc, opts) {
+        super(nc, opts);
+    }
+    checkStreamConfigVersions(cfg) {
+        const nci = this.nc;
+        if (cfg.metadata) {
+            const { min, ok } = nci.features.get(Feature.JS_STREAM_CONSUMER_METADATA);
+            if (!ok) {
+                throw new Error(`stream 'metadata' requires server ${min}`);
+            }
+        }
+        if (cfg.first_seq) {
+            const { min, ok } = nci.features.get(Feature.JS_STREAM_FIRST_SEQ);
+            if (!ok) {
+                throw new Error(`stream 'first_seq' requires server ${min}`);
+            }
+        }
+        if (cfg.subject_transform) {
+            const { min, ok } = nci.features.get(Feature.JS_STREAM_SUBJECT_TRANSFORM);
+            if (!ok) {
+                throw new Error(`stream 'subject_transform' requires server ${min}`);
+            }
+        }
+        if (cfg.compression) {
+            const { min, ok } = nci.features.get(Feature.JS_STREAM_COMPRESSION);
+            if (!ok) {
+                throw new Error(`stream 'compression' requires server ${min}`);
+            }
+        }
+        if (cfg.consumer_limits) {
+            const { min, ok } = nci.features.get(Feature.JS_DEFAULT_CONSUMER_LIMITS);
+            if (!ok) {
+                throw new Error(`stream 'consumer_limits' requires server ${min}`);
+            }
+        }
+        function validateStreamSource(context, src) {
+            const count = src?.subject_transforms?.length || 0;
+            if (count > 0) {
+                const { min, ok } = nci.features.get(Feature.JS_STREAM_SOURCE_SUBJECT_TRANSFORM);
+                if (!ok) {
+                    throw new Error(`${context} 'subject_transforms' requires server ${min}`);
+                }
+            }
+        }
+        if (cfg.sources) {
+            cfg.sources.forEach((src) => {
+                validateStreamSource("stream sources", src);
+            });
+        }
+        if (cfg.mirror) {
+            validateStreamSource("stream mirror", cfg.mirror);
+        }
+    }
+    async add(cfg) {
+        this.checkStreamConfigVersions(cfg);
+        validateStreamName(cfg.name);
+        cfg.mirror = convertStreamSourceDomain(cfg.mirror);
+        //@ts-ignore: the sources are either set or not - so no item should be undefined in the list
+        cfg.sources = cfg.sources?.map(convertStreamSourceDomain);
+        const r = await this._request(`${this.prefix}.STREAM.CREATE.${cfg.name}`, cfg);
+        const si = r;
+        this._fixInfo(si);
+        return si;
+    }
+    async delete(stream) {
+        validateStreamName(stream);
+        const r = await this._request(`${this.prefix}.STREAM.DELETE.${stream}`);
+        const cr = r;
+        return cr.success;
+    }
+    async update(name, cfg = {}) {
+        if (typeof name === "object") {
+            const sc = name;
+            name = sc.name;
+            cfg = sc;
+            console.trace(`\u001B[33m >> streams.update(config: StreamConfig) api changed to streams.update(name: string, config: StreamUpdateConfig) - this shim will be removed - update your code.  \u001B[0m`);
+        }
+        this.checkStreamConfigVersions(cfg);
+        validateStreamName(name);
+        const old = await this.info(name);
+        const update = Object.assign(old.config, cfg);
+        update.mirror = convertStreamSourceDomain(update.mirror);
+        //@ts-ignore: the sources are either set or not - so no item should be undefined in the list
+        update.sources = update.sources?.map(convertStreamSourceDomain);
+        const r = await this._request(`${this.prefix}.STREAM.UPDATE.${name}`, update);
+        const si = r;
+        this._fixInfo(si);
+        return si;
+    }
+    async info(name, data) {
+        validateStreamName(name);
+        const subj = `${this.prefix}.STREAM.INFO.${name}`;
+        const r = await this._request(subj, data);
+        let si = r;
+        let { total, limit } = si;
+        // check how many subjects we got in the first request
+        let have = si.state.subjects
+            ? Object.getOwnPropertyNames(si.state.subjects).length
+            : 1;
+        // if the response is paged, we have a large list of subjects
+        // handle the paging and return a StreamInfo with all of it
+        if (total && total > have) {
+            const infos = [si];
+            const paged = data || {};
+            let i = 0;
+            // total could change, so it is possible to have collected
+            // more that the total
+            while (total > have) {
+                i++;
+                paged.offset = limit * i;
+                const r = await this._request(subj, paged);
+                // update it in case it changed
+                total = r.total;
+                infos.push(r);
+                const count = Object.getOwnPropertyNames(r.state.subjects).length;
+                have += count;
+                // if request returns less than limit it is done
+                if (count < limit) {
+                    // done
+                    break;
+                }
+            }
+            // collect all the subjects
+            let subjects = {};
+            for (let i = 0; i < infos.length; i++) {
+                si = infos[i];
+                if (si.state.subjects) {
+                    subjects = Object.assign(subjects, si.state.subjects);
+                }
+            }
+            // don't give the impression we paged
+            si.offset = 0;
+            si.total = 0;
+            si.limit = 0;
+            si.state.subjects = subjects;
+        }
+        this._fixInfo(si);
+        return si;
+    }
+    list(subject = "") {
+        const payload = subject?.length ? { subject } : {};
+        const listerFilter = (v) => {
+            const slr = v;
+            slr.streams.forEach((si) => {
+                this._fixInfo(si);
+            });
+            return slr.streams;
+        };
+        const subj = `${this.prefix}.STREAM.LIST`;
+        return new ListerImpl(subj, listerFilter, this, payload);
+    }
+    // FIXME: init of sealed, deny_delete, deny_purge shouldn't be necessary
+    //  https://github.com/nats-io/nats-server/issues/2633
+    _fixInfo(si) {
+        si.config.sealed = si.config.sealed || false;
+        si.config.deny_delete = si.config.deny_delete || false;
+        si.config.deny_purge = si.config.deny_purge || false;
+        si.config.allow_rollup_hdrs = si.config.allow_rollup_hdrs || false;
+    }
+    async purge(name, opts) {
+        if (opts) {
+            const { keep, seq } = opts;
+            if (typeof keep === "number" && typeof seq === "number") {
+                throw InvalidArgumentError.format(["keep", "seq"], "are mutually exclusive");
+            }
+        }
+        validateStreamName(name);
+        const v = await this._request(`${this.prefix}.STREAM.PURGE.${name}`, opts);
+        return v;
+    }
+    async deleteMessage(stream, seq, erase = true) {
+        validateStreamName(stream);
+        const dr = { seq };
+        if (!erase) {
+            dr.no_erase = true;
+        }
+        const r = await this._request(`${this.prefix}.STREAM.MSG.DELETE.${stream}`, dr);
+        const cr = r;
+        return cr.success;
+    }
+    async getMessage(stream, query) {
+        validateStreamName(stream);
+        try {
+            const r = await this._request(`${this.prefix}.STREAM.MSG.GET.${stream}`, query);
+            const sm = r;
+            return new StoredMsgImpl(sm);
+        }
+        catch (err) {
+            if (err instanceof JetStreamApiError &&
+                err.code === JetStreamApiCodes.NoMessageFound) {
+                return null;
+            }
+            return Promise.reject(err);
+        }
+    }
+    find(subject) {
+        return this.findStream(subject);
+    }
+    names(subject = "") {
+        const payload = subject?.length ? { subject } : {};
+        const listerFilter = (v) => {
+            const sr = v;
+            return sr.streams;
+        };
+        const subj = `${this.prefix}.STREAM.NAMES`;
+        return new ListerImpl(subj, listerFilter, this, payload);
+    }
+    async get(name) {
+        const si = await this.info(name);
+        return Promise.resolve(new StreamImpl(this, si));
+    }
+}
+export class StoredMsgImpl {
+    constructor(smr) {
+        Object.defineProperty(this, "_header", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "smr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.smr = smr;
+    }
+    get pending() {
+        return 0;
+    }
+    get lastSequence() {
+        return 0;
+    }
+    get subject() {
+        return this.smr.message.subject;
+    }
+    get seq() {
+        return this.smr.message.seq;
+    }
+    get timestamp() {
+        return this.smr.message.time;
+    }
+    get time() {
+        return new Date(Date.parse(this.timestamp));
+    }
+    get data() {
+        return this.smr.message.data ? this._parse(this.smr.message.data) : Empty;
+    }
+    get header() {
+        if (!this._header) {
+            if (this.smr.message.hdrs) {
+                const hd = this._parse(this.smr.message.hdrs);
+                this._header = MsgHdrsImpl.decode(hd);
+            }
+            else {
+                this._header = headers();
+            }
+        }
+        return this._header;
+    }
+    _parse(s) {
+        const bs = atob(s);
+        const len = bs.length;
+        const bytes = new Uint8Array(len);
+        for (let i = 0; i < len; i++) {
+            bytes[i] = bs.charCodeAt(i);
+        }
+        return bytes;
+    }
+    json(reviver) {
+        return JSON.parse(new TextDecoder().decode(this.data), reviver);
+    }
+    string() {
+        return TD.decode(this.data);
+    }
+}
+export class StreamsImpl {
+    constructor(api) {
+        Object.defineProperty(this, "api", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.api = api;
+    }
+    get(stream) {
+        return this.api.info(stream)
+            .then((si) => {
+            return new StreamImpl(this.api, si);
+        });
+    }
+}

package/esm/deps/jsr.io/@nats-io/jetstream/3.0.2/src/jsutil.d.ts

@@ -0,0 +1,6 @@
+export declare function validateDurableName(name?: string): string;
+export declare function validateStreamName(name?: string): string;
+export declare function minValidation(context: string, name?: string): string;
+export declare function validateName(context: string, name?: string): void;
+export declare function validName(name?: string): string;
+//# sourceMappingURL=jsutil.d.ts.map

package/esm/deps/jsr.io/@nats-io/jetstream/3.0.2/src/jsutil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsutil.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/jetstream/3.0.2/src/jsutil.ts"],"names":[],"mappings":"AAiBA,wBAAgB,mBAAmB,CAAC,IAAI,CAAC,EAAE,MAAM,UAEhD;AAED,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM,UAE/C;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,SAAK,UA4BvD;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,SAAK,QAQtD;AAED,wBAAgB,SAAS,CAAC,IAAI,SAAK,GAAG,MAAM,CAe3C"}

package/esm/deps/jsr.io/@nats-io/jetstream/3.0.2/src/jsutil.js

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2021-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.
+ */
+import { InvalidNameError } from "./jserrors.js";
+export function validateDurableName(name) {
+    return minValidation("durable", name);
+}
+export function validateStreamName(name) {
+    return minValidation("stream", name);
+}
+export function minValidation(context, name = "") {
+    // minimum validation on streams/consumers matches nats cli
+    if (name === "") {
+        throw Error(`${context} name required`);
+    }
+    const bad = [".", "*", ">", "/", "\\", " ", "\t", "\n", "\r"];
+    bad.forEach((v) => {
+        if (name.indexOf(v) !== -1) {
+            // make the error have a meaningful character
+            switch (v) {
+                case "\n":
+                    v = "\\n";
+                    break;
+                case "\r":
+                    v = "\\r";
+                    break;
+                case "\t":
+                    v = "\\t";
+                    break;
+                default:
+                // nothing
+            }
+            throw new InvalidNameError(`${context} name ('${name}') cannot contain '${v}'`);
+        }
+    });
+    return "";
+}
+export function validateName(context, name = "") {
+    if (name === "") {
+        throw Error(`${context} name required`);
+    }
+    const m = validName(name);
+    if (m.length) {
+        throw new Error(`invalid ${context} name - ${context} name ${m}`);
+    }
+}
+export function validName(name = "") {
+    if (name === "") {
+        throw Error(`name required`);
+    }
+    const RE = /^[-\w]+$/g;
+    const m = name.match(RE);
+    if (m === null) {
+        for (const c of name.split("")) {
+            const mm = c.match(RE);
+            if (mm === null) {
+                return `cannot contain '${c}'`;
+            }
+        }
+    }
+    return "";
+}

package/esm/deps/jsr.io/@nats-io/jetstream/3.0.2/src/mod.d.ts

@@ -0,0 +1,4 @@
+export { jetstream, jetstreamManager } from "./internal_mod.js";
+export { AckPolicy, AdvisoryKind, DeliverPolicy, DirectMsgHeaders, DiscardPolicy, isPullConsumer, isPushConsumer, JetStreamApiCodes, JetStreamApiError, JetStreamError, JsHeaders, ReplayPolicy, RepublishHeaders, RetentionPolicy, StorageType, StoreCompression, } from "./internal_mod.js";
+export type { AbortOnMissingResource, AccountLimits, Advisory, ApiError, ApiPaged, ApiPagedRequest, Bind, BoundPushConsumerOptions, Close, Closed, ClusterInfo, ConsumeBytes, ConsumeCallback, ConsumeMessages, ConsumeOptions, Consumer, ConsumerAPI, ConsumerCallbackFn, ConsumerConfig, ConsumerDeleted, ConsumerInfo, ConsumerKind, ConsumerMessages, ConsumerNotFound, ConsumerNotification, Consumers, ConsumerUpdateConfig, Debug, DeleteableConsumer, DeliveryInfo, Destroyable, Discard, ExceededLimits, Expires, ExportedConsumer, ExternalStream, FetchBytes, FetchMessages, FetchOptions, FlowControl, Heartbeat, HeartbeatsMissed, IdleHeartbeat, InfoableConsumer, JetStreamAccountStats, JetStreamApiStats, JetStreamClient, JetStreamManager, JetStreamManagerOptions, JetStreamOptions, JetStreamPublishOptions, JetStreamUsage, JetStreamUsageAccountLimits, JsMsg, LastForMsgRequest, Lister, LostStreamData, MaxBytes, MaxMessages, MsgDeleteRequest, MsgRequest, Next, NextOptions, NoResponders, OrderedConsumerOptions, OrderedConsumerRecreated, OrderedPushConsumerOptions, OverflowMinAckPending, OverflowMinPending, OverflowMinPendingAndMinAck, OverflowOptions, PeerInfo, Placement, PriorityGroups, PriorityPolicy, PubAck, PullOptions, PurgeBySeq, PurgeBySubject, PurgeOpts, PurgeResponse, PurgeTrimOpts, PushConsumer, PushConsumerOptions, Republish, Reset, SeqMsgRequest, SequenceInfo, StoredMsg, Stream, StreamAlternate, StreamAPI, StreamConfig, StreamConsumerLimits, StreamInfo, StreamInfoRequestOptions, StreamNames, StreamNotFound, Streams, StreamSource, StreamSourceInfo, StreamState, StreamUpdateConfig, SubjectTransformConfig, Success, ThresholdBytes, ThresholdMessages, } from "./internal_mod.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@nats-io/jetstream/3.0.2/src/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/jetstream/3.0.2/src/mod.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EACL,SAAS,EACT,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,sBAAsB,EACtB,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,IAAI,EACJ,wBAAwB,EACxB,KAAK,EACL,MAAM,EACN,WAAW,EACX,YAAY,EACZ,eAAe,EACf,eAAe,EACf,cAAc,EACd,QAAQ,EACR,WAAW,EACX,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,SAAS,EACT,oBAAoB,EACpB,KAAK,EACL,kBAAkB,EAClB,YAAY,EACZ,WAAW,EACX,OAAO,EACP,cAAc,EACd,OAAO,EACP,gBAAgB,EAChB,cAAc,EACd,UAAU,EACV,aAAa,EACb,YAAY,EACZ,WAAW,EACX,SAAS,EACT,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,uBAAuB,EACvB,gBAAgB,EAChB,uBAAuB,EACvB,cAAc,EACd,2BAA2B,EAC3B,KAAK,EACL,iBAAiB,EACjB,MAAM,EACN,cAAc,EACd,QAAQ,EACR,WAAW,EACX,gBAAgB,EAChB,UAAU,EACV,IAAI,EACJ,WAAW,EACX,YAAY,EACZ,sBAAsB,EACtB,wBAAwB,EACxB,0BAA0B,EAC1B,qBAAqB,EACrB,kBAAkB,EAClB,2BAA2B,EAC3B,eAAe,EACf,QAAQ,EACR,SAAS,EACT,cAAc,EACd,cAAc,EACd,MAAM,EACN,WAAW,EACX,UAAU,EACV,cAAc,EACd,SAAS,EACT,aAAa,EACb,aAAa,EACb,YAAY,EACZ,mBAAmB,EACnB,SAAS,EACT,KAAK,EACL,aAAa,EACb,YAAY,EACZ,SAAS,EACT,MAAM,EACN,eAAe,EACf,SAAS,EACT,YAAY,EACZ,oBAAoB,EACpB,UAAU,EACV,wBAAwB,EACxB,WAAW,EACX,cAAc,EACd,OAAO,EACP,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,kBAAkB,EAClB,sBAAsB,EACtB,OAAO,EACP,cAAc,EACd,iBAAiB,GAClB,MAAM,mBAAmB,CAAC"}

package/esm/deps/jsr.io/@nats-io/jetstream/3.0.2/src/mod.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2023-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.
+ */
+export { jetstream, jetstreamManager } from "./internal_mod.js";
+export { AckPolicy, AdvisoryKind, DeliverPolicy, DirectMsgHeaders, DiscardPolicy, isPullConsumer, isPushConsumer, JetStreamApiCodes, JetStreamApiError, JetStreamError, JsHeaders, ReplayPolicy, RepublishHeaders, RetentionPolicy, StorageType, StoreCompression, } from "./internal_mod.js";