@visulima/notification 0.0.1 → 1.0.0-alpha.2

package/dist/i18n/index.d.ts

@@ -0,0 +1,42 @@
+/** Per-locale map of message key → ICU MessageFormat string. */
+type LocaleMessages = Record<string, string>;
+/** Options for {@link createTranslator}. */
+interface TranslatorOptions {
+  /** The locale to fall back to when a key is missing for the requested locale. */
+  fallbackLocale: string;
+  /** `locale → (key → ICU message)`. Locales may be `en`, `de-DE`, `de_DE`, … */
+  messages: Record<string, LocaleMessages>;
+  /** Called when a key is missing in every candidate locale; defaults to returning the key. */
+  onMissing?: (locale: string, key: string) => string;
+}
+/** Resolves and formats localized messages with ICU MessageFormat. */
+interface Translator {
+  /** Whether `key` resolves for `locale` (via region → language → fallback). */
+  has: (locale: string, key: string) => boolean;
+  /** Format `key` for `locale`, interpolating `values` (plurals/select via ICU). */
+  translate: (locale: string, key: string, values?: Record<string, unknown>) => string;
+}
+/**
+* Create a {@link Translator} over a set of locale message tables, using
+* [ICU MessageFormat](https://formatjs.io/docs/core-concepts/icu-syntax/) (plurals,
+* select, number/date) via `intl-messageformat`, with region → language → fallback
+* resolution driven by the subscriber's locale. Edge-safe and dependency-light
+* (requires the `intl-messageformat` peer).
+* @param options Message tables, fallback locale, and an optional missing-key handler.
+* @returns A {@link Translator}.
+* @example
+* ```ts
+* const t = createTranslator({
+*     fallbackLocale: "en",
+*     messages: {
+*         en: { likes: "{count, plural, one {# like} other {# likes}}" },
+*         de_DE: { likes: "{count, plural, one {# Like} other {# Likes}}" },
+*     },
+* });
+*
+* t.translate("de_DE", "likes", { count: 3 }); // "3 Likes"
+* t.translate("fr", "likes", { count: 1 });    // falls back to en → "1 like"
+* ```
+*/
+declare const createTranslator: (options: TranslatorOptions) => Translator;
+export { type Translator, type TranslatorOptions, createTranslator };

package/dist/i18n/index.js

@@ -0,0 +1 @@
+import{default as e}from"../packem_shared/createTranslator-CY91C2eS.js";export{e as createTranslator};

package/dist/index.d.ts

