@visulima/notification 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/tracer.d-Co1s_NwG.d.ts

@@ -0,0 +1,494 @@
+/**
+ * @since 1.0.0
+ */
+interface Context {
+  /**
+   * Get a value from the context.
+   *
+   * @param key key which identifies a context value
+   */
+  getValue(key: symbol): unknown;
+  /**
+   * Create a new context which inherits from this context and has
+   * the given key set to the given value.
+   *
+   * @param key context key for which to set the value
+   * @param value value to set for the given key
+   */
+  setValue(key: symbol, value: unknown): Context;
+  /**
+   * Return a new context which inherits from this context but does
+   * not contain a value for the given key.
+   *
+   * @param key context key for which to clear a value
+   */
+  deleteValue(key: symbol): Context;
+}
+/**
+ * Attributes is a map from string to attribute values.
+ *
+ * Note: only the own enumerable keys are counted as valid attribute keys.
+ *
+ * @since 1.3.0
+ */
+interface Attributes {
+  [attributeKey: string]: AttributeValue | undefined;
+}
+/**
+ * Attribute values may be any non-nullish primitive value except an object.
+ *
+ * null or undefined attribute values are invalid and will result in undefined behavior.
+ *
+ * @since 1.3.0
+ */
+type AttributeValue = string | number | boolean | Array<null | undefined | string> | Array<null | undefined | number> | Array<null | undefined | boolean>;
+interface ExceptionWithCode {
+  code: string | number;
+  name?: string;
+  message?: string;
+  stack?: string;
+}
+interface ExceptionWithMessage {
+  code?: string | number;
+  message: string;
+  name?: string;
+  stack?: string;
+}
+interface ExceptionWithName {
+  code?: string | number;
+  message?: string;
+  name: string;
+  stack?: string;
+}
+/**
+ * Defines Exception.
+ *
+ * string or an object with one of (message or name or code) and optional stack
+ *
+ * @since 1.0.0
+ */
+type Exception = ExceptionWithCode | ExceptionWithMessage | ExceptionWithName | string;
+/**
+ * Defines High-Resolution Time.
+ *
+ * The first number, HrTime[0], is UNIX Epoch time in seconds since 00:00:00 UTC on 1 January 1970.
+ * The second number, HrTime[1], represents the partial second elapsed since Unix Epoch time represented by first number in nanoseconds.
+ * For example, 2021-01-01T12:30:10.150Z in UNIX Epoch time in milliseconds is represented as 1609504210150.
+ * The first number is calculated by converting and truncating the Epoch time in milliseconds to seconds:
+ * HrTime[0] = Math.trunc(1609504210150 / 1000) = 1609504210.
+ * The second number is calculated by converting the digits after the decimal point of the subtraction, (1609504210150 / 1000) - HrTime[0], to nanoseconds:
+ * HrTime[1] = Number((1609504210.150 - HrTime[0]).toFixed(9)) * 1e9 = 150000000.
+ * This is represented in HrTime format as [1609504210, 150000000].
+ *
+ * @since 1.0.0
+ */
+type HrTime = [number, number];
+/**
+ * Defines TimeInput.
+ *
+ * hrtime, epoch milliseconds, performance.now() or Date
+ *
+ * @since 1.0.0
+ */
+type TimeInput = HrTime | number | Date;
+/**
+ * @deprecated please use {@link Attributes}
+ * @since 1.0.0
+ */
+type SpanAttributes = Attributes;
+/**
+ * @deprecated please use {@link AttributeValue}
+ * @since 1.0.0
+ */
+type SpanAttributeValue = AttributeValue;
+/**
+ * @since 1.0.0
+ */
+interface TraceState {
+  /**
+   * Create a new TraceState which inherits from this TraceState and has the
+   * given key set.
+   * The new entry will always be added in the front of the list of states.
+   *
+   * @param key key of the TraceState entry.
+   * @param value value of the TraceState entry.
+   */
+  set(key: string, value: string): TraceState;
+  /**
+   * Return a new TraceState which inherits from this TraceState but does not
+   * contain the given key.
+   *
+   * @param key the key for the TraceState entry to be removed.
+   */
+  unset(key: string): TraceState;
+  /**
+   * Returns the value to which the specified key is mapped, or `undefined` if
+   * this map contains no mapping for the key.
+   *
+   * @param key with which the specified value is to be associated.
+   * @returns the value to which the specified key is mapped, or `undefined` if
+   *     this map contains no mapping for the key.
+   */
+  get(key: string): string | undefined;
+  /**
+   * Serializes the TraceState to a `list` as defined below. The `list` is a
+   * series of `list-members` separated by commas `,`, and a list-member is a
+   * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs
+   * surrounding `list-members` are ignored. There can be a maximum of 32
+   * `list-members` in a `list`.
+   *
+   * @returns the serialized string.
+   */
+  serialize(): string;
+}
+/**
+ * A SpanContext represents the portion of a {@link Span} which must be
+ * serialized and propagated along side of a {@link Baggage}.
+ *
+ * @since 1.0.0
+ */
+interface SpanContext {
+  /**
+   * The ID of the trace that this span belongs to. It is worldwide unique
+   * with practically sufficient probability by being made as 16 randomly
+   * generated bytes, encoded as a 32 lowercase hex characters corresponding to
+   * 128 bits.
+   */
+  traceId: string;
+  /**
+   * The ID of the Span. It is globally unique with practically sufficient
+   * probability by being made as 8 randomly generated bytes, encoded as a 16
+   * lowercase hex characters corresponding to 64 bits.
+   */
+  spanId: string;
+  /**
+   * Only true if the SpanContext was propagated from a remote parent.
+   */
+  isRemote?: boolean;
+  /**
+   * Trace flags to propagate.
+   *
+   * It is represented as 1 byte (bitmap). Bit to represent whether trace is
+   * sampled or not. When set, the least significant bit documents that the
+   * caller may have recorded trace data. A caller who does not record trace
+   * data out-of-band leaves this flag unset.
+   *
+   * see {@link TraceFlags} for valid flag values.
+   */
+  traceFlags: number;
+  /**
+   * Tracing-system-specific info to propagate.
+   *
+   * The tracestate field value is a `list` as defined below. The `list` is a
+   * series of `list-members` separated by commas `,`, and a list-member is a
+   * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs
+   * surrounding `list-members` are ignored. There can be a maximum of 32
+   * `list-members` in a `list`.
+   * More Info: https://www.w3.org/TR/trace-context/#tracestate-field
+   *
+   * Examples:
+   *     Single tracing system (generic format):
+   *         tracestate: rojo=00f067aa0ba902b7
+   *     Multiple tracing systems (with different formatting):
+   *         tracestate: rojo=00f067aa0ba902b7,congo=t61rcWkgMzE
+   */
+  traceState?: TraceState;
+}
+/**
+ * @since 1.0.0
+ */
+interface SpanStatus {
+  /** The status code of this message. */
+  code: SpanStatusCode;
+  /** A developer-facing error message. */
+  message?: string;
+}
+/**
+ * An enumeration of status codes.
+ *
+ * @since 1.0.0
+ */
+declare enum SpanStatusCode {
+  /**
+   * The default status.
+   */
+  UNSET = 0,
+  /**
+   * The operation has been validated by an Application developer or
+   * Operator to have completed successfully.
+   */
+  OK = 1,
+  /**
+   * The operation contains an error.
+   */
+  ERROR = 2,
+}
+/**
+ * A pointer from the current {@link Span} to another span in the same trace or
+ * in a different trace.
+ * Few examples of Link usage.
+ * 1. Batch Processing: A batch of elements may contain elements associated
+ *    with one or more traces/spans. Since there can only be one parent
+ *    SpanContext, Link is used to keep reference to SpanContext of all
+ *    elements in the batch.
+ * 2. Public Endpoint: A SpanContext in incoming client request on a public
+ *    endpoint is untrusted from service provider perspective. In such case it
+ *    is advisable to start a new trace with appropriate sampling decision.
+ *    However, it is desirable to associate incoming SpanContext to new trace
+ *    initiated on service provider side so two traces (from Client and from
+ *    Service Provider) can be correlated.
+ *
+ * @since 1.0.0
+ */
+interface Link {
+  /** The {@link SpanContext} of a linked span. */
+  context: SpanContext;
+  /** A set of {@link SpanAttributes} on the link. */
+  attributes?: SpanAttributes;
+  /** Count of attributes of the link that were dropped due to collection limits */
+  droppedAttributesCount?: number;
+}
+/**
+ * An interface that represents a span. A span represents a single operation
+ * within a trace. Examples of span might include remote procedure calls or a
+ * in-process function calls to sub-components. A Trace has a single, top-level
+ * "root" Span that in turn may have zero or more child Spans, which in turn
+ * may have children.
+ *
+ * Spans are created by the {@link Tracer.startSpan} method.
+ *
+ * @since 1.0.0
+ */
+interface Span {
+  /**
+   * Returns the {@link SpanContext} object associated with this Span.
+   *
+   * Get an immutable, serializable identifier for this span that can be used
+   * to create new child spans. Returned SpanContext is usable even after the
+   * span ends.
+   *
+   * @returns the SpanContext object associated with this Span.
+   */
+  spanContext(): SpanContext;
+  /**
+   * Sets an attribute to the span.
+   *
+   * Sets a single Attribute with the key and value passed as arguments.
+   *
+   * @param key the key for this attribute.
+   * @param value the value for this attribute. Setting a value null or
+   *              undefined is invalid and will result in undefined behavior.
+   */
+  setAttribute(key: string, value: SpanAttributeValue): this;
+  /**
+   * Sets attributes to the span.
+   *
+   * @param attributes the attributes that will be added.
+   *                   null or undefined attribute values
+   *                   are invalid and will result in undefined behavior.
+   */
+  setAttributes(attributes: SpanAttributes): this;
+  /**
+   * Adds an event to the Span.
+   *
+   * @param name the name of the event.
+   * @param [attributesOrStartTime] the attributes that will be added; these are
+   *     associated with this event. Can be also a start time
+   *     if type is {@type TimeInput} and 3rd param is undefined
+   * @param [startTime] start time of the event.
+   */
+  addEvent(name: string, attributesOrStartTime?: SpanAttributes | TimeInput, startTime?: TimeInput): this;
+  /**
+   * Adds a single link to the span.
+   *
+   * Links added after the creation will not affect the sampling decision.
+   * It is preferred span links be added at span creation.
+   *
+   * @param link the link to add.
+   */
+  addLink(link: Link): this;
+  /**
+   * Adds multiple links to the span.
+   *
+   * Links added after the creation will not affect the sampling decision.
+   * It is preferred span links be added at span creation.
+   *
+   * @param links the links to add.
+   */
+  addLinks(links: Link[]): this;
+  /**
+   * Sets the status of the span.
+   *
+   * By default, a span has status {@link SpanStatusCode.UNSET}.
+   * Calling this method overrides that default.
+   *
+   * The status codes have a total order: `OK > ERROR > UNSET`.
+   *
+   * - Once {@link SpanStatusCode.OK} is set, any further attempts to change
+   *   the status are ignored.
+   * - Any attempt to set {@link SpanStatusCode.UNSET} is always ignored.
+   *
+   * The `message` field is only used when {@link SpanStatusCode.ERROR} is set.
+   * For all other status codes, `message` is ignored.
+   *
+   * @param status The {@link SpanStatus} to set.
+   */
+  setStatus(status: SpanStatus): this;
+  /**
+   * Updates the Span name.
+   *
+   * This will override the name provided via {@link Tracer.startSpan}.
+   *
+   * Upon this update, any sampling behavior based on Span name will depend on
+   * the implementation.
+   *
+   * @param name the Span name.
+   */
+  updateName(name: string): this;
+  /**
+   * Marks the end of Span execution.
+   *
+   * Call to End of a Span MUST not have any effects on child spans. Those may
+   * still be running and can be ended later.
+   *
+   * Do not return `this`. The Span generally should not be used after it
+   * is ended so chaining is not desired in this context.
+   *
+   * @param [endTime] the time to set as Span's end time. If not provided,
+   *     use the current time as the span's end time.
+   */
+  end(endTime?: TimeInput): void;
+  /**
+   * Returns the flag whether this span will be recorded.
+   *
+   * @returns true if this Span is active and recording information like events
+   *     with the `AddEvent` operation and attributes using `setAttributes`.
+   */
+  isRecording(): boolean;
+  /**
+   * Sets exception as a span event
+   * @param exception the exception the only accepted values are string or Error
+   * @param [time] the time to set as Span's event time. If not provided,
+   *     use the current time.
+   */
+  recordException(exception: Exception, time?: TimeInput): void;
+}
+/**
+ * @since 1.0.0
+ */
+declare enum SpanKind {
+  /** Default value. Indicates that the span is used internally. */
+  INTERNAL = 0,
+  /**
+   * Indicates that the span covers server-side handling of an RPC or other
+   * remote request.
+   */
+  SERVER = 1,
+  /**
+   * Indicates that the span covers the client-side wrapper around an RPC or
+   * other remote request.
+   */
+  CLIENT = 2,
+  /**
+   * Indicates that the span describes producer sending a message to a
+   * broker. Unlike client and server, there is no direct critical path latency
+   * relationship between producer and consumer spans.
+   */
+  PRODUCER = 3,
+  /**
+   * Indicates that the span describes consumer receiving a message from a
+   * broker. Unlike client and server, there is no direct critical path latency
+   * relationship between producer and consumer spans.
+   */
+  CONSUMER = 4,
+}
+/**
+ * Options needed for span creation
+ *
+ * @since 1.0.0
+ */
+interface SpanOptions {
+  /**
+   * The SpanKind of a span
+   * @default {@link SpanKind.INTERNAL}
+   */
+  kind?: SpanKind;
+  /** A span's attributes */
+  attributes?: Attributes;
+  /** {@link Link}s span to other spans */
+  links?: Link[];
+  /** A manually specified start time for the created `Span` object. */
+  startTime?: TimeInput;
+  /** The new span should be a root span. (Ignore parent from context). */
+  root?: boolean;
+}
+/**
+ * Tracer provides an interface for creating {@link Span}s.
+ *
+ * @since 1.0.0
+ */
+interface Tracer {
+  /**
+   * Starts a new {@link Span}. Start the span without setting it on context.
+   *
+   * This method do NOT modify the current Context.
+   *
+   * @param name The name of the span
+   * @param [options] SpanOptions used for span creation
+   * @param [context] Context to use to extract parent
+   * @returns Span The newly created span
+   * @example
+   *     const span = tracer.startSpan('op');
+   *     span.setAttribute('key', 'value');
+   *     span.end();
+   */
+  startSpan(name: string, options?: SpanOptions, context?: Context): Span;
+  /**
+   * Starts a new {@link Span} and calls the given function passing it the
+   * created span as first argument.
+   * Additionally the new span gets set in context and this context is activated
+   * for the duration of the function call.
+   *
+   * @param name The name of the span
+   * @param [options] SpanOptions used for span creation
+   * @param [context] Context to use to extract parent
+   * @param fn function called in the context of the span and receives the newly created span as an argument
+   * @returns return value of fn
+   * @example
+   *     const something = tracer.startActiveSpan('op', span => {
+   *       try {
+   *         do some work
+   *         span.setStatus({code: SpanStatusCode.OK});
+   *         return something;
+   *       } catch (err) {
+   *         span.setStatus({
+   *           code: SpanStatusCode.ERROR,
+   *           message: err.message,
+   *         });
+   *         throw err;
+   *       } finally {
+   *         span.end();
+   *       }
+   *     });
+   *
+   * @example
+   *     const span = tracer.startActiveSpan('op', span => {
+   *       try {
+   *         do some work
+   *         return span;
+   *       } catch (err) {
+   *         span.setStatus({
+   *           code: SpanStatusCode.ERROR,
+   *           message: err.message,
+   *         });
+   *         throw err;
+   *       }
+   *     });
+   *     do some more work
+   *     span.end();
+   */
+  startActiveSpan<F extends (span: Span) => unknown>(name: string, fn: F): ReturnType<F>;
+  startActiveSpan<F extends (span: Span) => unknown>(name: string, options: SpanOptions, fn: F): ReturnType<F>;
+  startActiveSpan<F extends (span: Span) => unknown>(name: string, options: SpanOptions, context: Context, fn: F): ReturnType<F>;
+}
+export { Attributes as A, Context as C, Tracer as T };

