// PublishWithEOL is a temporary stand in for the ipns records implementation
// see here for more details: https://github.com/ipfs/specs/tree/master/records
320374
func (p *IpnsPublisher) PublishWithEOL(ctx context.Context, k ci.PrivKey, value path.Path, eol time.Time) error {
	record, err := p.updateRecord(ctx, k, value, eol)
	if err != nil {
		return err
	}

	return PutRecordToRouting(ctx, p.routing, k.GetPublic(), record)
}
165711
func (o *GetServiceIDOK) WithPayload(payload *models.Service) *GetServiceIDOK {
	o.Payload = payload
	return o
}
1123478
func (o *UploadTaskFileDefault) WithPayload(payload *models.Error) *UploadTaskFileDefault {
	o.Payload = payload
	return o
}
225510
func (o *PutPolicyFailure) WithPayload(payload models.Error) *PutPolicyFailure {
	o.Payload = payload
	return o
}
16770
func (o *GetMapNameOK) WithPayload(payload *models.BPFMap) *GetMapNameOK {
	o.Payload = payload
	return o
}
448930
func (o *GetPrefilterOK) WithPayload(payload *models.Prefilter) *GetPrefilterOK {
	o.Payload = payload
	return o
}
386626
func (pc *PublisherClientWrapper) SubmitToSingleCTWithResult(ctx context.Context, req *pubpb.Request) (*pubpb.Result, error) {
	res, err := pc.inner.SubmitToSingleCTWithResult(ctx, req)
	if err != nil {
		return nil, err
	}
	if res.Sct == nil {
		return nil, errIncompleteResponse
	}
	return res, nil
}
133978
func (o *GetEndpointIDInvalid) WithPayload(payload models.Error) *GetEndpointIDInvalid {
	o.Payload = payload
	return o
}
1105141
func (e *eventer) Publish(name string, data interface{}) {
	evt := NewEvent(name, data)
	e.in <- evt
}
952403
func (o *GetHealthzOK) WithPayload(payload *models.StatusResponse) *GetHealthzOK {
	o.Payload = payload
	return o
}
734435
func (srv *Instance) PublishRaw(target string, data []byte) error {
	return srv.connector.PublishRaw(target, data)
}
348458
func (b *EventBus) PublishEvent(ctx context.Context, event eh.Event) error {
	b.group.publish(ctx, event)
	return nil
}
1156196
func (o *PetListOK) WithPayload(payload []*models.Pet) *PetListOK {
	o.Payload = payload
	return o
}
92879
func (service *BaseService) Publish(
	topic string,
	timeout time.Duration,
	heartbeat time.Duration) Service {
	if timeout <= 0 {
		timeout = service.Timeout
	}
	if heartbeat <= 0 {
		heartbeat = service.Heartbeat
	}
	t := newTopic(heartbeat)
	service.topicLock.Lock()
	service.topics[topic] = t
	service.topicLock.Unlock()
	return service.AddFunction(topic, func(id string) interface{} {
		message := t.get(id)
		if message == nil {
			message = make(chan interface{})
			t.put(id, message)
			fireSubscribeEvent(topic, id, service)
		}
	receiveMessage:
		select {
		case result := <-message:
			if result == heartbeatSignals {
				goto receiveMessage
			}
			return result
		case <-time.After(timeout):
			go func() {
				select {
				case message <- heartbeatSignals:
					break
				case <-time.After(t.heartbeat):
					service.offline(t, topic, id)
				}
			}()
			return nil
		}
	}, Options{})
}
478091
func (o *GetDebuginfoOK) WithPayload(payload *models.DebugInfo) *GetDebuginfoOK {
	o.Payload = payload
	return o
}
285343
func NewWithProtocol(proto Protocol) (*IPTables, error) {
	path, err := exec.LookPath(getIptablesCommand(proto))
	if err != nil {
		return nil, err
	}
	vstring, err := getIptablesVersionString(path)
	v1, v2, v3, mode, err := extractIptablesVersion(vstring)

	checkPresent, waitPresent, randomFullyPresent := getIptablesCommandSupport(v1, v2, v3)

	ipt := IPTables{
		path:           path,
		proto:          proto,
		hasCheck:       checkPresent,
		hasWait:        waitPresent,
		hasRandomFully: randomFullyPresent,
		v1:             v1,
		v2:             v2,
		v3:             v3,
		mode:           mode,
	}
	return &ipt, nil
}
1023013
func (o *GetEndpointIDConfigOK) WithPayload(payload *models.EndpointConfigurationStatus) *GetEndpointIDConfigOK {
	o.Payload = payload
	return o
}