@@ -0,0 +1,174 @@
+export { type M as Middleware, type S as SendContext, type a as SendFunction, c as composeMiddleware } from "./packem_shared/types.d-CximoA8M.js";
+import { C as ChannelPayloadMap, a as NotificationMessage } from "./packem_shared/notification.d-DFCVTods.js";
+export { N as Notification, type b as NotificationProviders, type S as SendManyOptions, c as createNotification, s as send } from "./packem_shared/notification.d-DFCVTods.js";
+export { type P as Provider, type a as ProviderFactory, d as defineProvider } from "./packem_shared/provider.d-BQAGriz6.js";
+export type { d as BaseConfig, B as BaseNotificationPayload, C as ChannelType, b as ChatPayload, f as EmailAddressLike, E as EmailChannelPayload, g as FailureReceipt, F as FeatureFlags, I as InAppPayload, M as MaybePromise, N as NotificationEvent, e as NotificationEventType, h as NotificationPayload, a as NotificationResult, P as PushPayload, c as Receipt, i as RecipientResult, R as Result, S as SmsPayload, j as SuccessReceipt, W as WebhookPayload } from "./packem_shared/types.d-GUzX1jTk.js";
+interface ErrorProperties {
+  cause?: unknown;
+  hint?: ErrorHint;
+  location?: ErrorLocation;
+  message?: string;
+  name: string;
+  stack?: string;
+  title?: string;
+}
+interface ErrorLocation {
+  column?: number;
+  file?: string;
+  line?: number;
+}
+/**
+* A message that explains to the user how they can fix the error.
+* @example
+* ```ts
+* const error = new VisulimaError({
+*    hint: "Try running `npm install` to install missing dependencies.",
+*    location: {
+*    file: "src/index.ts",
+*    line: 1,
+*    column: 1,
+*    },
+*    message: "Cannot find module 'react'",
+*    name: "ModuleNotFoundError",
+* });
+* ```
+*
+* For more complex hints, you can pass an array of strings or a single string in markdown format.
+*/
+type ErrorHint = string[] | string;
+declare class VisulimaError extends Error {
+  loc: ErrorLocation | undefined;
+  title: string | undefined;
+  /**
+  * A message that explains to the user how they can fix the error.
+  */
+  hint: ErrorHint | undefined;
+  type: string;
+  constructor({
+    cause,
+    hint,
+    location,
+    message,
+    name,
+    stack,
+    title
+  }: ErrorProperties);
+  setLocation(location: ErrorLocation): void;
+  setName(name: string): void;
+  setMessage(message: string): void;
+  setHint(hint: ErrorHint): void;
+}
+/**
+* Will return an array of all causes in the error in the order they occurred.
+*/
+/**
+* Base error class for notification package operations.
+* @param component The component name where the error occurred.
+* @param message The error message describing what went wrong.
+* @param options Optional error options including cause, code, and hint.
+*/
+declare class NotificationError extends VisulimaError {
+  readonly component: string;
+  readonly code?: string;
+  constructor(component: string, message: string, options?: {
+    cause?: Error | unknown;
+    code?: string;
+    hint?: string | string[];
+  });
+}
+/**
+* Error for missing required options.
+* @param component The component name where the error occurred.
+* @param name The name(s) of the missing required option(s).
+*/
+declare class RequiredOptionError extends NotificationError {
+  constructor(component: string, name: string | string[]);
+}
+/**
+* Fluent builder for assembling a multi-channel {@link NotificationMessage}.
+*
+* Mirrors the ergonomics of `@visulima/email`'s `MailMessage`: chainable, per-channel
+* setters that accumulate a plain message object. It is a thin convenience over the
+* existing `NotificationMessage` shape and does not change the facade — `build()`
+* returns the exact object `Notification.send()` already accepts.
+* @example
+* ```ts
+* const message = createNotificationMessage()
+*   .sms({ text: "your code is 123", to: "+15555550100" })
+*   .push({ body: "deploy finished", title: "CI", to: "device-token" })
+*   .idempotencyKey("deploy-42")
+*   .build();
+*
+* await createNotification({ sms, push }).send(message);
+* ```
+*/
+declare class NotificationMessageBuilder {
+  #private;
+  /**
+  * Sets the SMS payload for the message.
+  * @param payload The SMS channel payload.
+  * @returns This instance for method chaining.
+  */
+  sms(payload: ChannelPayloadMap["sms"]): this;
+  /**
+  * Sets the push payload for the message.
+  * @param payload The push channel payload.
+  * @returns This instance for method chaining.
+  */
+  push(payload: ChannelPayloadMap["push"]): this;
+  /**
+  * Sets the chat payload for the message.
+  * @param payload The chat channel payload.
+  * @returns This instance for method chaining.
+  */
+  chat(payload: ChannelPayloadMap["chat"]): this;
+  /**
+  * Sets the in-app inbox payload for the message.
+  * @param payload The in-app channel payload.
+  * @returns This instance for method chaining.
+  */
+  inApp(payload: ChannelPayloadMap["inapp"]): this;
+  /**
+  * Sets the outbound webhook payload for the message.
+  * @param payload The webhook channel payload.
+  * @returns This instance for method chaining.
+  */
+  webhook(payload: ChannelPayloadMap["webhook"]): this;
+  /**
+  * Sets the email payload for the message.
+  * @param payload The email channel payload.
+  * @returns This instance for method chaining.
+  */
+  email(payload: ChannelPayloadMap["email"]): this;
+  /**
+  * Sets metadata applied to every present channel payload at build time.
+  *
+  * Per-channel `metadata` already set on a payload takes precedence over these
+  * builder-level values (the builder values are spread first).
+  * @param metadata Arbitrary metadata to attach.
+  * @returns This instance for method chaining.
+  */
+  metadata(metadata: Record<string, unknown>): this;
+  /**
+  * Sets an idempotency key applied to every present channel payload at build time.
+  *
+  * A per-channel `idempotencyKey` already set on a payload takes precedence.
+  * @param key The idempotency key used to dedupe retried sends.
+  * @returns This instance for method chaining.
+  */
+  idempotencyKey(key: string): this;
+  /**
+  * Builds the plain {@link NotificationMessage}.
+  *
+  * Applies builder-level `metadata` / `idempotencyKey` to each present channel
+  * payload without overriding values already set on the individual payloads.
+  * @returns The assembled multi-channel message.
+  */
+  build(): NotificationMessage;
+}
+/**
+* Creates a new {@link NotificationMessageBuilder}.
+* @returns A fresh fluent message builder.
+*/
+declare const createNotificationMessage: () => NotificationMessageBuilder;
+export { type ChannelPayloadMap, NotificationError, type NotificationMessage, NotificationMessageBuilder, RequiredOptionError, createNotificationMessage };