package/dist/packem_shared/twilioProvider-BxI0e6LX.js

@@ -0,0 +1 @@
+import n from"./RequiredOptionError-CuL42XRq.js";import{defineProvider as g}from"./defineProvider-C9q-7iwt.js";import{b as S,t as h}from"./credentials-CG0zkn-W.js";import{r as w}from"./http-BMYcUNBU.js";import{s as y,b as T}from"./sms-CU-OZvNU.js";const v="https://api.twilio.com",M=g(d=>{const e=d??{};if(!e.accountSid)throw new n("twilio","accountSid");if(!e.authToken)throw new n("twilio","authToken");const a=e.endpoint??v,c=e.retries??3,u=e.timeout??3e4,m=`${a}/2010-04-01/Accounts/${e.accountSid}/Messages.json`,l=S(e.accountSid,e.authToken),f=async(t,o)=>{const i=new URLSearchParams;i.set("To",t),i.set("Body",o.text);const r=o.from??e.from;if(e.messagingServiceSid)i.set("MessagingServiceSid",e.messagingServiceSid);else if(r)i.set("From",r);else return{error:"Missing sender: provide `from` on the payload or provider config",id:t,status:"failed"};for(const p of o.mediaUrls??[])i.append("MediaUrl",p);const s=await w(m,{body:i.toString(),headers:{Authorization:l,"Content-Type":"application/x-www-form-urlencoded"},method:"POST",timeout:u},c);return!s.success||!s.data?{error:s.error instanceof Error?s.error.message:"Request failed",id:t,status:"failed"}:s.data.status>=400?{error:s.data.body.error_message??`HTTP ${String(s.data.status)}`,id:t,status:"failed"}:{id:t,messageId:s.data.body.sid,status:"sent"}};return{channel:"sms",endpoint:a,features:{batchSending:!1,deliveryReceipts:!0,media:!0,scheduling:!0},id:"twilio",initialize:()=>{},isAvailable:()=>!!(e.accountSid&&e.authToken),options:e,send:async t=>{const o=await y(h(t.to),async i=>f(i,t));return T("twilio",o)},validateCredentials:()=>!!(e.accountSid&&e.authToken)}});export{M as default};

