# plan.ops.timing.Pause

- **Module:** plan.ops.timing
- **Package:** libtmux
- **Language:** Rust
- **Kind:** struct
- **Source:** https://github.com/libtmux/libtmux-rs/blob/f0e37052c232636b61d095817046e6bfc8f2ca40/crates/libtmux/src/plan/ops/timing.rs#L52
- **Page:** https://libtmux.org/en/rs/latest/reference/plan-ops-timing-pause/

Wait before the next operation runs.

Renders `run-shell -d SECONDS` with no command, which every supported tmux
accepts: the client waits out the delay and runs nothing. The wait happens
in tmux, so a pause folded into a shared invocation still falls between
its neighbours, and a plan pauses in the same place whatever its
[`Planner`](crate::plan::Planner).

A shell does not need one to catch typed input: tmux holds it until the
pane reads it. A pause is for a program that drops what arrives before it
is ready.

A control-mode connection cannot carry one, because tmux answers a delayed
`run-shell` there at once and holds the next command instead:
[`Plan::run_over_control_mode`](crate::plan::Plan::run_over_control_mode),
and [`Plan::run`](crate::plan::Plan::run) on a handle from
`Server::over_control_mode`, refuse a plan holding a pause with
`ControlModeErrorKind::BlockingCommand` before sending anything.

## Example

```rust
use std::time::Duration;

use libtmux::PaneId;
use libtmux::plan::{Pause, Plan, SendKeys};

let pane: PaneId = "%1".parse()?;
let mut plan = Plan::new();
plan.add(SendKeys::new(pane.clone()).text("./start-db").enter());
plan.add(Pause::new(Duration::from_millis(1500)));
plan.add(SendKeys::new(pane).text("./migrate").enter());

let pause = plan.preview().remove(1).ok_or("a pause renders")?;
assert_eq!(pause.summary().to_string(), r#""run-shell" "-d" "1.5""#);
```

## Members

- `new` (method): Wait `duration` before the next operation.
- `duration` (method): How long this operation waits.