package/dist/index.js

@@ -0,0 +1 @@
+import{default as r}from"./packem_shared/NotificationError-DVfMJQ1u.js";import{default as t}from"./packem_shared/RequiredOptionError-CuL42XRq.js";import{composeMiddleware as f}from"./packem_shared/composeMiddleware-D6dR8DUS.js";import{Notification as c,createNotification as n,send as p}from"./packem_shared/Notification-B22tuJPy.js";import{NotificationMessageBuilder as m,createNotificationMessage as x}from"./packem_shared/NotificationMessageBuilder-Br_aZusY.js";import{defineProvider as l}from"./packem_shared/defineProvider-C9q-7iwt.js";export{c as Notification,r as NotificationError,m as NotificationMessageBuilder,t as RequiredOptionError,f as composeMiddleware,n as createNotification,x as createNotificationMessage,l as defineProvider,p as send};

package/dist/layouts/index.d.ts

@@ -0,0 +1,45 @@
+import { T as TemplateRenderer } from "../packem_shared/types.d-td-F2Oh0.js";
+/** Options for {@link defineLayout}. */
+interface LayoutOptions {
+  /**
+  * The renderer used for the layout template. Defaults to the zero-dependency
+  * `renderString` (`{{var}}`); pass the Handlebars/Liquid renderer for logic.
+  */
+  render?: TemplateRenderer;
+  /** Name of the slot variable the content is injected as. Defaults to `"content"`. */
+  slot?: string;
+  /**
+  * The layout template. Must contain the slot placeholder (default `{{content}}`).
+  * With the Handlebars renderer use the unescaped `{{{content}}}` so the already-
+  * rendered HTML body is not double-escaped.
+  */
+  template: string;
+}
+/** A reusable layout: renders a content string into its slot, then renders the wrapper. */
+interface Layout {
+  /**
+  * Wrap `content` in the layout.
+  * @param content The already-rendered body to inject into the slot.
+  * @param variables Extra variables available to the layout template (e.g. `unsubscribeUrl`).
+  */
+  render: (content: string, variables?: Record<string, unknown>) => Promise<string>;
+}
+/**
+* Define a reusable content layout — shared chrome (header/footer/brand) with a
+* `{{content}}` slot the per-notification body drops into. Code-first and engine-
+* agnostic: it reuses the package's template renderers, so it stays edge-safe with
+* the default `renderString`.
+* @param options The layout template, optional renderer and slot name.
+* @returns A {@link Layout} whose `render(content, vars)` returns the wrapped string.
+* @example
+* ```ts
+* const branded = defineLayout({
+*     template: `<table><tr><td>{{content}}</td></tr><tr><td><a href="{{unsubscribeUrl}}">unsubscribe</a></td></tr></table>`,
+* });
+*
+* const html = await branded.render("<p>Welcome!</p>", { unsubscribeUrl: "https://app/u/123" });
+* await notify.sendToChannel("email", { from, to, subject: "Hi", html });
+* ```
+*/
+declare const defineLayout: (options: LayoutOptions) => Layout;
+export { type Layout, type LayoutOptions, defineLayout };

package/dist/layouts/index.js

@@ -0,0 +1 @@
+import{default as f}from"../packem_shared/defineLayout-73TNxYPq.js";export{f as defineLayout};