package/dist/packem_shared/twilioWebhook-F0mTmGXD.js

@@ -0,0 +1 @@
+import{hmacBase64 as u,timingSafeEqual as c}from"./hmacBase64-BhhoX0uo.js";import{getHeader as o}from"./getHeader-C_gkdnMQ.js";const f="X-Twilio-Signature",m={delivered:"delivered",failed:"failed",queued:"queued",sending:"queued",sent:"sent",undelivered:"failed"},S=(i,e)=>{const r=Object.keys(e).toSorted((a,s)=>a.localeCompare(s));let t=i;for(const a of r)t+=`${a}${e[a]??""}`;return t},n=i=>{const e={};return new URLSearchParams(i).forEach((r,t)=>{e[t]=r}),e},g={parse:i=>{const e=n(i),r=e.MessageStatus??e.SmsStatus??e.CallStatus;if(r===void 0)return;const t=m[r.toLowerCase()];return t===void 0?void 0:{channel:"sms",messageId:e.MessageSid??e.SmsSid??e.CallSid??"",provider:"twilio",recipient:e.To,timestamp:new Date,type:t}},verify:async(i,e,r)=>{if(r.trim()==="")return!1;const t=o(e,f),a=o(e,"x-twilio-signature-url");if(t===void 0||a===void 0)return!1;const s=n(i),d=S(a,s),l=await u(r,d,"SHA-1");return c(l,t)}};export{g as default,g as twilioWebhook};

