Skip to main content
On this pageFunctions

Ui/Toast

Functions

make

functionsource
/** Creates a completed Toast Block for one payload Schema. */
<A, I>(payloadSchema: Codec<A, I>): Completed<A, I>

swipeOffset

functionsource
/**
 * Horizontal offset in pixels for an entry's swipe state. `Dragging`
 *  reports the distance travelled from the press point; `Dismissing` reports
 *  the offset the release left behind; `Idle` and `Settling` report zero.
 */
(swipeState: {
  _tag: "Idle"
} | {
  _tag: "Dragging"
  currentX: number
  pointerId: number
  startX: number
} | {
  _tag: "Settling"
  offsetX: number
} | {
  _tag: "Dismissing"
  direction: "Left" | "Right"
  offsetX: number
}): number

Types

EntryHandlers

typesource
/**
 * Handlers passed to `entryToView`. Spread `dismiss` onto a close button's
 *  attributes to dispatch `Dismissed` for this entry.
 */
type EntryHandlers = Readonly<{
  dismiss: ReadonlyArray<ChildAttribute>
}>

InitConfig

typesource
/**
 * Configuration for creating a Toast container Model. `defaultDuration` applies
 * to `show` calls without an explicit duration, unless `sticky: true` disables
 * auto-dismissal. Accepts any Effect Duration input; bare numbers are milliseconds.
 */
type InitConfig = Readonly<{
  defaultDuration: Duration.Input
  id: string
  swipeToDismiss: SwipeToDismissConfig
}>

ShowInput

typesource
/**
 * Input for the exposed `show` operation. `payload` is the consumer-defined content shape for an
 *  entry. Omit `duration` to use the container's `defaultDuration`; pass
 *  `sticky: true` to skip auto-dismiss entirely.
 */
type ShowInput = Readonly<{
  duration: Duration.Input
  payload: A
  sticky: boolean
  variant: Variant
}>

SwipeToDismissConfig

typesource
/**
 * Opt-in configuration for swipe-to-dismiss. Without `swipeToDismiss`,
 *  the view attaches no pointer handler and swipe Messages do nothing.
 *  Pass `{}` for the default rightward swipe, `{ threshold }` to change
 *  the distance, or `{ direction: 'Left' }` to swipe left.
 */
type SwipeToDismissConfig = Readonly<{
  direction: SwipeDirection
  threshold: number
}>

Interfaces

Completed