package/dist/middleware/index.d.ts

@@ -0,0 +1,382 @@
+import { M as Middleware, S as SendContext } from "../packem_shared/types.d-CximoA8M.js";
+export { type a as SendFunction, c as composeMiddleware } from "../packem_shared/types.d-CximoA8M.js";
+import { C as ChannelType, B as BaseNotificationPayload } from "../packem_shared/types.d-GUzX1jTk.js";
+import { A as Attributes, C as Context, T as Tracer } from "../packem_shared/tracer.d-Co1s_NwG.js";
+interface CircuitBreakerMiddlewareOptions {
+  /** Time in ms the circuit stays open before a trial request (default 30000). */
+  resetTimeout?: number;
+  /** Consecutive failures before the circuit opens (default 5). */
+  threshold?: number;
+}
+/**
+* Trips a circuit after consecutive failures, short-circuiting further sends until a
+* cool-off elapses (then allows a single trial request).
+* @param options Failure `threshold` and open-circuit `resetTimeout` (ms).
+* @returns A middleware.
+*/
+declare const circuitBreakerMiddleware: (options?: CircuitBreakerMiddlewareOptions) => Middleware;
+interface DedupeMiddlewareOptions {
+  /** Derive the dedupe key (default: `payload.idempotencyKey`). */
+  keyFn?: (context: SendContext) => string | undefined;
+  /** How long a key is remembered, in ms (default 60000). */
+  ttl?: number;
+}
+/**
+* Suppresses duplicate sends within a TTL window, keyed by idempotency key. A suppressed
+* send resolves successfully with `sent: false` and a `deduped:` message id.
+* @param options Custom `keyFn` and `ttl` (ms) controlling how keys are derived and expire.
+* @returns A middleware.
+*/
+declare const dedupeMiddleware: (options?: DedupeMiddlewareOptions) => Middleware;
+interface LoggingMiddlewareOptions {
+  /** Console-like logger (default `console`). */
+  logger?: Console;
+}
+/**
+* Logs each send attempt and its outcome.
+* @param options Provide a custom console-like `logger` (defaults to the global console).
+* @returns A middleware.
+*/
+declare const loggingMiddleware: (options?: LoggingMiddlewareOptions) => Middleware;
+interface RateLimitMiddlewareOptions {
+  /** Time window in ms over which `rate` tokens are available (default 1000). */
+  interval?: number;
+  /** Number of sends allowed per `interval` (token bucket capacity). */
+  rate: number;
+}
+/**
+* Throttles sends with a token-bucket rate limiter.
+* @param options Bucket `rate` (capacity) and refill `interval` (ms).
+* @returns A middleware.
+*/
+declare const rateLimitMiddleware: (options: RateLimitMiddlewareOptions) => Middleware;
+interface RetryMiddlewareOptions {
+  /** Base backoff delay in ms (default 250). */
+  baseDelay?: number;
+  /** Maximum retry attempts after the first try (default 3). */
+  retries?: number;
+  /** Decide whether a failed result is retryable (default: always retry). */
+  shouldRetry?: (error: unknown) => boolean;
+}
+/**
+* Retries failed sends with exponential backoff + jitter.
+* @param options Attempt count (`retries`), `baseDelay` (ms) and a `shouldRetry` predicate.
+* @returns A middleware.
+*/
+declare const retryMiddleware: (options?: RetryMiddlewareOptions) => Middleware;
+/**
+* Options for {@link suppressionMiddleware}.
+*/
+interface SuppressionMiddlewareOptions {
+  /** Returns whether a recipient is suppressed on a channel (unsubscribed, hard-bounced); may be async. */
+  isSuppressed: (recipient: string, channel: ChannelType) => boolean | Promise<boolean>;
+  /** Resolves the recipient identifier from a payload. Defaults to a stringified `payload.to`. */
+  resolveRecipient?: (payload: BaseNotificationPayload) => string | undefined;
+}
+/**
+* Short-circuits sends to suppressed recipients (unsubscribed, hard-bounced, ...). When the resolved
+* recipient is suppressed the send resolves successfully with `sent: false` and a `suppressed:` message
+* id, mirroring how {@link import("./dedupe").dedupeMiddleware} returns a synthetic success.
+*
+* Edge-safe: pure logic with no Node built-ins, so it runs on Cloudflare Workers and other edge runtimes.
+* @param options Suppression check and optional recipient resolver. See {@link SuppressionMiddlewareOptions}.
+* @returns A middleware.
+*/
+declare const suppressionMiddleware: (options: SuppressionMiddlewareOptions) => Middleware;
+/**
+ * Advisory options influencing aggregation configuration parameters.
+ *
+ * @since 1.7.0
+ * @experimental
+ */
+interface MetricAdvice {
+  /**
+   * Hint the explicit bucket boundaries for SDK if the metric is been
+   * aggregated with a HistogramAggregator.
+   */
+  explicitBucketBoundaries?: number[];
+}
+/**
+ * Options needed for metric creation
+ *
+ * @since 1.3.0
+ */
+interface MetricOptions {
+  /**
+   * The description of the Metric.
+   * @default ''
+   */
+  description?: string;
+  /**
+   * The unit of the Metric values.
+   * @default ''
+   */
+  unit?: string;
+  /**
+   * Indicates the type of the recorded value.
+   * @default {@link ValueType.DOUBLE}
+   */
+  valueType?: ValueType;
+  /**
+   * The advice influencing aggregation configuration parameters.
+   * @experimental
+   * @since 1.7.0
+   */
+  advice?: MetricAdvice;
+}
+/**
+ * The Type of value. It describes how the data is reported.
+ *
+ * @since 1.3.0
+ */
+declare enum ValueType {
+  INT = 0,
+  DOUBLE = 1,
+}
+/**
+ * Counter is the most common synchronous instrument. This instrument supports
+ * an `Add(increment)` function for reporting a sum, and is restricted to
+ * non-negative increments. The default aggregation is Sum, as for any additive
+ * instrument.
+ *
+ * Example uses for Counter:
+ * <ol>
+ *   <li> count the number of bytes received. </li>
+ *   <li> count the number of requests completed. </li>
+ *   <li> count the number of accounts created. </li>
+ *   <li> count the number of checkpoints run. </li>
+ *   <li> count the number of 5xx errors. </li>
+ * <ol>
+ *
+ * @since 1.3.0
+ */
+interface Counter<AttributesTypes extends MetricAttributes = MetricAttributes> {
+  /**
+   * Increment value of counter by the input. Inputs must not be negative.
+   */
+  add(value: number, attributes?: AttributesTypes, context?: Context): void;
+}
+/**
+ * @since 1.3.0
+ */
+interface UpDownCounter<AttributesTypes extends MetricAttributes = MetricAttributes> {
+  /**
+   * Increment value of counter by the input. Inputs may be negative.
+   */
+  add(value: number, attributes?: AttributesTypes, context?: Context): void;
+}
+/**
+ * @since 1.9.0
+ */
+interface Gauge<AttributesTypes extends MetricAttributes = MetricAttributes> {
+  /**
+   * Records a measurement.
+   */
+  record(value: number, attributes?: AttributesTypes, context?: Context): void;
+}
+/**
+ * @since 1.3.0
+ */
+interface Histogram<AttributesTypes extends MetricAttributes = MetricAttributes> {
+  /**
+   * Records a measurement. Value of the measurement must not be negative.
+   */
+  record(value: number, attributes?: AttributesTypes, context?: Context): void;
+}
+/**
+ * @deprecated please use {@link Attributes}
+ * @since 1.3.0
+ */
+type MetricAttributes = Attributes;
+/**
+ * Interface that is being used in callback function for Observable Metric.
+ *
+ * @since 1.3.0
+ */
+interface ObservableResult<AttributesTypes extends MetricAttributes = MetricAttributes> {
+  /**
+   * Observe a measurement of the value associated with the given attributes.
+   *
+   * @param value The value to be observed.
+   * @param attributes The attributes associated with the value. If more than
+   * one value is associated with the same attributes values, SDK may pick the
+   * last one or simply drop the entire observable result.
+   */
+  observe(this: ObservableResult<AttributesTypes>, value: number, attributes?: AttributesTypes): void;
+}
+/**
+ * Interface that is being used in batch observable callback function.
+ */
+interface BatchObservableResult<AttributesTypes extends MetricAttributes = MetricAttributes> {
+  /**
+   * Observe a measurement of the value associated with the given attributes.
+   *
+   * @param metric The observable metric to be observed.
+   * @param value The value to be observed.
+   * @param attributes The attributes associated with the value. If more than
+   * one value is associated with the same attributes values, SDK may pick the
+   * last one or simply drop the entire observable result.
+   */
+  observe(this: BatchObservableResult<AttributesTypes>, metric: Observable<AttributesTypes>, value: number, attributes?: AttributesTypes): void;
+}
+/**
+ * The observable callback for Observable instruments.
+ *
+ * @since 1.3.0
+ */
+type ObservableCallback<AttributesTypes extends MetricAttributes = MetricAttributes> = (observableResult: ObservableResult<AttributesTypes>) => void | Promise<void>;
+/**
+ * The observable callback for a batch of Observable instruments.
+ *
+ * @since 1.3.0
+ */
+type BatchObservableCallback<AttributesTypes extends MetricAttributes = MetricAttributes> = (observableResult: BatchObservableResult<AttributesTypes>) => void | Promise<void>;
+/**
+ * @since 1.3.0
+ */
+interface Observable<AttributesTypes extends MetricAttributes = MetricAttributes> {
+  /**
+   * Sets up a function that will be called whenever a metric collection is initiated.
+   *
+   * If the function is already in the list of callbacks for this Observable, the function is not added a second time.
+   */
+  addCallback(callback: ObservableCallback<AttributesTypes>): void;
+  /**
+   * Removes a callback previously registered with {@link Observable.addCallback}.
+   */
+  removeCallback(callback: ObservableCallback<AttributesTypes>): void;
+}
+/**
+ * @since 1.3.0
+ */
+type ObservableCounter<AttributesTypes extends MetricAttributes = MetricAttributes> = Observable<AttributesTypes>;
+/**
+ * @since 1.3.0
+ */
+type ObservableUpDownCounter<AttributesTypes extends MetricAttributes = MetricAttributes> = Observable<AttributesTypes>;
+/**
+ * @since 1.3.0
+ */
+type ObservableGauge<AttributesTypes extends MetricAttributes = MetricAttributes> = Observable<AttributesTypes>;
+/**
+ * An interface to allow the recording metrics.
+ *
+ * {@link Metric}s are used for recording pre-defined aggregation (`Counter`),
+ * or raw values (`Histogram`) in which the aggregation and attributes
+ * for the exported metric are deferred.
+ *
+ * @since 1.3.0
+ */
+interface Meter {
+  /**
+   * Creates and returns a new `Gauge`.
+   * @param name the name of the metric.
+   * @param [options] the metric options.
+   */
+  createGauge<AttributesTypes extends MetricAttributes = MetricAttributes>(name: string, options?: MetricOptions): Gauge<AttributesTypes>;
+  /**
+   * Creates and returns a new `Histogram`.
+   * @param name the name of the metric.
+   * @param [options] the metric options.
+   */
+  createHistogram<AttributesTypes extends MetricAttributes = MetricAttributes>(name: string, options?: MetricOptions): Histogram<AttributesTypes>;
+  /**
+   * Creates a new `Counter` metric. Generally, this kind of metric when the
+   * value is a quantity, the sum is of primary interest, and the event count
+   * and value distribution are not of primary interest.
+   * @param name the name of the metric.
+   * @param [options] the metric options.
+   */
+  createCounter<AttributesTypes extends MetricAttributes = MetricAttributes>(name: string, options?: MetricOptions): Counter<AttributesTypes>;
+  /**
+   * Creates a new `UpDownCounter` metric. UpDownCounter is a synchronous
+   * instrument and very similar to Counter except that Add(increment)
+   * supports negative increments. It is generally useful for capturing changes
+   * in an amount of resources used, or any quantity that rises and falls
+   * during a request.
+   * Example uses for UpDownCounter:
+   * <ol>
+   *   <li> count the number of active requests. </li>
+   *   <li> count memory in use by instrumenting new and delete. </li>
+   *   <li> count queue size by instrumenting enqueue and dequeue. </li>
+   *   <li> count semaphore up and down operations. </li>
+   * </ol>
+   *
+   * @param name the name of the metric.
+   * @param [options] the metric options.
+   */
+  createUpDownCounter<AttributesTypes extends MetricAttributes = MetricAttributes>(name: string, options?: MetricOptions): UpDownCounter<AttributesTypes>;
+  /**
+   * Creates a new `ObservableGauge` metric.
+   *
+   * The callback SHOULD be safe to be invoked concurrently.
+   *
+   * @param name the name of the metric.
+   * @param [options] the metric options.
+   */
+  createObservableGauge<AttributesTypes extends MetricAttributes = MetricAttributes>(name: string, options?: MetricOptions): ObservableGauge<AttributesTypes>;
+  /**
+   * Creates a new `ObservableCounter` metric.
+   *
+   * The callback SHOULD be safe to be invoked concurrently.
+   *
+   * @param name the name of the metric.
+   * @param [options] the metric options.
+   */
+  createObservableCounter<AttributesTypes extends MetricAttributes = MetricAttributes>(name: string, options?: MetricOptions): ObservableCounter<AttributesTypes>;
+  /**
+   * Creates a new `ObservableUpDownCounter` metric.
+   *
+   * The callback SHOULD be safe to be invoked concurrently.
+   *
+   * @param name the name of the metric.
+   * @param [options] the metric options.
+   */
+  createObservableUpDownCounter<AttributesTypes extends MetricAttributes = MetricAttributes>(name: string, options?: MetricOptions): ObservableUpDownCounter<AttributesTypes>;
+  /**
+   * Sets up a function that will be called whenever a metric collection is
+   * initiated.
+   *
+   * If the function is already in the list of callbacks for this Observable,
+   * the function is not added a second time.
+   *
+   * Only the associated observables can be observed in the callback.
+   * Measurements of observables that are not associated observed in the
+   * callback are dropped.
+   *
+   * @param callback the batch observable callback
+   * @param observables the observables associated with this batch observable callback
+   */
+  addBatchObservableCallback<AttributesTypes extends MetricAttributes = MetricAttributes>(callback: BatchObservableCallback<AttributesTypes>, observables: Observable<AttributesTypes>[]): void;
+  /**
+   * Removes a callback previously registered with {@link Meter.addBatchObservableCallback}.
+   *
+   * The callback to be removed is identified using a combination of the callback itself,
+   * and the set of the observables associated with it.
+   *
+   * @param callback the batch observable callback
+   * @param observables the observables associated with this batch observable callback
+   */
+  removeBatchObservableCallback<AttributesTypes extends MetricAttributes = MetricAttributes>(callback: BatchObservableCallback<AttributesTypes>, observables: Observable<AttributesTypes>[]): void;
+}
+interface TelemetryMiddlewareOptions {
+  /**
+  * The OpenTelemetry {@link Meter} used to record a send counter and duration histogram.
+  * When omitted, no metrics are recorded.
+  */
+  meter?: Meter;
+  /**
+  * The OpenTelemetry {@link Tracer} used to create a span per send. When omitted, no span
+  * is recorded (keeping `@opentelemetry/api` an optional peer dependency).
+  */
+  tracer?: Tracer;
+}
+/**
+* Records an OpenTelemetry span plus a send counter and duration histogram for each send.
+* Edge-safe: `@opentelemetry/api` is runtime-agnostic and both the tracer and meter are
+* injected, so nothing is emitted until the host application supplies them.
+* @param options Provide a `tracer` and/or `meter` to enable tracing and metrics.
+* @returns A middleware.
+*/
+declare const telemetryMiddleware: (options?: TelemetryMiddlewareOptions) => Middleware;
+export { type CircuitBreakerMiddlewareOptions, type DedupeMiddlewareOptions, type LoggingMiddlewareOptions, type Middleware, type RateLimitMiddlewareOptions, type RetryMiddlewareOptions, type SendContext, type SuppressionMiddlewareOptions, type TelemetryMiddlewareOptions, circuitBreakerMiddleware, dedupeMiddleware, loggingMiddleware, rateLimitMiddleware, retryMiddleware, suppressionMiddleware, telemetryMiddleware };

