nats/lib/jetstream/jsapi_types.d.ts

Node.js client for NATS, a lightweight, high-performance cloud native messaging system

import { ApiError, Nanos } from "../nats-base-client/core";
export interface ApiPaged {
    total: number;
    offset: number;
    limit: number;
}
export interface ApiPagedRequest {
    offset: number;
}
export interface ApiResponse {
    type: string;
    error?: ApiError;
}
/**
 * An alternate location to read mirrored data
 */
export interface 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 interface StreamInfo extends 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 interface 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 interface StreamConsumerLimits {
    /**
     * The default `inactive_threshold` applied to consumers.
     * This value is specified in nanoseconds. Pleause 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 interface StreamConfig extends 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 interface 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 interface 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 interface 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 interface Placement {
    /**
     * The cluster to place the stream on
     */
    cluster: string;
    /**
     * Tags matching server configuration
     */
    tags: string[];
}
export declare enum RetentionPolicy {
    /**
     * Retain messages until the limits are reached, then trigger the discard policy.
     */
    Limits = "limits",
    /**
     * Retain messages while there is consumer interest on the particular subject.
     */
    Interest = "interest",
    /**
     * Retain messages until acknowledged
     */
    Workqueue = "workqueue"
}
export declare enum DiscardPolicy {
    /**
     * Discard old messages to make room for the new ones
     */
    Old = "old",
    /**
     * Discard the new messages
     */
    New = "new"
}
export declare enum StorageType {
    /**
     * Store persistently on files
     */
    File = "file",
    /**
     * Store in server memory - doesn't survive server restarts
     */
    Memory = "memory"
}
export declare enum DeliverPolicy {
    /**
     * Deliver all messages
     */
    All = "all",
    /**
     * Deliver starting with the last message
     */
    Last = "last",
    /**
     * Deliver starting with new messages
     */
    New = "new",
    /**
     * Deliver starting with the specified sequence
     */
    StartSequence = "by_start_sequence",
    /**
     * Deliver starting with the specified time
     */
    StartTime = "by_start_time",
    /**
     * Deliver starting with the last messages for every subject
     */
    LastPerSubject = "last_per_subject"
}
export declare enum AckPolicy {
    /**
     * Messages don't need to be Ack'ed.
     */
    None = "none",
    /**
     * Ack, acknowledges all messages with a lower sequence
     */
    All = "all",
    /**
     * All sequences must be explicitly acknowledged
     */
    Explicit = "explicit",
    /**
     * @ignore
     */
    NotSet = ""
}
export declare enum ReplayPolicy {
    /**
     * Replays messages as fast as possible
     */
    Instant = "instant",
    /**
     * Replays messages following the original delay between messages
     */
    Original = "original"
}
export declare enum StoreCompression {
    /**
     * No compression
     */
    None = "none",
    /**
     * S2 compression
     */
    S2 = "s2"
}
/**
 * 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;
/**
 * Request the next stream message by sequence for the specified subject.
 */
export type NextMsgRequest = {
    /**
     * The seq to start looking. If the message under the specified sequence
     * matches, it will be returned.
     */
    seq: number;
    /**
     * The subject to look for
     */
    next_by_subj: string;
};
export type DirectMsgRequest = SeqMsgRequest | LastForMsgRequest | NextMsgRequest;
export type DirectBatchOptions = {
    batch?: number;
    max_bytes?: number;
    multi_last: string[];
    up_to_seq?: number;
    up_to_time?: Date | string;
};
export interface 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 interface LostStreamData {
    /**
     * The messages that were lost
     */
    msgs: number[] | null;
    /**
     * The number of bytes that were lost
     */
    bytes: number;
}
export interface ClusterInfo {
    /**
     * The cluster name
     */
    name?: string;
    /**
     * The server name of the RAFT leader
     */
    leader?: string;
    /**
     * The members of the RAFT cluster
     */
    replicas?: PeerInfo[];
}
export interface 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 interface 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 interface PurgeResponse extends Success {
    /**
     * Number of messages purged from the Stream
     */
    purged: number;
}
export declare enum ConsumerApiAction {
    CreateOrUpdate = "",
    Update = "update",
    Create = "create"
}
export interface CreateConsumerRequest {
    "stream_name": string;
    config: Partial<ConsumerConfig>;
    action?: ConsumerApiAction;
}
export interface StreamMsgResponse extends ApiResponse {
    message: {
        subject: string;
        seq: number;
        data: string;
        hdrs: string;
        time: string;
    };
}
export interface SequenceInfo {
    "consumer_seq": number;
    "stream_seq": number;
    "last_active": Nanos;
}
export interface 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 interface ConsumerListResponse extends ApiResponse, ApiPaged {
    consumers: ConsumerInfo[];
}
export interface StreamListResponse extends ApiResponse, ApiPaged {
    streams: StreamInfo[];
}
export interface Success {
    /**
     * True if the operation succeeded
     */
    success: boolean;
}
export type SuccessResponse = ApiResponse & Success;
export interface LastForMsgRequest {
    /**
     * Retrieves the last message for the given subject
     */
    "last_by_subj": string;
}
export interface SeqMsgRequest {
    /**
     * Stream sequence number of the message to retrieve
     */
    seq: number;
}
export type MsgRequest = SeqMsgRequest | LastForMsgRequest | number;
export interface MsgDeleteRequest extends 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 interface 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 interface 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 interface JetStreamUsageAccountLimits extends JetStreamUsage {
    limits: AccountLimits;
}
export interface JetStreamAccountStats extends JetStreamUsageAccountLimits {
    api: JetStreamApiStats;
    domain?: string;
    tiers?: {
        R1?: JetStreamUsageAccountLimits;
        R3?: JetStreamUsageAccountLimits;
    };
}
export interface JetStreamApiStats {
    /**
     * Total number of API requests received for this account
     */
    total: number;
    /**
     * "API requests that resulted in an error response"
     */
    errors: number;
}
export interface AccountInfoResponse extends ApiResponse, JetStreamAccountStats {
}
export interface ConsumerConfig extends 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
     * @deprecated
     */
    "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 interface ConsumerUpdateConfig {
    /**
     * 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 number of times a message will be redelivered to consumers if not acknowledged in time
     */
    "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
     * @deprecated
     */
    "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
     */
    "max_expires"?: Nanos;
    /**
     * Duration that instructs the server to clean up ephemeral consumers that are inactive for that long
     */
    "inactive_threshold"?: Nanos;
    /**
     * List of durations in nanoseconds format that represents a retry timescale for
     * NaK'd messages or those being normally retried
     */
    "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 function defaultConsumer(name: string, opts?: Partial<ConsumerConfig>): ConsumerConfig;
/**
 * 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 interface PullOptions {
    /**
     * 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;
    "idle_heartbeat": number;
}
export interface 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 redelivered.
     */
    redeliveryCount: 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;
}