interfacesource
/** A completed Toast Block refined to one payload Schema. */
interface Completed {
  __blockHandlerRequirements: never
  [CompletionTypeId]: true
  [DefaultViewTypeId]: OwnedAuthoredView<BlockView<{
    defaultDuration: Duration
    entries: readonly Array<{
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      isHovered: boolean
      maybeDuration: Option<Duration>
      payload: A
      pendingDismissVersion: number
      swipeState: {
        _tag: "Idle"
      } | {
        _tag: "Dragging"
        currentX: number
        pointerId: number
        startX: number
      } | {
        _tag: "Settling"
        offsetX: number
      } | {
        _tag: "Dismissing"
        direction: "Left" | "Right"
        offsetX: number
      }
      swipeVersion: number
      variant: "Error" | "Info" | "Success" | "Warning"
    }>
    id: string
    maybeSwipeConfig: Option<{
      direction: "Left" | "Right"
      threshold: number
    }>
    nextEntryKey: number
  }, {
    _tag: "RequestedDismissAll"
  } | {
    _tag: "PressedEscape"
  } | Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    key: string
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "Animation"
  }> | {
    _tag: "RequestedShow"
    isSticky: boolean
    maybeDuration: Option<Duration>
    payload: A
    variant: "Error" | "Info" | "Success" | "Warning"
  } | {
    _tag: "RequestedDismiss"
    entryId: string
  } | {
    _tag: "Dismissed"
    entryId: string
  } | {
    _tag: "CompletedWaitBeforeDismissal"
    entryId: string
    version: number
  } | {
    _tag: "HoveredEntry"
    entryId: string
  } | {
    _tag: "LeftEntry"
    entryId: string
  } | {
    _tag: "PressedEntryPointer"
    clientX: number
    entryId: string
    pointerId: number
  } | {
    _tag: "MovedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "ReleasedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "CancelledSwipe"
    pointerId: number
  } | {
    _tag: "CompletedWaitForSwipeSettled"
    entryId: string
    version: number
  } | {
    _tag: "Added"
    entry: {
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      isHovered: boolean
      maybeDuration: Option<Duration>
      payload: A
      pendingDismissVersion: number
      swipeState: {
        _tag: "Idle"
      } | {
        _tag: "Dragging"
        currentX: number
        pointerId: number
        startX: number
      } | {
        _tag: "Settling"
        offsetX: number
      } | {
        _tag: "Dismissing"
        direction: "Left" | "Right"
        offsetX: number
      }
      swipeVersion: number
      variant: "Error" | "Info" | "Success" | "Warning"
    }
  }, Readonly<{
    ariaLabel: string
    containerClassName: string
    entryClassName: string
    entryToView: (entry: {
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      isHovered: boolean
      maybeDuration: Option<Duration>
      payload: A
      pendingDismissVersion: number
      swipeState: {
        _tag: "Idle"
      } | {
        _tag: "Dragging"
        currentX: number
        pointerId: number
        startX: number
      } | {
        _tag: "Settling"
        offsetX: number
      } | {
        _tag: "Dismissing"
        direction: "Left" | "Right"
        offsetX: number
      }
      swipeVersion: number
      variant: "Error" | "Info" | "Success" | "Warning"
    }, handlers: EntryHandlers) => Html
    position: "TopLeft" | "TopCenter" | "TopRight" | "BottomLeft" | "BottomCenter" | "BottomRight"
  }>, Readonly<{
    __blockBindingRequirement: Readonly<{
      block: BlockValue extends Readonly<{
        mounts: infer Mounts
      }>
        ? Readonly<{
          mountRequirements: () => unknown extends unknown
            ? unknown
            : unknown
          owner: BlockValue extends Readonly<unknown>
            ? OwnerValue
            : unknown
        }>
        : never
      generatedSchema: () => GeneratedSchema
      placement: Placement
    }>
  }>>, Owner<"Toast", true>>
  [LocalEffectsLayerTypeId]: Layer<Handler<"Toast/WaitForSwipeSettled", {
    entryId: string
    version: number
  }, {
    _tag: "CompletedWaitForSwipeSettled"
    entryId: string
    version: number
  }> | Handler<"Toast/WaitBeforeDismissal", {
    duration: Duration
    entryId: string
    version: number
  }, {
    _tag: "CompletedWaitBeforeDismissal"
    entryId: string
    version: number
  }> | Handler<"Toast/SwipePointer", {
    isAnyDragging: boolean
    isSwipeEnabled: boolean
  }, {
    _tag: "MovedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "ReleasedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "CancelledSwipe"
    pointerId: number
  }> | Handler<"Toast/SwipeEscape", {
    isAnyDragging: boolean
    isSwipeEnabled: boolean
  }, {
    _tag: "PressedEscape"
  }>, never>
  [LocalMountsTypeId]: readonly []
  bindings: readonly [
    SelectedChildBinding<AssemblyWithViewAndOutMessage<Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
    }>, () => AssemblyDraft<CompletedBlockWithViewAndOutMessage<Owner<"Animation", true>, Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
    }>, MessageUnion<{
      CompletedWaitForPaint: {
        generation: Number
      }
      EndedAnimation: {
        generation: Number
      }
      Hid: {}
      RequestedFinish: {
        generation: Number
      }
      RequestedHide: {}
      RequestedImmediateReset: {}
      RequestedResume: {}
      RequestedShow: {}
      RequestedToggle: {}
      RequestedWaitForLeaveSettlement: {}
      Showed: {}
    }>, MessageUnion<{
      StartedLeaveAnimating: {
        generation: Number
      }
      TransitionedOut: {}
    }>, readonly [], readonly [], Readonly<{
      EffectsLayer: Layer<Handler<unknown, unknown, unknown> | Handler<unknown, unknown, unknown>, never, never>
      init: (args: [config: Readonly<unknown>]) => Return<{
        id: unknown
        isShowing: unknown
        transitionGeneration: unknown
        transitionState: unknown
      }, unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown, never>
      operations: Readonly<{
        requestFinish: (model: unknown, args: unknown) => unknown
        requestHide: (model: unknown, args: unknown) => unknown
        requestImmediateReset: (model: unknown, args: unknown) => unknown
        requestResume: (model: unknown, args: unknown) => unknown
        requestShow: (model: unknown, args: unknown) => unknown
        requestToggle: (model: unknown, args: unknown) => unknown
        requestWaitForLeaveSettlement: (model: unknown, args: unknown) => unknown
      }>
      update: (model: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: unknown | unknown | unknown | unknown | unknown
      }, message: {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
        generation: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
        generation: unknown
      } | {
        _tag: unknown
        generation: unknown
      }) => ReturnWithOutMessage<{
        id: unknown
        isShowing: unknown
        transitionGeneration: unknown
        transitionState: unknown
      }, unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown, unknown | unknown, unknown | unknown>
      view: OwnedAuthoredView<BlockView<{
        id: unknown
        isShowing: unknown
        transitionGeneration: unknown
        transitionState: unknown
      }, unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown, Readonly<unknown>, never>, Owner<"Animation", true>, {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: unknown | unknown | unknown | unknown | unknown
      }, {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
        generation: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
        generation: unknown
      } | {
        _tag: unknown
        generation: unknown
      }, never>
    }>>>>, Struct<{
      defaultDuration: DurationFromMillis
      entries: $Array<Struct<{
        animation: Struct<{
          id: String
          isShowing: Boolean
          transitionGeneration: Number
          transitionState: Literals<readonly [unknown, unknown, unknown, unknown, unknown]>
        }>
        id: String
        isHovered: Boolean
        maybeDuration: Option<DurationFromMillis>
        payload: Codec<A, I, never, never>
        pendingDismissVersion: Number
        swipeState: TaggedUnion<{
          Dismissing: {
            direction: Literals<unknown>
            offsetX: Number
          }
          Dragging: {
            currentX: Number
            pointerId: Number
            startX: Number
          }
          Idle: {}
          Settling: {
            offsetX: Number
          }
        }>
        swipeVersion: Number
        variant: Literals<readonly ["Info", "Success", "Warning", "Error"]>
      }>>
      id: String
      maybeSwipeConfig: Option<Struct<{
        direction: Literals<readonly ["Left", "Right"]>
        threshold: Number
      }>>
      nextEntryKey: Number
    }>, MessageUnion<{
      Added: {
        entry: Struct<{
          animation: Struct<{
            id: String
            isShowing: Boolean
            transitionGeneration: Number
            transitionState: Literals<readonly [unknown, unknown, unknown, unknown, unknown]>
          }>
          id: String
          isHovered: Boolean
          maybeDuration: Option<DurationFromMillis>
          payload: Codec<A, I, never, never>
          pendingDismissVersion: Number
          swipeState: TaggedUnion<{
            Dismissing: {
              direction: Literals<unknown>
              offsetX: Number
            }
            Dragging: {
              currentX: Number
              pointerId: Number
              startX: Number
            }
            Idle: {}
            Settling: {
              offsetX: Number
            }
          }>
          swipeVersion: Number
          variant: Literals<readonly ["Info", "Success", "Warning", "Error"]>
        }>
      }
      CancelledSwipe: {
        pointerId: Number
      }
      CompletedWaitBeforeDismissal: {
        entryId: String
        version: Number
      }
      CompletedWaitForSwipeSettled: {
        entryId: String
        version: Number
      }
      Dismissed: {
        entryId: String
      }
      HoveredEntry: {
        entryId: String
      }
      LeftEntry: {
        entryId: String
      }
      MovedSwipePointer: {
        clientX: Number
        pointerId: Number
      }
      PressedEntryPointer: {
        clientX: Number
        entryId: String
        pointerId: Number
      }
      PressedEscape: {}
      ReleasedSwipePointer: {
        clientX: Number
        pointerId: Number
      }
      RequestedDismiss: {
        entryId: String
      }
      RequestedDismissAll: {}
      RequestedShow: {
        isSticky: Boolean
        maybeDuration: Option<DurationFromMillis>
        payload: Codec<A, I, never, never>
        variant: Literals<readonly ["Info", "Success", "Warning", "Error"]>
      }
    }>, MessageUnion<{
      DismissedToast: {
        payload: Codec<A, I, never, never>
      }
    }>, {
      childField: "animation"
      field: "entries"
      key: "id"
    }, never, {
      fold: (entryId: string, outMessage: {
        _tag: "StartedLeaveAnimating"
        generation: number
      } | {
        _tag: "TransitionedOut"
      }) => DefinedCaseSteps<{
        defaultDuration: Duration
        entries: readonly Array<{
          animation: {
            id: string
            isShowing: boolean
            transitionGeneration: number
            transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
          }
          id: string
          isHovered: boolean
          maybeDuration: Option<Duration>
          payload: A
          pendingDismissVersion: number
          swipeState: {
            _tag: "Idle"
          } | {
            _tag: "Dragging"
            currentX: number
            pointerId: number
            startX: number
          } | {
            _tag: "Settling"
            offsetX: number
          } | {
            _tag: "Dismissing"
            direction: unknown | unknown
            offsetX: number
          }
          swipeVersion: number
          variant: "Error" | "Info" | "Success" | "Warning"
        }>
        id: string
        maybeSwipeConfig: Option<{
          direction: "Left" | "Right"
          threshold: number
        }>
        nextEntryKey: number
      }, {
        StartedLeaveAnimating: () => (model: {
          defaultDuration: Duration
          entries: readonly Array<unknown>
          id: string
          maybeSwipeConfig: Option<unknown>
          nextEntryKey: number
        } & GraphCapability<{
          defaultDuration: unknown
          entries: unknown
          id: unknown
          maybeSwipeConfig: unknown
          nextEntryKey: unknown
        }, Readonly<unknown>>) => ResultRecipe<{
          defaultDuration: Duration
          entries: readonly Array<unknown>
          id: string
          maybeSwipeConfig: Option<unknown>
          nextEntryKey: number
        }, Readonly<{
          _tag: unknown
          generation: unknown
          key: unknown
          message: unknown
          placement: unknown
        }>, never, Scoped<unknown, unknown> | Scoped<unknown, unknown>, Readonly<unknown> | DeferredResultEvidence<unknown>>
        TransitionedOut: () => NoInfer<DefinedStep<{
          defaultDuration: Duration
          entries: readonly Array<unknown>
          id: string
          maybeSwipeConfig: Option<unknown>
          nextEntryKey: number
        }, {
          _tag: unknown
        } | {
          _tag: unknown
        } | {
          _tag: unknown
          isSticky: unknown
          maybeDuration: unknown
          payload: unknown
          variant: unknown
        } | {
          _tag: unknown
          entryId: unknown
        } | {
          _tag: unknown
          entryId: unknown
        } | {
          _tag: unknown
          entryId: unknown
          version: unknown
        } | {
          _tag: unknown
          entryId: unknown
        } | {
          _tag: unknown
          entryId: unknown
        } | {
          _tag: unknown
          clientX: unknown
          entryId: unknown
          pointerId: unknown
        } | {
          _tag: unknown
          clientX: unknown
          pointerId: unknown
        } | {
          _tag: unknown
          clientX: unknown
          pointerId: unknown
        } | {
          _tag: unknown
          pointerId: unknown
        } | {
          _tag: unknown
          entryId: unknown
          version: unknown
        } | {
          _tag: unknown
          entry: unknown
        }, readonly [], {
          _tag: "DismissedToast"
          payload: A
        }, never, never, "None", never>>
      }>
    }>
  ]
  EffectsLayer: CompleteEffectsLayer<Layer<Handler<"Toast/WaitForSwipeSettled", {
    entryId: string
    version: number
  }, {
    _tag: "CompletedWaitForSwipeSettled"
    entryId: string
    version: number
  }> | Handler<"Toast/WaitBeforeDismissal", {
    duration: Duration
    entryId: string
    version: number
  }, {
    _tag: "CompletedWaitBeforeDismissal"
    entryId: string
    version: number
  }> | Handler<"Toast/SwipePointer", {
    isAnyDragging: boolean
    isSwipeEnabled: boolean
  }, {
    _tag: "MovedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "ReleasedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "CancelledSwipe"
    pointerId: number
  }> | Handler<"Toast/SwipeEscape", {
    isAnyDragging: boolean
    isSwipeEnabled: boolean
  }, {
    _tag: "PressedEscape"
  }>, never, never>, readonly [
    SelectedChildBinding<AssemblyWithViewAndOutMessage<Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
    }>, () => AssemblyDraft<CompletedBlockWithViewAndOutMessage<Owner<"Animation", true>, Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly [unknown, unknown, unknown, unknown, unknown]>
    }>, MessageUnion<{
      CompletedWaitForPaint: {
        generation: Number
      }
      EndedAnimation: {
        generation: Number
      }
      Hid: {}
      RequestedFinish: {
        generation: Number
      }
      RequestedHide: {}
      RequestedImmediateReset: {}
      RequestedResume: {}
      RequestedShow: {}
      RequestedToggle: {}
      RequestedWaitForLeaveSettlement: {}
      Showed: {}
    }>, MessageUnion<{
      StartedLeaveAnimating: {
        generation: Number
      }
      TransitionedOut: {}
    }>, readonly [], readonly [], Readonly<{
      EffectsLayer: Layer<unknown | unknown, never, never>
      init: (args: [config: unknown]) => Return<unknown, unknown, unknown>
      operations: Readonly<{
        requestFinish: unknown
        requestHide: unknown
        requestImmediateReset: unknown
        requestResume: unknown
        requestShow: unknown
        requestToggle: unknown
        requestWaitForLeaveSettlement: unknown
      }>
      update: (model: {
        id: unknown
        isShowing: unknown
        transitionGeneration: unknown
        transitionState: unknown
      }, message: unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown) => ReturnWithOutMessage<unknown, unknown, unknown, unknown>
      view: OwnedAuthoredView<BlockView<unknown, unknown, unknown, unknown>, Owner<unknown, unknown>, {
        id: unknown
        isShowing: unknown
        transitionGeneration: unknown
        transitionState: unknown
      }, unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown, never>
    }>>>>, Struct<{
      defaultDuration: DurationFromMillis
      entries: $Array<Struct<{
        animation: Struct<{
          id: String
          isShowing: Boolean
          transitionGeneration: Number
          transitionState: Literals<unknown>
        }>
        id: String
        isHovered: Boolean
        maybeDuration: Option<DurationFromMillis>
        payload: Codec<A, I, never, never>
        pendingDismissVersion: Number
        swipeState: TaggedUnion<{
          Dismissing: {
            direction: unknown
            offsetX: unknown
          }
          Dragging: {
            currentX: unknown
            pointerId: unknown
            startX: unknown
          }
          Idle: {}
          Settling: {
            offsetX: unknown
          }
        }>
        swipeVersion: Number
        variant: Literals<readonly ["Info", "Success", "Warning", "Error"]>
      }>>
      id: String
      maybeSwipeConfig: Option<Struct<{
        direction: Literals<readonly ["Left", "Right"]>
        threshold: Number
      }>>
      nextEntryKey: Number
    }>, MessageUnion<{
      Added: {
        entry: Struct<{
          animation: Struct<{
            id: String
            isShowing: Boolean
            transitionGeneration: Number
            transitionState: Literals<unknown>
          }>
          id: String
          isHovered: Boolean
          maybeDuration: Option<DurationFromMillis>
          payload: Codec<A, I, never, never>
          pendingDismissVersion: Number
          swipeState: TaggedUnion<{
            Dismissing: {
              direction: unknown
              offsetX: unknown
            }
            Dragging: {
              currentX: unknown
              pointerId: unknown
              startX: unknown
            }
            Idle: {}
            Settling: {
              offsetX: unknown
            }
          }>
          swipeVersion: Number
          variant: Literals<readonly ["Info", "Success", "Warning", "Error"]>
        }>
      }
      CancelledSwipe: {
        pointerId: Number
      }
      CompletedWaitBeforeDismissal: {
        entryId: String
        version: Number
      }
      CompletedWaitForSwipeSettled: {
        entryId: String
        version: Number
      }
      Dismissed: {
        entryId: String
      }
      HoveredEntry: {
        entryId: String
      }
      LeftEntry: {
        entryId: String
      }
      MovedSwipePointer: {
        clientX: Number
        pointerId: Number
      }
      PressedEntryPointer: {
        clientX: Number
        entryId: String
        pointerId: Number
      }
      PressedEscape: {}
      ReleasedSwipePointer: {
        clientX: Number
        pointerId: Number
      }
      RequestedDismiss: {
        entryId: String
      }
      RequestedDismissAll: {}
      RequestedShow: {
        isSticky: Boolean
        maybeDuration: Option<DurationFromMillis>
        payload: Codec<A, I, never, never>
        variant: Literals<readonly ["Info", "Success", "Warning", "Error"]>
      }
    }>, MessageUnion<{
      DismissedToast: {
        payload: Codec<A, I, never, never>
      }
    }>, {
      childField: "animation"
      field: "entries"
      key: "id"
    }, never, {
      fold: (entryId: string, outMessage: {
        _tag: "StartedLeaveAnimating"
        generation: number
      } | {
        _tag: "TransitionedOut"
      }) => DefinedCaseSteps<{
        defaultDuration: Duration
        entries: readonly Array<{
          animation: {
            id: string
            isShowing: boolean
            transitionGeneration: number
            transitionState: unknown | unknown | unknown | unknown | unknown
          }
          id: string
          isHovered: boolean
          maybeDuration: Option<Duration>
          payload: A
          pendingDismissVersion: number
          swipeState: {
            _tag: unknown
          } | {
            _tag: unknown
            currentX: unknown
            pointerId: unknown
            startX: unknown
          } | {
            _tag: unknown
            offsetX: unknown
          } | {
            _tag: unknown
            direction: unknown
            offsetX: unknown
          }
          swipeVersion: number
          variant: "Error" | "Info" | "Success" | "Warning"
        }>
        id: string
        maybeSwipeConfig: Option<{
          direction: "Left" | "Right"
          threshold: number
        }>
        nextEntryKey: number
      }, {
        StartedLeaveAnimating: () => (model: {
          defaultDuration: unknown
          entries: unknown
          id: unknown
          maybeSwipeConfig: unknown
          nextEntryKey: unknown
        } & GraphCapability<unknown, unknown>) => ResultRecipe<{
          defaultDuration: unknown
          entries: unknown
          id: unknown
          maybeSwipeConfig: unknown
          nextEntryKey: unknown
        }, Readonly<unknown>, never, unknown | unknown, unknown | unknown>
        TransitionedOut: () => NoInfer<DefinedStep<{
          defaultDuration: unknown
          entries: unknown
          id: unknown
          maybeSwipeConfig: unknown
          nextEntryKey: unknown
        }, unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown, readonly [], {
          _tag: unknown
          payload: unknown
        }, never, never, "None", never>>
      }>
    }>
  ]>
  hostHandlers: readonly []
  init: (args: [
    config: Readonly<{
      defaultDuration: Input
      id: string
      swipeToDismiss: Readonly<{
        direction: "Left" | "Right"
        threshold: number
      }>
    }>
  ]) => Return<{
    defaultDuration: Duration
    entries: readonly Array<{
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      isHovered: boolean
      maybeDuration: Option<Duration>
      payload: A
      pendingDismissVersion: number
      swipeState: {
        _tag: "Idle"
      } | {
        _tag: "Dragging"
        currentX: number
        pointerId: number
        startX: number
      } | {
        _tag: "Settling"
        offsetX: number
      } | {
        _tag: "Dismissing"
        direction: "Left" | "Right"
        offsetX: number
      }
      swipeVersion: number
      variant: "Error" | "Info" | "Success" | "Warning"
    }>
    id: string
    maybeSwipeConfig: Option<{
      direction: "Left" | "Right"
      threshold: number
    }>
    nextEntryKey: number
  }, {
    _tag: "RequestedDismissAll"
  } | {
    _tag: "PressedEscape"
  } | Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    key: string
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "Animation"
  }> | {
    _tag: "RequestedShow"
    isSticky: boolean
    maybeDuration: Option<Duration>
    payload: A
    variant: "Error" | "Info" | "Success" | "Warning"
  } | {
    _tag: "RequestedDismiss"
    entryId: string
  } | {
    _tag: "Dismissed"
    entryId: string
  } | {
    _tag: "CompletedWaitBeforeDismissal"
    entryId: string
    version: number
  } | {
    _tag: "HoveredEntry"
    entryId: string
  } | {
    _tag: "LeftEntry"
    entryId: string
  } | {
    _tag: "PressedEntryPointer"
    clientX: number
    entryId: string
    pointerId: number
  } | {
    _tag: "MovedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "ReleasedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "CancelledSwipe"
    pointerId: number
  } | {
    _tag: "CompletedWaitForSwipeSettled"
    entryId: string
    version: number
  } | {
    _tag: "Added"
    entry: {
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      isHovered: boolean
      maybeDuration: Option<Duration>
      payload: A
      pendingDismissVersion: number
      swipeState: {
        _tag: "Idle"
      } | {
        _tag: "Dragging"
        currentX: number
        pointerId: number
        startX: number
      } | {
        _tag: "Settling"
        offsetX: number
      } | {
        _tag: "Dismissing"
        direction: "Left" | "Right"
        offsetX: number
      }
      swipeVersion: number
      variant: "Error" | "Info" | "Success" | "Warning"
    }
  }, never>
  makeView: DefineView<Owner<"Toast", true>, {
    defaultDuration: Duration
    entries: readonly Array<{
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      isHovered: boolean
      maybeDuration: Option<Duration>
      payload: A
      pendingDismissVersion: number
      swipeState: {
        _tag: "Idle"
      } | {
        _tag: "Dragging"
        currentX: number
        pointerId: number
        startX: number
      } | {
        _tag: "Settling"
        offsetX: number
      } | {
        _tag: "Dismissing"
        direction: "Left" | "Right"
        offsetX: number
      }
      swipeVersion: number
      variant: "Error" | "Info" | "Success" | "Warning"
    }>
    id: string
    maybeSwipeConfig: Option<{
      direction: "Left" | "Right"
      threshold: number
    }>
    nextEntryKey: number
  }>
  managedResources: Readonly<Record<never, never>> & Namespaced<"Animation", Readonly<Record<never, never>>>
  Message: Codec<{
    _tag: "RequestedDismissAll"
  } | {
    _tag: "PressedEscape"
  } | Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    key: string
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "Animation"
  }> | {
    _tag: "RequestedShow"
    isSticky: boolean
    maybeDuration: Option<Duration>
    payload: A
    variant: "Error" | "Info" | "Success" | "Warning"
  } | {
    _tag: "RequestedDismiss"
    entryId: string
  } | {
    _tag: "Dismissed"
    entryId: string
  } | {
    _tag: "CompletedWaitBeforeDismissal"
    entryId: string
    version: number
  } | {
    _tag: "HoveredEntry"
    entryId: string
  } | {
    _tag: "LeftEntry"
    entryId: string
  } | {
    _tag: "PressedEntryPointer"
    clientX: number
    entryId: string
    pointerId: number
  } | {
    _tag: "MovedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "ReleasedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "CancelledSwipe"
    pointerId: number
  } | {
    _tag: "CompletedWaitForSwipeSettled"
    entryId: string
    version: number
  } | {
    _tag: "Added"
    entry: {
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      isHovered: boolean
      maybeDuration: Option<Duration>
      payload: A
      pendingDismissVersion: number
      swipeState: {
        _tag: "Idle"
      } | {
        _tag: "Dragging"
        currentX: number
        pointerId: number
        startX: number
      } | {
        _tag: "Settling"
        offsetX: number
      } | {
        _tag: "Dismissing"
        direction: "Left" | "Right"
        offsetX: number
      }
      swipeVersion: number
      variant: "Error" | "Info" | "Success" | "Warning"
    }
  }, Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    key: string
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "Animation"
  }> | {
    _tag: "PressedEscape"
  } | {
    _tag: "RequestedDismissAll"
  } | {
    _tag: "RequestedShow"
    isSticky: boolean
    maybeDuration: Option<number>
    payload: I
    variant: "Error" | "Info" | "Success" | "Warning"
  } | {
    _tag: "RequestedDismiss"
    entryId: string
  } | {
    _tag: "Dismissed"
    entryId: string
  } | {
    _tag: "CompletedWaitBeforeDismissal"
    entryId: string
    version: number
  } | {
    _tag: "HoveredEntry"
    entryId: string
  } | {
    _tag: "LeftEntry"
    entryId: string
  } | {
    _tag: "PressedEntryPointer"
    clientX: number
    entryId: string
    pointerId: number
  } | {
    _tag: "MovedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "ReleasedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "CancelledSwipe"
    pointerId: number
  } | {
    _tag: "CompletedWaitForSwipeSettled"
    entryId: string
    version: number
  } | {
    _tag: "Added"
    entry: {
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      isHovered: boolean
      maybeDuration: Option<number>
      payload: I
      pendingDismissVersion: number
      swipeState: {
        _tag: "Idle"
      } | {
        _tag: "Dragging"
        currentX: number
        pointerId: number
        startX: number
      } | {
        _tag: "Settling"
        offsetX: number
      } | {
        _tag: "Dismissing"
        direction: "Left" | "Right"
        offsetX: number
      }
      swipeVersion: number
      variant: "Error" | "Info" | "Success" | "Warning"
    }
  }, never, never> & LocalConstructors<MessageUnion<{
    Added: {
      entry: Struct<{
        animation: Struct<{
          id: String
          isShowing: Boolean
          transitionGeneration: Number
          transitionState: Literals<readonly [unknown, unknown, unknown, unknown, unknown]>
        }>
        id: String
        isHovered: Boolean
        maybeDuration: Option<DurationFromMillis>
        payload: Codec<A, I, never, never>
        pendingDismissVersion: Number
        swipeState: TaggedUnion<{
          Dismissing: {
            direction: Literals<unknown>
            offsetX: Number
          }
          Dragging: {
            currentX: Number
            pointerId: Number
            startX: Number
          }
          Idle: {}
          Settling: {
            offsetX: Number
          }
        }>
        swipeVersion: Number
        variant: Literals<readonly ["Info", "Success", "Warning", "Error"]>
      }>
    }
    CancelledSwipe: {
      pointerId: Number
    }
    CompletedWaitBeforeDismissal: {
      entryId: String
      version: Number
    }
    CompletedWaitForSwipeSettled: {
      entryId: String
      version: Number
    }
    Dismissed: {
      entryId: String
    }
    HoveredEntry: {
      entryId: String
    }
    LeftEntry: {
      entryId: String
    }
    MovedSwipePointer: {
      clientX: Number
      pointerId: Number
    }
    PressedEntryPointer: {
      clientX: Number
      entryId: String
      pointerId: Number
    }
    PressedEscape: {}
    ReleasedSwipePointer: {
      clientX: Number
      pointerId: Number
    }
    RequestedDismiss: {
      entryId: String
    }
    RequestedDismissAll: {}
    RequestedShow: {
      isSticky: Boolean
      maybeDuration: Option<DurationFromMillis>
      payload: Codec<A, I, never, never>
      variant: Literals<readonly ["Info", "Success", "Warning", "Error"]>
    }
  }>>
  Model: Struct
  mounts: readonly Array<never>
  operations: ProducedMember<Producer, "operations">
  OutMessage: MessageUnion<{
    DismissedToast: {
      payload: Codec<A, I, never, never>
    }
  }>
  owner: Owner<"Toast", true>
  provideHandlers: never
  replaceEffectsLayer: ReplaceEffectsLayer<Owner<"Toast", true>, Struct<{
    defaultDuration: DurationFromMillis
    entries: $Array<Struct<{
      animation: Struct<{
        id: String
        isShowing: Boolean
        transitionGeneration: Number
        transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
      }>
      id: String
      isHovered: Boolean
      maybeDuration: Option<DurationFromMillis>
      payload: Codec<A, I, never, never>
      pendingDismissVersion: Number
      swipeState: TaggedUnion<{
        Dismissing: {
          direction: Literals<readonly [unknown, unknown]>
          offsetX: Number
        }
        Dragging: {
          currentX: Number
          pointerId: Number
          startX: Number
        }
        Idle: {}
        Settling: {
          offsetX: Number
        }
      }>
      swipeVersion: Number
      variant: Literals<readonly ["Info", "Success", "Warning", "Error"]>
    }>>
    id: String
    maybeSwipeConfig: Option<Struct<{
      direction: Literals<readonly ["Left", "Right"]>
      threshold: Number
    }>>
    nextEntryKey: Number
  }>>
  subscriptions: Readonly<{
    swipeEscape: EntryWithoutKeepAlive<{
      defaultDuration: Duration
      entries: readonly Array<{
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        isHovered: boolean
        maybeDuration: Option<Duration>
        payload: A
        pendingDismissVersion: number
        swipeState: {
          _tag: "Idle"
        } | {
          _tag: "Dragging"
          currentX: number
          pointerId: number
          startX: number
        } | {
          _tag: "Settling"
          offsetX: number
        } | {
          _tag: "Dismissing"
          direction: unknown | unknown
          offsetX: number
        }
        swipeVersion: number
        variant: "Error" | "Info" | "Success" | "Warning"
      }>
      id: string
      maybeSwipeConfig: Option<{
        direction: "Left" | "Right"
        threshold: number
      }>
      nextEntryKey: number
    }, {
      _tag: "PressedEscape"
    }, {
      isAnyDragging: boolean
      isSwipeEnabled: boolean
    }, Handler<"Toast/SwipeEscape", {
      isAnyDragging: boolean
      isSwipeEnabled: boolean
    }, {
      _tag: "PressedEscape"
    }>> & Readonly<{
      messages: [CallableTaggedStruct<"PressedEscape", {}>]
      name: "Toast/SwipeEscape"
      toLayer: ToLayerWithoutKeepAlive<"Toast/SwipeEscape", {
        isAnyDragging: boolean
        isSwipeEnabled: boolean
      }, {
        _tag: "PressedEscape"
      }>
    }> & Readonly<{
      layer: Layer<Handler<"Toast/SwipeEscape", {
        isAnyDragging: boolean
        isSwipeEnabled: boolean
      }, {
        _tag: "PressedEscape"
      }>, never, never>
    }> & Subscription<{
      defaultDuration: Duration
      entries: readonly Array<{
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        isHovered: boolean
        maybeDuration: Option<Duration>
        payload: A
        pendingDismissVersion: number
        swipeState: {
          _tag: "Idle"
        } | {
          _tag: "Dragging"
          currentX: number
          pointerId: number
          startX: number
        } | {
          _tag: "Settling"
          offsetX: number
        } | {
          _tag: "Dismissing"
          direction: unknown | unknown
          offsetX: number
        }
        swipeVersion: number
        variant: "Error" | "Info" | "Success" | "Warning"
      }>
      id: string
      maybeSwipeConfig: Option<{
        direction: "Left" | "Right"
        threshold: number
      }>
      nextEntryKey: number
    }, {
      _tag: "RequestedDismissAll"
    } | {
      _tag: "PressedEscape"
    } | {
      _tag: "RequestedShow"
      isSticky: boolean
      maybeDuration: Option<Duration>
      payload: A
      variant: "Error" | "Info" | "Success" | "Warning"
    } | {
      _tag: "RequestedDismiss"
      entryId: string
    } | {
      _tag: "Dismissed"
      entryId: string
    } | {
      _tag: "CompletedWaitBeforeDismissal"
      entryId: string
      version: number
    } | {
      _tag: "HoveredEntry"
      entryId: string
    } | {
      _tag: "LeftEntry"
      entryId: string
    } | {
      _tag: "PressedEntryPointer"
      clientX: number
      entryId: string
      pointerId: number
    } | {
      _tag: "MovedSwipePointer"
      clientX: number
      pointerId: number
    } | {
      _tag: "ReleasedSwipePointer"
      clientX: number
      pointerId: number
    } | {
      _tag: "CancelledSwipe"
      pointerId: number
    } | {
      _tag: "CompletedWaitForSwipeSettled"
      entryId: string
      version: number
    } | {
      _tag: "Added"
      entry: {
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        isHovered: boolean
        maybeDuration: Option<Duration>
        payload: A
        pendingDismissVersion: number
        swipeState: {
          _tag: "Idle"
        } | {
          _tag: "Dragging"
          currentX: number
          pointerId: number
          startX: number
        } | {
          _tag: "Settling"
          offsetX: number
        } | {
          _tag: "Dismissing"
          direction: unknown | unknown
          offsetX: number
        }
        swipeVersion: number
        variant: "Error" | "Info" | "Success" | "Warning"
      }
    }, {
      isAnyDragging: boolean
      isSwipeEnabled: boolean
    }, Handler<"Toast/SwipeEscape", {
      isAnyDragging: boolean
      isSwipeEnabled: boolean
    }, {
      _tag: "PressedEscape"
    }>>
    swipePointer: EntryWithoutKeepAlive<{
      defaultDuration: Duration
      entries: readonly Array<{
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        isHovered: boolean
        maybeDuration: Option<Duration>
        payload: A
        pendingDismissVersion: number
        swipeState: {
          _tag: "Idle"
        } | {
          _tag: "Dragging"
          currentX: number
          pointerId: number
          startX: number
        } | {
          _tag: "Settling"
          offsetX: number
        } | {
          _tag: "Dismissing"
          direction: unknown | unknown
          offsetX: number
        }
        swipeVersion: number
        variant: "Error" | "Info" | "Success" | "Warning"
      }>
      id: string
      maybeSwipeConfig: Option<{
        direction: "Left" | "Right"
        threshold: number
      }>
      nextEntryKey: number
    }, {
      _tag: "MovedSwipePointer"
      clientX: number
      pointerId: number
    } | {
      _tag: "ReleasedSwipePointer"
      clientX: number
      pointerId: number
    } | {
      _tag: "CancelledSwipe"
      pointerId: number
    }, {
      isAnyDragging: boolean
      isSwipeEnabled: boolean
    }, Handler<"Toast/SwipePointer", {
      isAnyDragging: boolean
      isSwipeEnabled: boolean
    }, {
      _tag: "MovedSwipePointer"
      clientX: number
      pointerId: number
    } | {
      _tag: "ReleasedSwipePointer"
      clientX: number
      pointerId: number
    } | {
      _tag: "CancelledSwipe"
      pointerId: number
    }>> & Readonly<{
      messages: [
        CallableTaggedStruct<"MovedSwipePointer", {
          clientX: Number
          pointerId: Number
        }>,
        CallableTaggedStruct<"ReleasedSwipePointer", {
          clientX: Number
          pointerId: Number
        }>,
        CallableTaggedStruct<"CancelledSwipe", {
          pointerId: Number
        }>
      ]
      name: "Toast/SwipePointer"
      toLayer: ToLayerWithoutKeepAlive<"Toast/SwipePointer", {
        isAnyDragging: boolean
        isSwipeEnabled: boolean
      }, {
        _tag: "MovedSwipePointer"
        clientX: number
        pointerId: number
      } | {
        _tag: "ReleasedSwipePointer"
        clientX: number
        pointerId: number
      } | {
        _tag: "CancelledSwipe"
        pointerId: number
      }>
    }> & Readonly<{
      layer: Layer<Handler<"Toast/SwipePointer", {
        isAnyDragging: boolean
        isSwipeEnabled: boolean
      }, {
        _tag: "MovedSwipePointer"
        clientX: number
        pointerId: number
      } | {
        _tag: "ReleasedSwipePointer"
        clientX: number
        pointerId: number
      } | {
        _tag: "CancelledSwipe"
        pointerId: number
      }>, never, never>
    }> & Subscription<{
      defaultDuration: Duration
      entries: readonly Array<{
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        isHovered: boolean
        maybeDuration: Option<Duration>
        payload: A
        pendingDismissVersion: number
        swipeState: {
          _tag: "Idle"
        } | {
          _tag: "Dragging"
          currentX: number
          pointerId: number
          startX: number
        } | {
          _tag: "Settling"
          offsetX: number
        } | {
          _tag: "Dismissing"
          direction: unknown | unknown
          offsetX: number
        }
        swipeVersion: number
        variant: "Error" | "Info" | "Success" | "Warning"
      }>
      id: string
      maybeSwipeConfig: Option<{
        direction: "Left" | "Right"
        threshold: number
      }>
      nextEntryKey: number
    }, {
      _tag: "RequestedDismissAll"
    } | {
      _tag: "PressedEscape"
    } | {
      _tag: "RequestedShow"
      isSticky: boolean
      maybeDuration: Option<Duration>
      payload: A
      variant: "Error" | "Info" | "Success" | "Warning"
    } | {
      _tag: "RequestedDismiss"
      entryId: string
    } | {
      _tag: "Dismissed"
      entryId: string
    } | {
      _tag: "CompletedWaitBeforeDismissal"
      entryId: string
      version: number
    } | {
      _tag: "HoveredEntry"
      entryId: string
    } | {
      _tag: "LeftEntry"
      entryId: string
    } | {
      _tag: "PressedEntryPointer"
      clientX: number
      entryId: string
      pointerId: number
    } | {
      _tag: "MovedSwipePointer"
      clientX: number
      pointerId: number
    } | {
      _tag: "ReleasedSwipePointer"
      clientX: number
      pointerId: number
    } | {
      _tag: "CancelledSwipe"
      pointerId: number
    } | {
      _tag: "CompletedWaitForSwipeSettled"
      entryId: string
      version: number
    } | {
      _tag: "Added"
      entry: {
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        isHovered: boolean
        maybeDuration: Option<Duration>
        payload: A
        pendingDismissVersion: number
        swipeState: {
          _tag: "Idle"
        } | {
          _tag: "Dragging"
          currentX: number
          pointerId: number
          startX: number
        } | {
          _tag: "Settling"
          offsetX: number
        } | {
          _tag: "Dismissing"
          direction: unknown | unknown
          offsetX: number
        }
        swipeVersion: number
        variant: "Error" | "Info" | "Success" | "Warning"
      }
    }, {
      isAnyDragging: boolean
      isSwipeEnabled: boolean
    }, Handler<"Toast/SwipePointer", {
      isAnyDragging: boolean
      isSwipeEnabled: boolean
    }, {
      _tag: "MovedSwipePointer"
      clientX: number
      pointerId: number
    } | {
      _tag: "ReleasedSwipePointer"
      clientX: number
      pointerId: number
    } | {
      _tag: "CancelledSwipe"
      pointerId: number
    }>>
  }> & Namespaced<"Animation", Readonly<Record<never, never>>>
  test: Readonly<{
    drainEntry: DrainEntry<AssemblyWithViewAndOutMessage<Struct<{
      defaultDuration: DurationFromMillis
      entries: $Array<Struct<{
        animation: Struct<{
          id: unknown
          isShowing: unknown
          transitionGeneration: unknown
          transitionState: unknown
        }>
        id: String
        isHovered: Boolean
        maybeDuration: Option<DurationFromMillis>
        payload: Codec<A, I, never, never>
        pendingDismissVersion: Number
        swipeState: TaggedUnion<{
          Dismissing: unknown
          Dragging: unknown
          Idle: unknown
          Settling: unknown
        }>
        swipeVersion: Number
        variant: Literals<readonly [unknown, unknown, unknown, unknown]>
      }>>
      id: String
      maybeSwipeConfig: Option<Struct<{
        direction: Literals<readonly [unknown, unknown]>
        threshold: Number
      }>>
      nextEntryKey: Number
    }>, () => AssemblyDraft<CompletedBlockWithViewAndOutMessage<Owner<"Toast", true>, Struct<{
      defaultDuration: DurationFromMillis
      entries: $Array<Struct<unknown>>
      id: String
      maybeSwipeConfig: Option<Struct<unknown>>
      nextEntryKey: Number
    }>, Codec<{
      _tag: unknown
    } | {
      _tag: unknown
    } | Readonly<unknown> | {
      _tag: unknown
      isSticky: unknown
      maybeDuration: unknown
      payload: unknown
      variant: unknown
    } | {
      _tag: unknown
      entryId: unknown
    } | {
      _tag: unknown
      entryId: unknown
    } | {
      _tag: unknown
      entryId: unknown
      version: unknown
    } | {
      _tag: unknown
      entryId: unknown
    } | {
      _tag: unknown
      entryId: unknown
    } | {
      _tag: unknown
      clientX: unknown
      entryId: unknown
      pointerId: unknown
    } | {
      _tag: unknown
      clientX: unknown
      pointerId: unknown
    } | {
      _tag: unknown
      clientX: unknown
      pointerId: unknown
    } | {
      _tag: unknown
      pointerId: unknown
    } | {
      _tag: unknown
      entryId: unknown
      version: unknown
    } | {
      _tag: unknown
      entry: unknown
    }, Readonly<unknown> | {
      _tag: unknown
    } | {
      _tag: unknown
    } | {
      _tag: unknown
      isSticky: unknown
      maybeDuration: unknown
      payload: unknown
      variant: unknown
    } | {
      _tag: unknown
      entryId: unknown
    } | {
      _tag: unknown
      entryId: unknown
    } | {
      _tag: unknown
      entryId: unknown
      version: unknown
    } | {
      _tag: unknown
      entryId: unknown
    } | {
      _tag: unknown
      entryId: unknown
    } | {
      _tag: unknown
      clientX: unknown
      entryId: unknown
      pointerId: unknown
    } | {
      _tag: unknown
      clientX: unknown
      pointerId: unknown
    } | {
      _tag: unknown
      clientX: unknown
      pointerId: unknown
    } | {
      _tag: unknown
      pointerId: unknown
    } | {
      _tag: unknown
      entryId: unknown
      version: unknown
    } | {
      _tag: unknown
      entry: unknown
    }, never, never> & LocalConstructors<MessageUnion<{
      Added: unknown
      CancelledSwipe: unknown
      CompletedWaitBeforeDismissal: unknown
      CompletedWaitForSwipeSettled: unknown
      Dismissed: unknown
      HoveredEntry: unknown
      LeftEntry: unknown
      MovedSwipePointer: unknown
      PressedEntryPointer: unknown
      PressedEscape: unknown
      ReleasedSwipePointer: unknown
      RequestedDismiss: unknown
      RequestedDismissAll: unknown
      RequestedShow: unknown
    }>>, MessageUnion<{
      DismissedToast: {
        payload: Codec<unknown, unknown, unknown, unknown>
      }
    }>, readonly [], readonly [
      SelectedChildBinding<AssemblyWithViewAndOutMessage<Struct<unknown>, () => unknown>, Struct<{
        defaultDuration: unknown
        entries: unknown
        id: unknown
        maybeSwipeConfig: unknown
        nextEntryKey: unknown
      }>, MessageUnion<{
        Added: unknown
        CancelledSwipe: unknown
        CompletedWaitBeforeDismissal: unknown
        CompletedWaitForSwipeSettled: unknown
        Dismissed: unknown
        HoveredEntry: unknown
        LeftEntry: unknown
        MovedSwipePointer: unknown
        PressedEntryPointer: unknown
        PressedEscape: unknown
        ReleasedSwipePointer: unknown
        RequestedDismiss: unknown
        RequestedDismissAll: unknown
        RequestedShow: unknown
      }>, MessageUnion<{
        DismissedToast: unknown
      }>, {
        childField: "animation"
        field: "entries"
        key: "id"
      }, never, {
        fold: (entryId: unknown, outMessage: unknown) => unknown
      }>
    ], Readonly<{
      EffectsLayer: Layer<unknown | unknown | unknown | unknown, never, never>
      init: (args: [config: unknown]) => Return<unknown, unknown, unknown>
      operations: Readonly<{
        requestDismiss: unknown
        requestDismissAll: unknown
        requestShow: unknown
      }>
      subscriptions: OwnedSubscriptionRegistry<{
        swipeEscape: unknown
        swipePointer: unknown
      }, {
        defaultDuration: unknown
        entries: unknown
        id: unknown
        maybeSwipeConfig: unknown
        nextEntryKey: unknown
      }, unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown>
      update: (message: unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown) => (model: unknown, context: unknown) => unknown
      view: OwnedAuthoredView<BlockView<unknown, unknown, unknown, unknown>, Owner<unknown, unknown>, {
        defaultDuration: unknown
        entries: unknown
        id: unknown
        maybeSwipeConfig: unknown
        nextEntryKey: unknown
      }, unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown, Readonly<unknown>>
    }>>>>>
  }>
  update: (message: {
    _tag: "RequestedDismissAll"
  } | {
    _tag: "PressedEscape"
  } | Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    key: string
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "Animation"
  }> | {
    _tag: "RequestedShow"
    isSticky: boolean
    maybeDuration: Option<Duration>
    payload: A
    variant: "Error" | "Info" | "Success" | "Warning"
  } | {
    _tag: "RequestedDismiss"
    entryId: string
  } | {
    _tag: "Dismissed"
    entryId: string
  } | {
    _tag: "CompletedWaitBeforeDismissal"
    entryId: string
    version: number
  } | {
    _tag: "HoveredEntry"
    entryId: string
  } | {
    _tag: "LeftEntry"
    entryId: string
  } | {
    _tag: "PressedEntryPointer"
    clientX: number
    entryId: string
    pointerId: number
  } | {
    _tag: "MovedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "ReleasedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "CancelledSwipe"
    pointerId: number
  } | {
    _tag: "CompletedWaitForSwipeSettled"
    entryId: string
    version: number
  } | {
    _tag: "Added"
    entry: {
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      isHovered: boolean
      maybeDuration: Option<Duration>
      payload: A
      pendingDismissVersion: number
      swipeState: {
        _tag: "Idle"
      } | {
        _tag: "Dragging"
        currentX: number
        pointerId: number
        startX: number
      } | {
        _tag: "Settling"
        offsetX: number
      } | {
        _tag: "Dismissing"
        direction: "Left" | "Right"
        offsetX: number
      }
      swipeVersion: number
      variant: "Error" | "Info" | "Success" | "Warning"
    }
  }) => (model: {
    defaultDuration: Duration
    entries: readonly Array<{
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      isHovered: boolean
      maybeDuration: Option<Duration>
      payload: A
      pendingDismissVersion: number
      swipeState: {
        _tag: "Idle"
      } | {
        _tag: "Dragging"
        currentX: number
        pointerId: number
        startX: number
      } | {
        _tag: "Settling"
        offsetX: number
      } | {
        _tag: "Dismissing"
        direction: "Left" | "Right"
        offsetX: number
      }
      swipeVersion: number
      variant: "Error" | "Info" | "Success" | "Warning"
    }>
    id: string
    maybeSwipeConfig: Option<{
      direction: "Left" | "Right"
      threshold: number
    }>
    nextEntryKey: number
  }, context: []) => ReturnWithOutMessage<{
    defaultDuration: Duration
    entries: readonly Array<{
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      isHovered: boolean
      maybeDuration: Option<Duration>
      payload: A
      pendingDismissVersion: number
      swipeState: {
        _tag: "Idle"
      } | {
        _tag: "Dragging"
        currentX: number
        pointerId: number
        startX: number
      } | {
        _tag: "Settling"
        offsetX: number
      } | {
        _tag: "Dismissing"
        direction: "Left" | "Right"
        offsetX: number
      }
      swipeVersion: number
      variant: "Error" | "Info" | "Success" | "Warning"
    }>
    id: string
    maybeSwipeConfig: Option<{
      direction: "Left" | "Right"
      threshold: number
    }>
    nextEntryKey: number
  }, {
    _tag: "RequestedDismissAll"
  } | {
    _tag: "PressedEscape"
  } | Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    key: string
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "Animation"
  }> | {
    _tag: "RequestedShow"
    isSticky: boolean
    maybeDuration: Option<Duration>
    payload: A
    variant: "Error" | "Info" | "Success" | "Warning"
  } | {
    _tag: "RequestedDismiss"
    entryId: string
  } | {
    _tag: "Dismissed"
    entryId: string
  } | {
    _tag: "CompletedWaitBeforeDismissal"
    entryId: string
    version: number
  } | {
    _tag: "HoveredEntry"
    entryId: string
  } | {
    _tag: "LeftEntry"
    entryId: string
  } | {
    _tag: "PressedEntryPointer"
    clientX: number
    entryId: string
    pointerId: number
  } | {
    _tag: "MovedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "ReleasedSwipePointer"
    clientX: number
    pointerId: number
  } | {
    _tag: "CancelledSwipe"
    pointerId: number
  } | {
    _tag: "CompletedWaitForSwipeSettled"
    entryId: string
    version: number
  } | {
    _tag: "Added"
    entry: {
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      isHovered: boolean
      maybeDuration: Option<Duration>
      payload: A
      pendingDismissVersion: number
      swipeState: {
        _tag: "Idle"
      } | {
        _tag: "Dragging"
        currentX: number
        pointerId: number
        startX: number
      } | {
        _tag: "Settling"
        offsetX: number
      } | {
        _tag: "Dismissing"
        direction: "Left" | "Right"
        offsetX: number
      }
      swipeVersion: number
      variant: "Error" | "Info" | "Success" | "Warning"
    }
  }, {
    _tag: "DismissedToast"
    payload: A
  }>
}

