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

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

@@ -0,0 +1,1119 @@
+import type { Nanos } from "../../../nats-core/3.0.2/src/mod.js";
+import type { MaxBytes, StoredMsg } from "./types.js";
+export type ApiPaged = {
+    total: number;
+    offset: number;
+    limit: number;
+};
+export type ApiPagedRequest = {
+    offset: number;
+};
+export type ApiResponse = {
+    type: string;
+    error?: ApiError;
+};
+export type ApiError = {
+    /**
+     * HTTP like error code in the 300 to 500 range
+     */
+    code: number;
+    /**
+     * A human friendly description of the error
+     */
+    description: string;
+    /**
+     * The NATS error code unique to each kind of error
+     */
+    err_code: number;
+};
+/**
+ * An alternate location to read mirrored data
+ */
+export type StreamAlternate = {
+    /**
+     * The mirror Stream name
+     */
+    name: string;
+    /**
+     * The name of the cluster holding the Stream
+     */
+    cluster: string;
+    /**
+     * The domain holding the Stream
+     */
+    domain: string;
+};
+/**
+ * Stream configuration info
+ */
+export type StreamInfo = ApiPaged & {
+    /**
+     * The active configuration for the Stream
+     */
+    config: StreamConfig;
+    /**
+     * The ISO Timestamp when the stream was created
+     */
+    created: string;
+    /**
+     * Detail about the current State of the Stream
+     */
+    state: StreamState;
+    /**
+     * Cluster information for the stream if applicable
+     */
+    cluster?: ClusterInfo;
+    /**
+     * Information about an upstream stream source in a mirror
+     */
+    mirror?: StreamSourceInfo;
+    /**
+     * Sources for the Stream if applicable
+     */
+    sources?: StreamSourceInfo[];
+    /**
+     * Alternates for a stream if applicable. Alternates are listed
+     * in order of TTL. With streams at the start of the Array potentially
+     * closer and faster to access.
+     */
+    alternates?: StreamAlternate[];
+    /**
+     * The ISO timestamp when the StreamInfo was generated. This field is only available
+     * on servers 2.10.x or better
+     */
+    "ts"?: string;
+};
+export type SubjectTransformConfig = {
+    /**
+     * The source pattern
+     */
+    src?: string;
+    /**
+     * The destination pattern
+     */
+    dest: string;
+};
+/**
+ * Sets default consumer limits for inactive_threshold and max_ack_pending
+ * to consumers of this stream that don't specify specific values.
+ * This functionality requires a server 2.10.x or better.
+ */
+export type StreamConsumerLimits = {
+    /**
+     * The default `inactive_threshold` applied to consumers.
+     * This value is specified in nanoseconds. Please use the `nanos()`
+     * function to convert between millis and nanoseconds. Or `millis()`
+     * to convert a nanosecond value to millis.
+     */
+    "inactive_threshold"?: Nanos;
+    /**
+     * The default `max_ack_pending` applied to consumers of the stream.
+     */
+    "max_ack_pending"?: number;
+};
+export type StreamConfig = StreamUpdateConfig & {
+    /**
+     * A unique name for the Stream
+     */
+    name: string;
+    /**
+     * How messages are retained in the Stream, once this is exceeded old messages are removed.
+     */
+    retention: RetentionPolicy;
+    /**
+     * The storage backend to use for the Stream.
+     */
+    storage: StorageType;
+    /**
+     * How many Consumers can be defined for a given Stream. -1 for unlimited.
+     */
+    "max_consumers": number;
+    /**
+     * Maintains a 1:1 mirror of another stream with name matching this property.
+     * When a mirror is configured subjects and sources must be empty.
+     */
+    mirror?: StreamSource;
+    /**
+     * Sealed streams do not allow messages to be deleted via limits or API,
+     * sealed streams can not be unsealed via configuration update.
+     * Can only be set on already created streams via the Update API
+     */
+    sealed: boolean;
+    /**
+     * Sets the first sequence number used by the stream. This property can only be
+     * specified when creating the stream, and likely is not valid on mirrors etc.,
+     * as it may disrupt the synchronization logic.
+     */
+    "first_seq": number;
+};
+/**
+ * Stream options that can be updated
+ */
+export type StreamUpdateConfig = {
+    /**
+     * A list of subjects to consume, supports wildcards. Must be empty when a mirror is configured. May be empty when sources are configured.
+     */
+    subjects: string[];
+    /**
+     * A short description of the purpose of this stream
+     */
+    description?: string;
+    /**
+     * For wildcard streams ensure that for every unique subject this many messages are kept - a per subject retention limit
+     */
+    "max_msgs_per_subject": number;
+    /**
+     * How many messages may be in a Stream, oldest messages will be removed if the Stream exceeds this size. -1 for unlimited.
+     */
+    "max_msgs": number;
+    /**
+     * Maximum age of any message in the stream, expressed in nanoseconds. 0 for unlimited.
+     */
+    "max_age": Nanos;
+    /**
+     * How big the Stream may be, when the combined stream size exceeds this old messages are removed. -1 for unlimited.
+     */
+    "max_bytes": number;
+    /**
+     * The largest message that will be accepted by the Stream. -1 for unlimited.
+     */
+    "max_msg_size": number;
+    /**
+     * When a Stream reach its limits either old messages are deleted or new ones are denied
+     */
+    discard: DiscardPolicy;
+    /**
+     * Sets the context of the on a per subject basis. Requires {@link DiscardPolicy#New} as the
+     * {@link discard} policy.
+     */
+    discard_new_per_subject: boolean;
+    /**
+     * Disables acknowledging messages that are received by the Stream.
+     */
+    "no_ack"?: boolean;
+    /**
+     * The time window to track duplicate messages for, expressed in nanoseconds. 0 for default
+     * Set {@link JetStreamPublishOptions#msgID} to enable duplicate detection.
+     */
+    "duplicate_window": Nanos;
+    /**
+     * List of Stream names to replicate into this Stream
+     */
+    sources?: StreamSource[];
+    /**
+     * Allows the use of the {@link JsHeaders#RollupHdr} header to replace all contents of a stream,
+     * or subject in a stream, with a single new message
+     */
+    "allow_rollup_hdrs": boolean;
+    /**
+     * How many replicas to keep for each message. Min 1, Max 5. Default 1.
+     */
+    "num_replicas": number;
+    /**
+     * Placement directives to consider when placing replicas of this stream, random placement when unset
+     */
+    placement?: Placement;
+    /**
+     * Restricts the ability to delete messages from a stream via the API.
+     * Cannot be changed once set to true
+     */
+    "deny_delete": boolean;
+    /**
+     * Restricts the ability to purge messages from a stream via the API.
+     * Cannot be change once set to true
+     */
+    "deny_purge": boolean;
+    /**
+     * Allow higher performance, direct access to get individual messages via the $JS.DS.GET API
+     */
+    "allow_direct": boolean;
+    /**
+     * Allow higher performance, direct access to get individual messages via the $JS.DS.GET API
+     */
+    "mirror_direct": boolean;
+    /**
+     * Rules for republishing messages from a stream with subject mapping
+     * onto new subjects for partitioning and more
+     */
+    republish?: Republish;
+    /**
+     * Metadata field to store additional information about the stream. Note that
+     * keys starting with `_nats` are reserved. This feature only supported on servers
+     * 2.10.x and better.
+     */
+    metadata?: Record<string, string>;
+    /**
+     * Apply a subject transform to incoming messages before doing anything else.
+     * This feature only supported on 2.10.x and better.
+     */
+    "subject_transform"?: SubjectTransformConfig;
+    /**
+     * Sets the compression level of the stream. This feature is only supported in
+     * servers 2.10.x and better.
+     */
+    compression?: StoreCompression;
+    /**
+     * The consumer limits applied to consumers that don't specify limits
+     * for `inactive_threshold` or `max_ack_pending`. Note that these limits
+     * become an upper bound for all clients.
+     */
+    "consumer_limits"?: StreamConsumerLimits;
+};
+export type Republish = {
+    /**
+     * The source subject to republish
+     */
+    src: string;
+    /**
+     * The destination to publish to
+     */
+    dest: string;
+    /**
+     * Only send message headers, no bodies
+     */
+    "headers_only"?: boolean;
+};
+export type ExternalStream = {
+    /**
+     * API prefix for the remote stream - the API prefix should be something like
+     * `$JS.domain.API where domain is the JetStream domain on the NATS server configuration.
+     */
+    api: string;
+    /**
+     * Deliver prefix for the remote stream
+     */
+    deliver?: string;
+};
+export type StreamSource = {
+    /**
+     * Name of the stream source
+     */
+    name: string;
+    /**
+     * An optional start sequence from which to start reading messages
+     */
+    "opt_start_seq"?: number;
+    /**
+     * An optional start time Date string
+     */
+    "opt_start_time"?: string;
+    /**
+     * An optional filter subject. If the filter matches the message will be
+     * on-boarded.
+     */
+    "filter_subject"?: string;
+    /**
+     * This value cannot be set if domain is set
+     */
+    external?: ExternalStream;
+    /**
+     * This field is a convenience for setting up an ExternalStream.
+     * If set, the value here is used to calculate the JetStreamAPI prefix.
+     * This field is never serialized to the server. This value cannot be set
+     * if external is set.
+     */
+    domain?: string;
+    /**
+     * Apply a subject transforms to sourced messages before doing anything else.
+     * This feature only supported on 2.10.x and better.
+     */
+    subject_transforms?: SubjectTransformConfig[];
+};
+export type Placement = {
+    /**
+     * The cluster to place the stream on
+     */
+    cluster: string;
+    /**
+     * Tags matching server configuration
+     */
+    tags: string[];
+};
+export declare const RetentionPolicy: {
+    /**
+     * Retain messages until the limits are reached, then trigger the discard policy.
+     */
+    readonly Limits: "limits";
+    /**
+     * Retain messages while there is consumer interest on the particular subject.
+     */
+    readonly Interest: "interest";
+    /**
+     * Retain messages until acknowledged
+     */
+    readonly Workqueue: "workqueue";
+};
+export type RetentionPolicy = typeof RetentionPolicy[keyof typeof RetentionPolicy];
+export declare const DiscardPolicy: {
+    /**
+     * Discard old messages to make room for the new ones
+     */
+    readonly Old: "old";
+    /**
+     * Discard the new messages
+     */
+    readonly New: "new";
+};
+export type DiscardPolicy = typeof DiscardPolicy[keyof typeof DiscardPolicy];
+export declare const StorageType: {
+    /**
+     * Store persistently on files
+     */
+    readonly File: "file";
+    /**
+     * Store in server memory - doesn't survive server restarts
+     */
+    readonly Memory: "memory";
+};
+export type StorageType = typeof StorageType[keyof typeof StorageType];
+export declare const DeliverPolicy: {
+    /**
+     * Deliver all messages
+     */
+    readonly All: "all";
+    /**
+     * Deliver starting with the last message
+     */
+    readonly Last: "last";
+    /**
+     * Deliver starting with new messages
+     */
+    readonly New: "new";
+    /**
+     * Deliver starting with the specified sequence
+     */
+    readonly StartSequence: "by_start_sequence";
+    /**
+     * Deliver starting with the specified time
+     */
+    readonly StartTime: "by_start_time";
+    /**
+     * Deliver starting with the last messages for every subject
+     */
+    readonly LastPerSubject: "last_per_subject";
+};
+export type DeliverPolicy = typeof DeliverPolicy[keyof typeof DeliverPolicy];
+export declare const AckPolicy: {
+    /**
+     * Messages don't need to be Ack'ed.
+     */
+    readonly None: "none";
+    /**
+     * Ack, acknowledges all messages with a lower sequence
+     */
+    readonly All: "all";
+    /**
+     * All sequences must be explicitly acknowledged
+     */
+    readonly Explicit: "explicit";
+    /**
+     * @ignore
+     */
+    readonly NotSet: "";
+};
+export type AckPolicy = typeof AckPolicy[keyof typeof AckPolicy];
+export declare const ReplayPolicy: {
+    /**
+     * Replays messages as fast as possible
+     */
+    readonly Instant: "instant";
+    /**
+     * Replays messages following the original delay between messages
+     */
+    readonly Original: "original";
+};
+export type ReplayPolicy = typeof ReplayPolicy[keyof typeof ReplayPolicy];
+export declare const StoreCompression: {
+    /**
+     * No compression
+     */
+    readonly None: "none";
+    /**
+     * S2 compression
+     */
+    readonly S2: "s2";
+};
+export type StoreCompression = typeof StoreCompression[keyof typeof StoreCompression];
+/**
+ * Options for StreamAPI info requests
+ */
+export type StreamInfoRequestOptions = {
+    /**
+     * Include info on deleted subjects.
+     */
+    "deleted_details": boolean;
+    /**
+     * Only include information matching the specified subject filter
+     */
+    "subjects_filter": string;
+} & ApiPagedRequest;
+export type MsgRequest = SeqMsgRequest | LastForMsgRequest;
+/**
+ * Request the first message matching specified subject found on or after the specified optional sequence.
+ */
+export type NextMsgRequest = {
+    seq?: number;
+    next_by_subj: string;
+};
+/**
+ * Retrieves the last message with the given subject
+ */
+export type LastForMsgRequest = {
+    "last_by_subj": string;
+};
+/**
+ * Stream sequence number of the message to retrieve
+ */
+export type SeqMsgRequest = {
+    seq: number;
+};
+/**
+ * Start time for the message. This is only supported on servers
+ * 2.11.0 and better.
+ */
+export type StartTimeMsgRequest = {
+    start_time: Date | string;
+};
+export type DirectMsgRequest = SeqMsgRequest | LastForMsgRequest | NextMsgRequest | StartTimeMsgRequest;
+export type CompletionResult = {
+    err?: Error;
+};
+export type BatchCallback<T> = (done: CompletionResult | null, d: T) => void;
+export type DirectBatch = {
+    batch: number;
+};
+export type DirectMaxBytes = MaxBytes;
+export type DirectBatchLimits = {
+    batch: number;
+    max_bytes: number;
+    callback: BatchCallback<StoredMsg>;
+    next_by_subj?: string;
+};
+export type DirectBatchStartSeq = Partial<DirectBatchLimits> & {
+    seq: number;
+    start_time: never;
+};
+export type DirectBatchStartTime = Partial<DirectBatchLimits> & {
+    start_time: Date | string;
+    seq: never;
+};
+export type DirectBatchOptions = DirectBatchStartSeq | DirectBatchStartTime;
+export type DirectLastFor = {
+    multi_last: string[];
+    up_to_time?: Date | string;
+    up_to_seq?: number;
+} & Partial<DirectBatchLimits>;
+export type StreamState = {
+    /**
+     * Number of messages stored in the Stream
+     */
+    messages: number;
+    /**
+     * Combined size of all messages in the Stream
+     */
+    bytes: number;
+    /**
+     * Sequence number of the first message in the Stream
+     */
+    "first_seq": number;
+    /**
+     * The ISO timestamp of the first message in the Stream
+     */
+    "first_ts": string;
+    /**
+     * Sequence number of the last message in the Stream
+     */
+    "last_seq": number;
+    /**
+     * The ISO timestamp of the last message in the Stream
+     */
+    "last_ts": string;
+    /**
+     * The number of deleted messages
+     */
+    "num_deleted": number;
+    /**
+     * IDs of messages that were deleted using the Message Delete API or Interest based streams removing messages out of order
+     * {@link StreamInfoRequestOptions | deleted_details} is specified on
+     * the request.
+     */
+    deleted: number[];
+    /**
+     * Messages that were damaged and unrecoverable
+     */
+    lost: LostStreamData;
+    /**
+     * Number of Consumers attached to the Stream
+     */
+    "consumer_count": number;
+    /**
+     * The number of unique subjects held in the stream
+     */
+    num_subjects?: number;
+    /**
+     * Subjects and their message counts when a {@link StreamInfoRequestOptions | subjects_filter} was set
+     */
+    subjects?: Record<string, number>;
+};
+/**
+ * Records messages that were damaged and unrecoverable
+ */
+export type LostStreamData = {
+    /**
+     * The messages that were lost
+     */
+    msgs: number[] | null;
+    /**
+     * The number of bytes that were lost
+     */
+    bytes: number;
+};
+export type ClusterInfo = {
+    /**
+     * The cluster name
+     */
+    name?: string;
+    /**
+     * The server name of the RAFT leader
+     */
+    leader?: string;
+    /**
+     * The members of the RAFT cluster
+     */
+    replicas?: PeerInfo[];
+};
+export type PeerInfo = {
+    /**
+     * The server name of the peer
+     */
+    name: string;
+    /**
+     * Indicates if the server is up-to-date and synchronised
+     */
+    current: boolean;
+    /**
+     * Indicates the node is considered offline by the group
+     */
+    offline: boolean;
+    /**
+     * Nanoseconds since this peer was last seen
+     */
+    active: Nanos;
+    /**
+     * How many uncommitted operations this peer is behind the leader
+     */
+    lag: number;
+};
+/**
+ * Information about an upstream stream source in a mirror
+ */
+export type StreamSourceInfo = {
+    /**
+     * The name of the Stream being replicated
+     */
+    name: string;
+    /**
+     * How many messages behind the mirror operation is
+     */
+    lag: number;
+    /**
+     * When last the mirror had activity, in nanoseconds. Value will be -1 when there has been no activity.
+     */
+    active: Nanos;
+    /**
+     * A possible error
+     */
+    error?: ApiError;
+    /**
+     * Apply a subject transforms to sourced messages before doing anything else.
+     * This feature only supported on 2.10.x and better.
+     */
+    subject_transforms?: SubjectTransformConfig[];
+};
+export type PurgeOpts = PurgeBySeq | PurgeTrimOpts | PurgeBySubject;
+export type PurgeBySeq = {
+    /**
+     * Restrict purging to messages that match this subject
+     */
+    filter?: string;
+    /**
+     * Purge all messages up to but not including the message with this sequence.
+     */
+    seq: number;
+};
+export type PurgeTrimOpts = {
+    /**
+     * Restrict purging to messages that match this subject
+     */
+    filter?: string;
+    /**
+     * Ensures this many messages are present after the purge.
+     */
+    keep: number;
+};
+export type PurgeBySubject = {
+    /**
+     * Restrict purging to messages that match this subject
+     */
+    filter: string;
+};
+export type PurgeResponse = Success & {
+    /**
+     * Number of messages purged from the Stream
+     */
+    purged: number;
+};
+export declare const ConsumerApiAction: {
+    readonly CreateOrUpdate: "";
+    readonly Update: "update";
+    readonly Create: "create";
+};
+export type ConsumerApiAction = typeof ConsumerApiAction[keyof typeof ConsumerApiAction];
+export type CreateConsumerRequest = {
+    "stream_name": string;
+    config: Partial<ConsumerConfig>;
+    action?: ConsumerApiAction;
+};
+export type StreamMsgResponse = ApiResponse & {
+    message: {
+        subject: string;
+        seq: number;
+        data: string;
+        hdrs: string;
+        time: string;
+    };
+};
+export type SequenceInfo = {
+    "consumer_seq": number;
+    "stream_seq": number;
+    "last_active": Nanos;
+};
+export type ConsumerInfo = {
+    /**
+     * The stream hosting the consumer
+     */
+    "stream_name": string;
+    /**
+     * A unique name for the consumer, either machine generated or the durable name
+     */
+    name: string;
+    /**
+     * The ISO timestamp when the Consumer was created
+     */
+    created: string;
+    /**
+     * The consumer configuration
+     */
+    config: ConsumerConfig;
+    /**
+     * The last message delivered from this Consumer
+     */
+    delivered: SequenceInfo;
+    /**
+     * The highest contiguous acknowledged message
+     */
+    "ack_floor": SequenceInfo;
+    /**
+     * The number of messages pending acknowledgement
+     * but yet to acknowledged by the client.
+     */
+    "num_ack_pending": number;
+    /**
+     * The number of redeliveries that have been performed
+     */
+    "num_redelivered": number;
+    /**
+     * The number of pull consumers waiting for messages
+     */
+    "num_waiting": number;
+    /**
+     * The number of messages left unconsumed in this Consumer
+     */
+    "num_pending": number;
+    /**
+     * The cluster where the consumer is defined
+     */
+    cluster?: ClusterInfo;
+    /**
+     * Indicates if any client is connected and receiving messages from a push consumer
+     */
+    "push_bound": boolean;
+    /**
+     * The ISO timestamp when the ConsumerInfo was generated. This field is only available
+     * on servers 2.10.x or better
+     */
+    "ts"?: string;
+    /**
+     * Set to true if the consumer is paused.
+     * This field is only available on servers 2.11.x or better
+     */
+    paused?: boolean;
+    /**
+     * If the consumer was paused with a resume date, this field specifies the amount of time
+     * in nanoseconds remaining until the consumer will be automatically resumed. This field
+     * is only available on servers 2.11.x or better
+     */
+    "pause_remaining": Nanos;
+};
+export type ConsumerListResponse = ApiResponse & ApiPaged & {
+    consumers: ConsumerInfo[];
+};
+export type StreamListResponse = ApiResponse & ApiPaged & {
+    streams: StreamInfo[];
+};
+export type Success = {
+    /**
+     * True if the operation succeeded
+     */
+    success: boolean;
+};
+export type SuccessResponse = ApiResponse & Success;
+export type MsgDeleteRequest = SeqMsgRequest & {
+    /**
+     * Default will securely remove a message and rewrite the data with random data,
+     * set this to true to only remove the message
+     */
+    "no_erase"?: boolean;
+};
+export type AccountLimits = {
+    /**
+     * The maximum amount of Memory storage Stream Messages may consume
+     */
+    "max_memory": number;
+    /**
+     * The maximum amount of File storage Stream Messages may consume
+     */
+    "max_storage": number;
+    /**
+     * The maximum number of Streams an account can create
+     */
+    "max_streams": number;
+    /**
+     * The maximum number of Consumer an account can create
+     */
+    "max_consumers": number;
+    /**
+     * The maximum number of outstanding ACKs any consumer may configure
+     */
+    "max_ack_pending": number;
+    /**
+     * The maximum size any single memory stream may be
+     */
+    "memory_max_stream_bytes": number;
+    /**
+     * The maximum size any single storage based stream may be
+     */
+    "storage_max_stream_bytes": number;
+    /**
+     * Indicates if Streams created in this account requires the max_bytes property set
+     */
+    "max_bytes_required": number;
+};
+export type JetStreamUsage = {
+    /**
+     * Memory Storage being used for Stream Message storage
+     */
+    memory: number;
+    /**
+     * File Storage being used for Stream Message storage
+     */
+    storage: number;
+    /**
+     * Number of active Streams
+     */
+    streams: number;
+    /**
+     * "Number of active Consumers
+     */
+    consumers: number;
+};
+export type JetStreamUsageAccountLimits = JetStreamUsage & {
+    limits: AccountLimits;
+};
+export type JetStreamAccountStats = JetStreamUsageAccountLimits & {
+    api: JetStreamApiStats;
+    domain?: string;
+    tiers?: {
+        R1?: JetStreamUsageAccountLimits;
+        R3?: JetStreamUsageAccountLimits;
+    };
+};
+export type JetStreamApiStats = {
+    /**
+     * Total number of API requests received for this account
+     */
+    total: number;
+    /**
+     * "API requests that resulted in an error response"
+     */
+    errors: number;
+};
+export type AccountInfoResponse = ApiResponse & JetStreamAccountStats;
+export type PriorityGroups = {
+    priority_groups?: string[];
+    priority_policy?: PriorityPolicy;
+};
+export type ConsumerConfig = ConsumerUpdateConfig & {
+    /**
+     * The type of acknowledgment required by the Consumer
+     */
+    "ack_policy": AckPolicy;
+    /**
+     * Where to start consuming messages on the stream
+     */
+    "deliver_policy": DeliverPolicy;
+    /**
+     * Allows push consumers to form a queue group
+     */
+    "deliver_group"?: string;
+    /**
+     * A unique name for a durable consumer
+     * Set {@link name} - for ephemeral consumers, also set {@link idle_heartbeat}
+     */
+    "durable_name"?: string;
+    /**
+     * The consumer name
+     */
+    name?: string;
+    /**
+     * For push consumers this will regularly send an empty mess with Status header 100
+     * and a reply subject, consumers must reply to these messages to control
+     * the rate of message delivery.
+     */
+    "flow_control"?: boolean;
+    /**
+     * If the Consumer is idle for more than this many nanoseconds an empty message with
+     * Status header 100 will be sent indicating the consumer is still alive
+     */
+    "idle_heartbeat"?: Nanos;
+    /**
+     * The sequence from which to start delivery messages.
+     * Requires {@link DeliverPolicy#StartSequence}
+     */
+    "opt_start_seq"?: number;
+    /**
+     * The date time from which to start delivering messages
+     * Requires {@link DeliverPolicy#StartTime}
+     */
+    "opt_start_time"?: string;
+    /**
+     * The rate at which messages will be delivered to clients, expressed in bytes per second
+     */
+    "rate_limit_bps"?: number;
+    /**
+     * How messages are played back to the Consumer
+     */
+    "replay_policy": ReplayPolicy;
+    /**
+     * Creates a consumer that is initially paused, but will resume at the specified Date and time.
+     * Specified as an ISO date time string (Date#toISOString()).
+     */
+    "pause_until"?: string;
+};
+export type ConsumerUpdateConfig = PriorityGroups & {
+    /**
+     * A short description of the purpose of this consume
+     */
+    description?: string;
+    /**
+     * How long (in nanoseconds) to allow messages to remain un-acknowledged before attempting redelivery
+     */
+    "ack_wait"?: Nanos;
+    /**
+     * The maximum number of times a message will be delivered to consumers if not acknowledged in time.
+     * Default is -1 (will redeliver until acknowledged).
+     */
+    "max_deliver"?: number;
+    /**
+     * @ignore
+     */
+    "sample_freq"?: string;
+    /**
+     * The maximum number of messages without acknowledgement that can be outstanding,
+     * once this limit is reached message delivery will be suspended
+     */
+    "max_ack_pending"?: number;
+    /**
+     * The number of pulls that can be outstanding on a pull consumer,
+     * pulls received after this is reached are ignored
+     */
+    "max_waiting"?: number;
+    /**
+     * Delivers only the headers of messages in the stream and not the bodies. Additionally,
+     * adds Nats-Msg-Size {@link JsHeaders#MessageSizeHdr} header to indicate the size of
+     * the removed payload
+     */
+    "headers_only"?: boolean;
+    /**
+     * The subject where the push consumer should be sent the messages
+     */
+    "deliver_subject"?: string;
+    /**
+     * The largest batch property that may be specified when doing a pull on a Pull Consumer
+     */
+    "max_batch"?: number;
+    /**
+     * The maximum expires value that may be set when doing a pull on a Pull Consumer expressed in nanoseconds.
+     */
+    "max_expires"?: Nanos;
+    /**
+     * Duration that instructs the server to clean up ephemeral consumers that are inactive for the specified
+     * time in nanoseconds
+     */
+    "inactive_threshold"?: Nanos;
+    /**
+     * List of durations in nanoseconds that represents a retry timescale for
+     * the redelivery of messages
+     */
+    "backoff"?: Nanos[];
+    /**
+     * The maximum bytes value that maybe set when dong a pull on a Pull Consumer
+     */
+    "max_bytes"?: number;
+    /**
+     * When set do not inherit the replica count from the stream but specifically set it to this amount.
+     */
+    "num_replicas"?: number;
+    /**
+     * Force the consumer state to be kept in memory rather than inherit the setting from the stream
+     */
+    "mem_storage"?: boolean;
+    /**
+     * Deliver only messages that match the subject filter
+     * This is exclusive of {@link filter_subjects}
+     */
+    "filter_subject"?: string;
+    /**
+     * Deliver only messages that match the specified filters.
+     * This is exclusive of {@link filter_subject}.
+     */
+    "filter_subjects"?: string[];
+    /**
+     * Metadata field to store additional information about the consumer. Note that
+     * keys starting with `_nats` are reserved. This feature only supported on servers
+     * 2.10.x and better.
+     */
+    metadata?: Record<string, string>;
+};
+export declare const PriorityPolicy: {
+    readonly None: "none";
+    readonly Overflow: "overflow";
+};
+export type PriorityPolicy = typeof PriorityPolicy[keyof typeof PriorityPolicy];
+export declare function defaultConsumer(name: string, opts?: Partial<ConsumerConfig>): ConsumerConfig;
+export type OverflowMinPending = {
+    /**
+     * The name of the priority_group
+     */
+    group: string;
+    /**
+     * Only deliver messages when num_pending for the consumer is greater than this value
+     */
+    min_pending: number;
+};
+export type OverflowMinAckPending = {
+    /**
+     * The name of the priority_group
+     */
+    group: string;
+    /**
+     * Only deliver messages when num_ack_pending for the consumer is greater than this value
+     */
+    min_ack_pending: number;
+};
+export type OverflowMinPendingAndMinAck = {
+    /**
+     * The name of the priority_group
+     */
+    group: string;
+    /**
+     * Only deliver messages when num_pending for the consumer is greater than this value
+     */
+    min_pending: number;
+    /**
+     * Only deliver messages when num_ack_pending for the consumer is greater than this value
+     */
+    min_ack_pending: number;
+};
+export type OverflowOptions = OverflowMinPending | OverflowMinAckPending | OverflowMinPendingAndMinAck;
+/**
+ * Options for a JetStream pull subscription which define how long
+ * the pull request will remain open and limits the amount of data
+ * that the server could return.
+ */
+export type PullOptions = Partial<OverflowMinPendingAndMinAck> & {
+    /**
+     * Max number of messages to retrieve in a pull.
+     */
+    batch: number;
+    /**
+     * If true, the request for messages will end when received by the server
+     */
+    "no_wait": boolean;
+    /**
+     * If set, the number of milliseconds to wait for the number of messages
+     * specified in {@link batch}
+     */
+    expires: number;
+    /**
+     * If set, the max number of bytes to receive. The server will limit the
+     * number of messages in the batch to fit within this setting.
+     */
+    "max_bytes": number;
+    /**
+     * Number of nanos between messages for the server to emit an idle_heartbeat
+     */
+    "idle_heartbeat": number;
+};
+export type DeliveryInfo = {
+    /**
+     * JetStream domain of the message if applicable.
+     */
+    domain: string;
+    /**
+     * The hash of the sending account if applicable.
+     */
+    "account_hash"?: string;
+    /**
+     * The stream where the message came from
+     */
+    stream: string;
+    /**
+     * The intended consumer for the message.
+     */
+    consumer: string;
+    /**
+     * The number of times the message has been delivered.
+     */
+    deliveryCount: number;
+    /**
+     * The sequence number of the message in the stream
+     */
+    streamSequence: number;
+    /**
+     * The client delivery sequence for the message
+     */
+    deliverySequence: number;
+    /**
+     * The timestamp for the message in nanoseconds. Convert with `millis(n)`,
+     */
+    timestampNanos: number;
+    /**
+     * The number of pending messages for the consumer at the time the
+     * message was delivered.
+     */
+    pending: number;
+    /**
+     * True if the message has been redelivered.
+     */
+    redelivered: boolean;
+};
+export declare const PubHeaders: {
+    readonly MsgIdHdr: "Nats-Msg-Id";
+    readonly ExpectedStreamHdr: "Nats-Expected-Stream";
+    readonly ExpectedLastSeqHdr: "Nats-Expected-Last-Sequence";
+    readonly ExpectedLastMsgIdHdr: "Nats-Expected-Last-Msg-Id";
+    readonly ExpectedLastSubjectSequenceHdr: "Nats-Expected-Last-Subject-Sequence";
+};
+export type PubHeaders = typeof PubHeaders[keyof typeof PubHeaders];
+//# sourceMappingURL=jsapi_types.d.ts.map