package/dist/packem_shared/types.d-67TogK4k.d.ts

@@ -0,0 +1,33 @@
+import { a as NotificationMessage } from "./notification.d-DFCVTods.js";
+/**
+* A queued notification job.
+*/
+interface QueueJob {
+  /** Number of delivery attempts so far. */
+  attempts: number;
+  /** Unique job id. */
+  id: string;
+  /** The multi-channel message to deliver. */
+  message: NotificationMessage;
+  /** Epoch ms before which the job must not be reserved. */
+  scheduledAt?: number;
+}
+/**
+* A durable notification queue. The default {@link import("./memory-queue").MemoryQueue}
+* is in-process; adapters (unstorage, BullMQ, ...) back it with external stores.
+*/
+interface NotificationQueue {
+  /** Acknowledges a reserved job as completed, removing it. */
+  ack: (id: string) => Promise<void> | void;
+  /** Adds a message to the queue, returning its job id. */
+  enqueue: (message: NotificationMessage, options?: {
+    scheduledAt?: number;
+  }) => Promise<string> | string;
+  /** Reserves the next due job, or undefined when none are ready. */
+  reserve: () => Promise<QueueJob | undefined> | (QueueJob | undefined);
+  /** Returns a reserved job to the queue, optionally delaying it. */
+  retry: (id: string, delayMs?: number) => Promise<void> | void;
+  /** Returns the number of pending jobs. */
+  size: () => Promise<number> | number;
+}
+export { NotificationQueue as N, QueueJob as Q };