package/dist/middleware/index.js

@@ -0,0 +1 @@
+import{circuitBreakerMiddleware as o}from"../packem_shared/circuitBreakerMiddleware-BlZN7SVT.js";import{dedupeMiddleware as i}from"../packem_shared/dedupeMiddleware-CQmPJd_h.js";import{loggingMiddleware as p}from"../packem_shared/loggingMiddleware-Cs6EDLcL.js";import{rateLimitMiddleware as a}from"../packem_shared/rateLimitMiddleware-DWmEYq-m.js";import{retryMiddleware as f}from"../packem_shared/retryMiddleware-uUJDcUoP.js";import{suppressionMiddleware as x}from"../packem_shared/suppressionMiddleware-CY-Qo1A_.js";import{telemetryMiddleware as s}from"../packem_shared/telemetryMiddleware-B1N4k171.js";import{composeMiddleware as g}from"../packem_shared/composeMiddleware-D6dR8DUS.js";export{o as circuitBreakerMiddleware,g as composeMiddleware,i as dedupeMiddleware,p as loggingMiddleware,a as rateLimitMiddleware,f as retryMiddleware,x as suppressionMiddleware,s as telemetryMiddleware};

package/dist/packem_shared/MemoryDigestStore-Bw-sE5MI.js

@@ -0,0 +1 @@
+class a{#e=new Map;append(e,s,r){const t=this.#e.get(e);return t===void 0?(this.#e.set(e,{events:[s],key:e,wakeAt:r}),Promise.resolve(!0)):(t.events.push(s),Promise.resolve(!1))}read(e){return Promise.resolve(this.#e.get(e))}remove(e){return this.#e.delete(e),Promise.resolve()}due(e,s){const r=[...this.#e.values()].filter(t=>t.wakeAt<=e).toSorted((t,o)=>t.wakeAt-o.wakeAt).slice(0,s).map(t=>t.key);return Promise.resolve(r)}}export{a as default};

package/dist/packem_shared/MemoryEventStore-BGD_xRxu.js

@@ -0,0 +1 @@
+class a{#e=new Map;append(e){const s=this.#e.get(e.messageId)??[];s.push(e),this.#e.set(e.messageId,s)}timeline(e){return this.#e.get(e)??[]}}export{a as default};

package/dist/packem_shared/MemoryInAppStore-48qlrDCx.js

@@ -0,0 +1 @@
+import{n as i}from"./id-C_FRCsUM.js";class d{#e=new Map;add(r){const e={...r,createdAt:Date.now(),id:r.id??i("inapp"),read:!1};return this.#e.set(e.id,e),Promise.resolve(e)}list(r,e={}){let t=[...this.#e.values()].filter(s=>s.subscriberId===r);return e.unreadOnly&&(t=t.filter(s=>!s.read)),t.sort((s,o)=>o.createdAt-s.createdAt),Promise.resolve(e.limit?t.slice(0,e.limit):t)}markRead(r){const e=this.#e.get(r);return e&&(e.read=!0),Promise.resolve()}markAllRead(r){for(const e of this.#e.values())e.subscriberId===r&&(e.read=!0);return Promise.resolve()}unreadCount(r){let e=0;for(const t of this.#e.values())t.subscriberId===r&&!t.read&&(e+=1);return Promise.resolve(e)}remove(r){return this.#e.delete(r),Promise.resolve()}}export{d as MemoryInAppStore};

package/dist/packem_shared/MemoryQueue-CXgWoZoY.js

@@ -0,0 +1 @@
+import{n}from"./id-C_FRCsUM.js";class r{#e=[];#t=new Map;enqueue(t,s){const e={attempts:0,id:n("job"),message:t,scheduledAt:s?.scheduledAt};return this.#e.push(e),e.id}reserve(){const t=Date.now(),s=this.#e.findIndex(i=>(i.scheduledAt??0)<=t);if(s===-1)return;const e=this.#e.splice(s,1)[0];return e.attempts+=1,this.#t.set(e.id,e),e}ack(t){this.#t.delete(t)}retry(t,s=0){const e=this.#t.get(t);e&&(this.#t.delete(t),e.scheduledAt=Date.now()+s,this.#e.push(e))}size(){return this.#e.length}}export{r as default};