// BreakerInterval is the cyclic period of the closed state for CircuitBreaker to clear the internal counts,
// If Interval is 0, CircuitBreaker doesn't clear the internal counts during the closed state.
192599
func BreakerInterval(interval time.Duration) Option {
	return func(r *Rabbus) error {
		r.config.breaker.interval = interval
		return nil
	}
}
1020254
func (s *CheckpointConfiguration) SetCheckpointInterval(v int64) *CheckpointConfiguration {
	s.CheckpointInterval = &v
	return s
}
1127489
func WithRefreshInterval(value time.Duration) coptions.Opt {
	return func(p coptions.Params) {
		logger.Debug("Checking refreshIntervalSetter")
		if setter, ok := p.(refreshIntervalSetter); ok {
			setter.SetDiscoveryRefreshInterval(value)
		}
	}
}
653076
func (remote *RemoteDebugger) SetProfilerSamplingInterval(n int64) error {
	_, err := remote.SendRequest("Profiler.setSamplingInterval", Params{
		"interval": n,
	})
	return err
}
71571
func (_m *SchedulerQueueClient) AddIntervalToQueue(interval models.Interval) error {
	ret := _m.Called(interval)

	var r0 error
	if rf, ok := ret.Get(0).(func(models.Interval) error); ok {
		r0 = rf(interval)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}
1050868
func (c *Profiler) SetSamplingInterval(interval int) (*gcdmessage.ChromeResponse, error) {
	var v ProfilerSetSamplingIntervalParams
	v.Interval = interval
	return c.SetSamplingIntervalWithParams(&v)
}
1041516
func (c *Conn) SetKeepAliveInterval(d time.Duration) error {
	return setInterval(c.fd, secs(d))
}
897046
func (a *StartSamplingArgs) SetSamplingInterval(samplingInterval int) *StartSamplingArgs {
	a.SamplingInterval = &samplingInterval
	return a
}
1292828
func WithRefreshInterval(refreshInterval time.Duration) ConfigOption {
	return func(o *configOption) {
		o.refreshInterval = refreshInterval
	}
}
658670
func FlushInterval(interval time.Duration) Option {
	return func(c *client) {
		c.flushInterval = interval
	}
}
616926
func (s *HealthCheck) SetInterval(v int64) *HealthCheck {
	s.Interval = &v
	return s
}
687285
func (i Interval) ContainsInterval(oi Interval) bool {
	if oi.IsEmpty() {
		return true
	}
	return i.Lo <= oi.Lo && oi.Hi <= i.Hi
}
1344065
func (c *Client) AddInterval(from contract.Interval) (id string, err error) {
	interval := models.NewInterval(from)
	if interval.ID != "" {
		_, err = uuid.Parse(interval.ID)
		if err != nil {
			return "", db.ErrInvalidObjectId
		}
	} else {
		interval.ID = uuid.New().String()
	}

	if interval.Timestamps.Created == 0 {
		ts := db.MakeTimestamp()
		interval.Timestamps.Created = ts
		interval.Timestamps.Modified = ts
	}

	data, err := json.Marshal(interval)
	if err != nil {
		return "", err
	}

	conn := c.Pool.Get()
	defer conn.Close()

	_ = conn.Send("MULTI")
	addObject(data, interval, interval.ID, conn)
	_, err = conn.Do("EXEC")

	return interval.ID, err
}
760288
func isIntervalStillInUse(s contract.Interval) (bool, error) {
	var intervalActions []contract.IntervalAction

	intervalActions, err := dbClient.IntervalActionsByIntervalName(s.Name)
	if err != nil {
		return false, err
	}
	if len(intervalActions) > 0 {
		return true, nil
	}

	return false, nil
}
161138
func (s *H264Settings) SetMinIInterval(v int64) *H264Settings {
	s.MinIInterval = &v
	return s
}
1251
func BreakerTimeout(timeout time.Duration) Option {
	return func(r *Rabbus) error {
		r.config.breaker.timeout = timeout
		return nil
	}
}
497912
func (_m *SchedulerQueueClient) QueryIntervalByID(intervalId string) (models.Interval, error) {
	ret := _m.Called(intervalId)

	var r0 models.Interval
	if rf, ok := ret.Get(0).(func(string) models.Interval); ok {
		r0 = rf(intervalId)
	} else {
		r0 = ret.Get(0).(models.Interval)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(intervalId)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}