package/dist/packem_shared/types.d-C1GoEAlI.d-Bv3grfyD.d.ts

@@ -0,0 +1,83 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+/** A value that may be returned directly or as a promise. */
+type MaybePromise<T> = Promise<T> | T;
+/**
+* A human-friendly duration. Either a raw millisecond count, a structured
+* `{ amount, unit }` pair, or a `{ cron }` expression resolved against "now".
+*/
+type Duration = number | {
+  amount: number;
+  unit: DurationUnit;
+} | {
+  cron: string;
+  tz?: string;
+};
+/** Units accepted by the structured {@link Duration} form. */
+type DurationUnit = "days" | "hours" | "milliseconds" | "minutes" | "ms" | "seconds" | "weeks";
+/** A JSON-serialisable snapshot of an `Error`, persisted in run history. */
+
+/**
+* The context handed to a workflow body. Every durable operation goes through
+* `ctx` so the engine can record, skip and resume it deterministically.
+*
+* IMPORTANT: any side effect that must run *exactly once* has to be wrapped in
+* {@link RunContext.step}. Code outside `step`/`sleep`/`waitForEvent` re-executes
+* on every replay.
+*/
+interface RunContext<PayloadT = unknown> {
+  /** The validated trigger payload. */
+  readonly payload: PayloadT;
+  /** The id of the current run. */
+  readonly runId: string;
+  /**
+  * Durably pause the run for a duration, then resume.
+  * @param id A stable, unique id for this sleep.
+  * @param duration How long to pause.
+  */
+  sleep: (id: string, duration: Duration) => Promise<void>;
+  /**
+  * Run a side effect exactly once. The result is recorded; on replay the
+  * recorded value is returned without re-executing the function.
+  * @param id A stable, unique id for this step within the workflow.
+  * @param function_ The side effect to run.
+  */
+  step: <T>(id: string, function_: () => MaybePromise<T>) => Promise<T>;
+  /**
+  * Durably suspend until an external event is delivered via
+  * `runtime.signal(runId, name, payload)`, or the optional timeout elapses.
+  * @param id A stable, unique id for this wait.
+  * @param name The event name to wait for.
+  * @param options Optional settings for the wait.
+  * @param options.timeout How long to wait before resolving to `undefined`.
+  * @returns The signalled payload, or `undefined` on timeout.
+  */
+  waitForEvent: <T = unknown>(id: string, name: string, options?: {
+    timeout?: Duration;
+  }) => Promise<T | undefined>;
+}
+/** The body of a workflow: an async function driven by {@link RunContext}. */
+type WorkflowRun<PayloadT, OutputT> = (context: RunContext<PayloadT>) => MaybePromise<OutputT>;
+/** Options accepted by `defineWorkflow`. */
+interface WorkflowConfig<PayloadT, OutputT> {
+  /** Unique id of the workflow, used as the namespace for run ids and storage. */
+  id: string;
+  /** Optional Standard Schema validating (and typing) the trigger payload. */
+  payload?: StandardSchemaV1<unknown, PayloadT>;
+  /** The workflow body. */
+  run: WorkflowRun<PayloadT, OutputT>;
+  /** Optional free-form tags for routing/observability. */
+  tags?: string[];
+}
+/** A defined workflow: the config plus the validated payload-schema accessor. */
+interface WorkflowDefinition<PayloadT = unknown, OutputT = unknown> extends WorkflowConfig<PayloadT, OutputT> {
+  /** Validate (and parse) an unknown input against the payload schema. */
+  parsePayload: (input: unknown) => Promise<PayloadT>;
+  /** Brand marking this object as a defined workflow. */
+  readonly [WORKFLOW_BRAND]: true;
+}
+/**
+* The persisted form of a run. `snapshot` is the opaque XState persisted
+* snapshot; `status`, `wakeAt` and `eventName` are denormalised so a store can
+* answer {@link WorkflowStore.due} and signal lookups without parsing it.
+*/
+export { Duration as D, MaybePromise as M, WorkflowConfig as W, WorkflowDefinition as a };

