queueStore := store.NewQueueStore[any](queueDir, uint64(h.kconfig.QueueSize), kafkaLoggerExtension)
	if err = queueStore.Open(); err != nil {
		return fmt.Errorf("unable to initialize the queue store of %s webhook: %w", h.Name(), err)
	}
	ctx, cancel := context.WithCancel(ctx)
	h.store = queueStore
	h.storeCtxCancel = cancel
	store.StreamItems(h.store, h, ctx.Done(), h.kconfig.LogOnce)
	return err
}

// Name - returns the Name of the target.
func (target *RedisTarget) Name() string {
	return target.ID().String()
}

// Store returns any underlying store if set.
func (target *RedisTarget) Store() event.TargetStore {
	return target.store
}

// IsActive - Return true if target is up and active
func (target *RedisTarget) IsActive() (bool, error) {
	if err := target.init(); err != nil {
		return false, err
	}

	"net/http"

	"github.com/minio/minio/internal/hash"
)

var errConfigNotFound = errors.New("config file not found")

func readConfigWithMetadata(ctx context.Context, store objectIO, configFile string, opts ObjectOptions) ([]byte, ObjectInfo, error) {
	r, err := store.GetObjectNInfo(ctx, minioMetaBucket, configFile, nil, http.Header{}, opts)
	if err != nil {
		if isErrObjectNotFound(err) {
			return nil, ObjectInfo{}, errConfigNotFound
		}

	}

	loadUserCalled := false
	select {
	case <-sys.configLoaded:
	default:
		sys.store.LoadUser(ctx, name)
		loadUserCalled = true
	}

	userInfo, err := sys.store.GetUserInfo(name)
	if err == errNoSuchUser && !loadUserCalled {
		sys.store.LoadUser(ctx, name)
		userInfo, err = sys.store.GetUserInfo(name)
	}
	return userInfo, err
}

	connMutex  sync.Mutex
	store      store.Store[event.Event]
	loggerOnce logger.LogOnce

	quitCh chan struct{}
}

// ID - returns TargetID.
func (target *AMQPTarget) ID() event.TargetID {
	return target.id
}

// Name - returns the Name of the target.
func (target *AMQPTarget) Name() string {
	return target.ID().String()
}

// Store returns any underlying store if set.

		if err := tearDownQueueStore(); err != nil {
			t.Fatalf("Failed to tear down store; %v", err)
		}
	}()
	store, err := setUpQueueStore(queueDir, 100)
	if err != nil {
		t.Fatalf("Failed to create a queue store; %v", err)
	}

	var limit uint32 = 100

	batch := NewBatch[TestItem](BatchConfig[TestItem]{
		Limit:         limit,
		Store:         store,
		CommitTimeout: 5 * time.Minute,

// Name - returns the Name of the target.
func (target *MySQLTarget) Name() string {
	return target.ID().String()
}

// Store returns any underlying store if set.
func (target *MySQLTarget) Store() event.TargetStore {
	return target.store
}

// IsActive - Return true if target is up and active
func (target *MySQLTarget) IsActive() (bool, error) {
	if err := target.init(); err != nil {
		return false, err
	}

 * This factory maintains a registry of data store implementations and provides methods
 * to register, retrieve, and discover available data stores.
 *
 * <p>Data stores are registered by name and class name, allowing flexible lookup.
 * The factory also supports dynamic discovery of data store plugins by scanning
 * JAR files for data store configurations.</p>
 *

			return nil, fmt.Errorf("unable to initialize the queue store of NATS `%s`: %w", id, err)
		}
	}

	target := &NATSTarget{
		id:         event.TargetID{ID: id, Name: "nats"},
		args:       args,
		loggerOnce: loggerOnce,
		store:      queueStore,
		quitCh:     make(chan struct{}),
	}

	if target.store != nil {
		store.StreamItems(target.store, target, target.quitCh, target.loggerOnce)
	}

	if target.store != nil {
		if args.BatchSize > 1 {
			target.batch = store.NewBatch[event.Event](store.BatchConfig[event.Event]{
				Limit:         args.BatchSize,
				Log:           loggerOnce,
				Store:         queueStore,
				CommitTimeout: args.BatchCommitTimeout,
			})
		}
		store.StreamItems(target.store, target, target.quitCh, target.loggerOnce)
	}

	return target, nil
}