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.

     * @param comments
     *            Comments.
     */
    public static void store(final Properties props, final OutputStream out, final String comments) {
        assertArgumentNotNull("props", props);
        assertArgumentNotNull("out", out);

        try {
            props.store(out, comments);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }

	go h.startQueueProcessor(ctx, true)

	queueStore := store.NewQueueStore[any](
		filepath.Join(h.config.QueueDir, h.Name()),
		uint64(h.config.QueueSize),
		httpLoggerExtension,
	)

	if err := queueStore.Open(); err != nil {
		return fmt.Errorf("unable to initialize the queue store of %s webhook: %w", h.Name(), err)
	}

	h.store = queueStore
	store.StreamItems(h.store, h, ctx.Done(), h.config.LogOnceIf)

	return nil

type BatchConfig[I any] struct {
	Limit         uint32
	Store         Store[I]
	CommitTimeout time.Duration
	Log           logger
}

// Add adds the item to the batch
func (b *Batch[I]) Add(item I) error {
	b.Lock()
	defer b.Unlock()

	if b.isFull() {
		if b.store == nil {
			return ErrBatchFull
		}
		// commit batch to store
		if err := b.commit(); err != nil {
			return 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)
	}

}

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

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

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

	if stmt.Stmt != nil {
		return stmt.Stmt.Close()
	}
	return nil
}

// Store defines an interface for managing the caching operations of SQL statements (Stmt).
// This interface provides methods for creating new statements, retrieving all cache keys,
// getting cached statements, setting cached statements, and deleting cached statements.
type Store interface {
	// New creates a new Stmt object and caches it.
	// Parameters:

        }

    }

    /**
     * Inner thread class for executing data store crawling operations.
     * Each thread handles crawling for a single data configuration,
     * processing documents and updating the search index.
     *
     * <p>The thread manages:</p>
     * <ul>
     *   <li>Data store initialization and document processing</li>
     *   <li>Index update operations through callbacks</li>

	c.mu.Lock()
	defer c.mu.Unlock()

	c.readSetAt = time.Time{}
	c.writeSetAt = time.Time{}
	c.abortReads.Store(!t.IsZero() && time.Until(t) < 0)
	c.abortWrites.Store(!t.IsZero() && time.Until(t) < 0)
	c.infReads.Store(t.IsZero())
	c.infWrites.Store(t.IsZero())
	return c.Conn.SetDeadline(t)
}

// SetReadDeadline sets the deadline for future Read calls
// and any currently-blocked Read call.