package/dist/packem_shared/types.d-CximoA8M.d.ts

@@ -0,0 +1,29 @@
+import { C as ChannelType, B as BaseNotificationPayload, a as NotificationResult, R as Result } from "./types.d-GUzX1jTk.js";
+/**
+* Context passed through the middleware chain for a single send.
+*/
+interface SendContext {
+  /** The channel being sent on. */
+  channel: ChannelType;
+  /** The (possibly mutated) payload. */
+  payload: BaseNotificationPayload;
+  /** The provider id handling the send. */
+  provider: string;
+}
+/**
+* The terminal send function and the type middleware wrap.
+*/
+type SendFunction = (context: SendContext) => Promise<Result<NotificationResult>>;
+/**
+* A middleware wraps a {@link SendFunction}. The first registered middleware is the
+* outermost wrapper (runs first on the way in, last on the way out).
+*/
+type Middleware = (context: SendContext, next: SendFunction) => Promise<Result<NotificationResult>>;
+/**
+* Composes middleware around a terminal send function.
+* @param middlewares Middleware in registration order.
+* @param terminal The terminal send function.
+* @returns A single composed send function.
+*/
+declare const composeMiddleware: (middlewares: Middleware[], terminal: SendFunction) => SendFunction;
+export { Middleware as M, SendContext as S, SendFunction as a, composeMiddleware as c };