=head1 NAME

lei-up - update a saved search

=head1 SYNOPSIS

lei up [OPTIONS] OUTPUT

lei up [OPTIONS] --all[=<local|remote>]

=head1 DESCRIPTION

Update the saved search at C<OUTPUT> or all saved searches.

=head1 OPTIONS

=over

=item --all[=<local|remote>]

C<--all> updates all saved searches (listed in L<lei-ls-search(1)>).
C<--all=local> only updates local mailboxes, C<--all=remote> only
updates remote mailboxes (currently C<imap://> and C<imaps://>).

=item --remote-fudge-time=INTERVAL

Look for mail older than the time of the last successful query.
Using a small interval will reduce bandwidth use.  A larger
interval reduces the likelihood of missing a result due to MTA
delays or downtime.

The time(s) of the last successful queries are the C<lastresult>
values visible from L<lei-edit-search(1)>.

Date formats understood by L<git-rev-parse(1)> may be used,
e.g., C<1.hour> or C<3.days>.

Default: 2.days

=item --no-external

=item --no-local

=item --no-remote

These disable the use of all externals, local externals, or
remote externals respectively.  They are useful during
temporary network or mount-point outages.

Unlike C<lei q>, these switches override the original C<lei q --only>
options saved as C<lei.q.only>.

The combination C<--all=remote --no-remote> is supported for
offline use in case a user is updating an IMAP folder on localhost.

=item --exclude=LOCATION

As with L<lei-q(1)>, but may also exclude externals originally
specified via C<lei q --only>.

=item --lock=METHOD

=item --alert=CMD

=item --mua=CMD

=item --jobs QUERY_WORKERS[,WRITE_WORKERS]

C<--lock>, C<--alert>, C<--mua>, and C<--jobs> are all supported and
documented in L<lei-q(1)>.

C<--mua> is incompatible with C<--all>.

=back

=head1 CONTACT

Feedback welcome via plain-text mail to L<mailto:meta@public-inbox.org>

The mail archives are hosted at L<https://public-inbox.org/meta/>
and L<http://4uok3hntl7oi7b4uf4rtfwefqeexfzil2w6kgk2jn5z2f764irre7byd.onion/meta/>

=head1 COPYRIGHT

Copyright all contributors L<mailto:meta@public-inbox.org>

License: AGPL-3.0+ L<https://www.gnu.org/licenses/agpl-3.0.txt>

=head1 SEE ALSO

L<lei-q(1)>, L<lei-ls-search(1)>, L<lei-edit-search(1)>,
L<lei-forget-search(1)>
