type time.Duration

124 uses

	time (current package)
		format.go#L1617: func ParseDuration(s string) (Duration, error) {
		format.go#L1708: 		return -Duration(d), nil
		format.go#L1713: 	return Duration(d), nil
		sleep.go#L14: func Sleep(d Duration)
		sleep.go#L52: func when(d Duration) int64 {
		sleep.go#L143: func NewTimer(d Duration) *Timer {
		sleep.go#L171: func (t *Timer) Reset(d Duration) bool {
		sleep.go#L187: 	case c.(chan Time) <- Now().Add(Duration(-delta)):
		sleep.go#L202: func After(d Duration) <-chan Time {
		sleep.go#L210: func AfterFunc(d Duration, f func()) *Timer {
		tick.go#L36: func NewTicker(d Duration) *Ticker {
		tick.go#L65: func (t *Ticker) Reset(d Duration) {
		tick.go#L86: func Tick(d Duration) <-chan Time {
		time.go#L632: type Duration int64
		time.go#L635: 	minDuration Duration = -1 << 63
		time.go#L636: 	maxDuration Duration = 1<<63 - 1
		time.go#L652: 	Nanosecond  Duration = 1
		time.go#L664: func (d Duration) String() string {
		time.go#L674: func (d Duration) format(buf *[32]byte) int {
		time.go#L789: func (d Duration) Nanoseconds() int64 { return int64(d) }
		time.go#L792: func (d Duration) Microseconds() int64 { return int64(d) / 1e3 }
		time.go#L795: func (d Duration) Milliseconds() int64 { return int64(d) / 1e6 }
		time.go#L807: func (d Duration) Seconds() float64 {
		time.go#L814: func (d Duration) Minutes() float64 {
		time.go#L821: func (d Duration) Hours() float64 {
		time.go#L829: func (d Duration) Truncate(m Duration) Duration {
		time.go#L838: func lessThanHalf(x, y Duration) bool {
		time.go#L848: func (d Duration) Round(m Duration) Duration {
		time.go#L874: func (d Duration) Abs() Duration {
		time.go#L886: func (t Time) Add(d Duration) Time {
		time.go#L914: func (t Time) Sub(u Time) Duration {
		time.go#L918: 	d := Duration(t.sec()-u.sec())*Second + Duration(t.nsec()-u.nsec())
		time.go#L930: func subMono(t, u int64) Duration {
		time.go#L931: 	d := Duration(t - u)
		time.go#L943: func Since(t Time) Duration {
		time.go#L953: func Until(t Time) Duration {
		time.go#L1577: func (t Time) Truncate(d Duration) Time {
		time.go#L1594: func (t Time) Round(d Duration) Time {
		time.go#L1609: func div(t Time, d Duration) (qmod2 int, r Duration) {
		time.go#L1628: 		r = Duration(nsec % int32(d))
		time.go#L1634: 		r = Duration(sec%d1)*Second + Duration(nsec)
		time.go#L1681: 		r = Duration(u0)

	context
		context.go#L689: func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
		context.go#L696: func WithTimeoutCause(parent Context, timeout time.Duration, cause error) (Context, CancelFunc) {

	crypto/tls
		handshake_client_tls13.go#L877: 	lifetime := time.Duration(msg.lifetime) * time.Second

	github.com/coinbase/cdp-sdk/go/auth
		jwt.go#L161: 		"exp":  now.Add(time.Duration(options.ExpiresIn) * time.Second).Unix(),
		jwt.go#L201: 		"exp":  now.Add(time.Duration(options.ExpiresIn) * time.Second).Unix(),

	github.com/golang-jwt/jwt/v5
		parser_option.go#L38: func WithLeeway(leeway time.Duration) ParserOption {
		validator.go#L38: 	leeway time.Duration

	net
		dial.go#L91: 	Timeout time.Duration
		dial.go#L122: 	FallbackDelay time.Duration
		dial.go#L134: 	KeepAlive time.Duration
		dial.go#L227: 	timeout := timeRemaining / time.Duration(addrsRemaining)
		dial.go#L240: func (d *Dialer) fallbackDelay() time.Duration {
		dial.go#L433: func DialTimeout(network, address string, timeout time.Duration) (Conn, error) {
		dial.go#L709: 	KeepAlive time.Duration
		dnsclient_unix.go#L168: func (r *Resolver) exchange(ctx context.Context, server string, q dnsmessage.Question, timeout time.Duration, useTCP, ad bool) (dnsmessage.Parser, dnsmessage.Header, error) {
		dnsconfig.go#L35: 	timeout       time.Duration // wait before giving up on a query, including retries
		dnsconfig_unix.go#L92: 					conf.timeout = time.Duration(n) * time.Second
		tcpsock.go#L139: 	Idle time.Duration
		tcpsock.go#L143: 	Interval time.Duration
		tcpsock.go#L249: func (c *TCPConn) SetKeepAlivePeriod(d time.Duration) error {
		tcpsock.go#L289: func newTCPConn(fd *netFD, keepAliveIdle time.Duration, keepAliveCfg KeepAliveConfig, preKeepAliveHook func(*netFD), keepAliveHook func(KeepAliveConfig)) *TCPConn {
		tcpsock.go#L450: func roundDurationUp(d time.Duration, to time.Duration) time.Duration {
		tcpsockopt_unix.go#L15: func setKeepAliveIdle(fd *netFD, d time.Duration) error {
		tcpsockopt_unix.go#L29: func setKeepAliveInterval(fd *netFD, d time.Duration) error {

	net/http
		client.go#L105: 	Timeout time.Duration
		h2_bundle.go#L3706: 	NewTimer(d time.Duration) http2timer
		h2_bundle.go#L3707: 	AfterFunc(d time.Duration, f func()) http2timer
		h2_bundle.go#L3708: 	ContextWithTimeout(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc)
		h2_bundle.go#L3958: 	IdleTimeout time.Duration
		h2_bundle.go#L4007: func (s *http2Server) newTimer(d time.Duration) http2timer {
		h2_bundle.go#L4015: func (s *http2Server) afterFunc(d time.Duration, f func()) http2timer {
		h2_bundle.go#L5303: func (sc *http2serverConn) shutDownIn(d time.Duration) {
		h2_bundle.go#L7166: 	Reset(d time.Duration) bool
		h2_bundle.go#L7290: 	IdleConnTimeout time.Duration
		h2_bundle.go#L7298: 	ReadIdleTimeout time.Duration
		h2_bundle.go#L7303: 	PingTimeout time.Duration
		h2_bundle.go#L7308: 	WriteByteTimeout time.Duration
		h2_bundle.go#L7343: func (t *http2Transport) newTimer(d time.Duration) http2timer {
		h2_bundle.go#L7351: func (t *http2Transport) afterFunc(d time.Duration, f func()) http2timer {
		h2_bundle.go#L7358: func (t *http2Transport) contextWithTimeout(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc) {
		h2_bundle.go#L7392: func (t *http2Transport) pingTimeout() time.Duration {
		h2_bundle.go#L7486: 	idleTimeout time.Duration // or 0 for never
		h2_bundle.go#L7639: 	timeout time.Duration
		h2_bundle.go#L7750: 				d := time.Second * time.Duration(backoff)
		h2_bundle.go#L7891: func (t *http2Transport) expectContinueTimeout() time.Duration {
		h2_bundle.go#L8364: func (cc *http2ClientConn) responseHeaderTimeout() time.Duration {
		h2_bundle.go#L10378: func (t *http2Transport) idleConnTimeout() time.Duration {
		server.go#L934: func (srv *Server) tlsHandshakeTimeout() time.Duration {
		server.go#L935: 	var ret time.Duration
		server.go#L936: 	for _, v := range [...]time.Duration{
		server.go#L2910: 	ReadTimeout time.Duration
		server.go#L2918: 	ReadHeaderTimeout time.Duration
		server.go#L2925: 	WriteTimeout time.Duration
		server.go#L2931: 	IdleTimeout time.Duration
		server.go#L3061: 	nextPollInterval := func() time.Duration {
		server.go#L3063: 		interval := pollIntervalBase + time.Duration(rand.Intn(int(pollIntervalBase/10)))
		server.go#L3326: 	var tempDelay time.Duration // how long to sleep on accept failure
		server.go#L3446: func (s *Server) idleTimeout() time.Duration {
		server.go#L3453: func (s *Server) readHeaderTimeout() time.Duration {
		server.go#L3620: func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler {
		server.go#L3635: 	dt      time.Duration
		transport.go#L185: 	TLSHandshakeTimeout time.Duration
		transport.go#L224: 	IdleConnTimeout time.Duration
		transport.go#L230: 	ResponseHeaderTimeout time.Duration
		transport.go#L239: 	ExpectContinueTimeout time.Duration

	net/http/httptrace
		trace.go#L254: 	IdleTime time.Duration

	os
		exec.go#L368: func (p *ProcessState) UserTime() time.Duration {
		exec.go#L373: func (p *ProcessState) SystemTime() time.Duration {
		exec_unix.go#L172: func (p *ProcessState) userTime() time.Duration {
		exec_unix.go#L173: 	return time.Duration(p.rusage.Utime.Nano()) * time.Nanosecond
		exec_unix.go#L176: func (p *ProcessState) systemTime() time.Duration {
		exec_unix.go#L177: 	return time.Duration(p.rusage.Stime.Nano()) * time.Nanosecond