Constants

DEFAULT_SWIPE_DIRECTION

constsource
/** Default direction in which a pointer can dismiss a Toast. */
const DEFAULT_SWIPE_DIRECTION: SwipeDirection

DEFAULT_SWIPE_THRESHOLD

constsource
/** Default distance in pixels a pointer must travel to dismiss a Toast. */
const DEFAULT_SWIPE_THRESHOLD: 40

Position

constsource
/** Where the toast viewport is anchored on the screen and how entries stack. */
const Position: Literals<readonly ["TopLeft", "TopCenter", "TopRight", "BottomLeft", "BottomCenter", "BottomRight"]>

SWIPE_SETTLE_DURATION

constsource
/**
 * Time an entry remains in `Settling` after a short or cancelled swipe,
 *  allowing consumer CSS to animate it back to rest.
 */
const SWIPE_SETTLE_DURATION: Duration

SwipeDirection

constsource
/** Direction in which a pointer can drag an entry to dismiss it. */
const SwipeDirection: Literals<readonly ["Left", "Right"]>

SwipeState

constsource
/**
 * Per-entry swipe gesture state. `Dragging` retains the initiating
 *  `pointerId`, so move, release, and cancel Messages update only the entry
 *  that started the gesture and ignore unrelated touches. `Settling` returns
 *  a cancelled or short swipe to rest. `Dismissing` retains the release offset
 *  and direction while the leave animation carries the entry off-screen. The
 *  settle generation lives in the entry's `swipeVersion` so a stale settle
 *  timer cannot clear a later gesture.
 */
const SwipeState: TaggedUnion<{
  Dismissing: {
    direction: Literals<readonly ["Left", "Right"]>
    offsetX: Number
  }
  Dragging: {
    currentX: Number
    pointerId: Number
    startX: Number
  }
  Idle: {}
  Settling: {
    offsetX: Number
  }
}>

Variant

constsource
/**
 * Semantic category of a toast. Drives the default ARIA role: `status` for
 *  `Info` / `Success`, `alert` for `Warning` / `Error`. Also surfaced as
 *  `data-variant` on each entry for per-variant CSS. This is the only
 *  content-adjacent field the Toast Block owns. The rest of the entry's
 *  content lives in the user-provided payload.
 */
const Variant: Literals<readonly ["Info", "Success", "Warning", "Error"]>