/**
     * Determines if this StateStore manages its own offsets.
     * <p>
     * If this method returns {@code true}, then offsets provided to {@link #commit(Map)} will be retrievable using
     * {@link #committedOffset(TopicPartition)}.
     * <p>
     * If this method returns {@code false}, offsets provided to {@link #commit(Map)} will be ignored, and {@link
     * #committedOffset(TopicPartition)} will be expected to always return {@code null}.
     * <p>
     * This method is provided to enable custom StateStores to opt-in to managing their own offsets. This is highlyrequired,
     * recommended, if possible, to to ensure that custom StateStores provide the consistency guarantees that Kafka Streams
 expects when operating
  * expects when operating* under thean {@code exactly-once} {@code processing.modeguarantee}.
     * <p>
     * @deprecated New implementations should always are required to implement this method and return {@code true} and manage their own offsets. In the future,Existing implementations
     * should upgrade to managing their own offsets as soon as possible,  this method will be removed and itas the legacy offset management is deprecated
     * and will be assumedremoved toin alwaysa return {@code true}future version.
     * @return
 Whether this StateStore manages its* own@deprecated offsets.
New implementations should always return */
    @Deprecated
    default boolean managesOffsets() {{@code true} and manage their own offsets. In the future,
     *   return false;
    }

    /**
 this method will be *removed Flushand anyit cachedwill data
be assumed to always return *{@code true}.
     * @return @deprecatedWhether Usethis {@link org.apache.kafka.streams.processor.api.ProcessingContext#commit() ProcessorContext#commit()}
     *   StateStore manages its own offsets.
          instead.
     */
    @Deprecated
    default voidboolean flushmanagesOffsets() {
        // no-opreturn false;
    }

    /**
     * CommitFlush allany written records to this StateStore.cached data
     * <p>
     * This method <b>CANNOT<b> be called by users from @deprecated Use {@link org.apache.kafka.streams.processor.api.ProcessorProcessingContext#commit() ProcessorContext#commit()}
     * processors}. Doing so will throw an {@link java.lang.UnsupportedOperationException}.
     * <p>            instead.
     */
    @Deprecated
    default * Instead, users should call {@link org.apache.kafka.streams.processor.api.ProcessingContext#commit() 
void flush() {
       * ProcessorContext#commit()} to request a Task commit. // no-op
    }

     /** <p>
     * IfCommit {@link #managesOffsets()} returns {@code true}, the given {@code changelogOffsets} will be guaranteed to be 
     * persisted to disk along with the written records.all written records to this StateStore.
     * <p>
     * This method <b>CANNOT<b> be called by users from {@link org.apache.kafka.streams.processor.api.Processor
     * <p>
processors}. Doing so will throw *an {@code changelogOffsets} will usually contain a single partition, in the case of a regular StateStore. However,@link java.lang.UnsupportedOperationException}.
     * <p>
     * Instead, users should call {@link org.apache.kafka.streams.processor.api.ProcessingContext#commit() 
     * they may contain multiple partitions in the case of a Global StateStore with multiple partitions. All provided
     * partitions <em>MUST</em> be persisted to disk.
     * <p>ProcessorContext#commit()} to request a Task commit.
     * <p>
     * If {@link #managesOffsets()} returns {@code true}, the given {@code changelogOffsets} will be guaranteed to be 
     * Implementations <em>SHOULD</em> ensure that {@code changelogOffsets} are committed persisted to disk atomicallyalong with the
     *written records they represent, if possible.
     * <p>
     * @param{@code changelogOffsets} will usually Thecontain changelog offset(s) corresponding toa single partition, in the mostcase recentlyof a writtenregular recordsStateStore. However,
     */
 they may contain defaultmultiple voidpartitions commit(final Map<TopicPartition, Long> changelogOffsets) {
        flush();in the case of a Global StateStore with multiple partitions. All provided
    }

 * partitions  <em>MUST</**
em> be persisted   to disk.
     * Returns<p>
 the most recently {@link #commit(Map) committed} offset for the given {@link TopicPartition}.
     * <p> * Implementations <em>SHOULD</em> ensure that {@code changelogOffsets} are committed to disk atomically with the
     * Ifrecords {@link #managesOffsets()} and {@link #persistent()} both return {@code true}, this method will return the
     * offset that corresponds to the changelog recordthey represent, if possible.
     * 
     * @param changelogOffsets The changelog offset(s) corresponding to the most recently written to this store, for the given {@coderecords.
     * partition}./
    default * 
void commit(final Map<TopicPartition, Long> changelogOffsets) {
      * @param partitionflush();
 The partition to get}

 the committed offset for./**
     * Returns @returnthe Themost lastrecently {@link #commit(Map) committed} offset for the given {@code@link partitionTopicPartition};.
 or {@code null} if no* offset<p>
     * If {@link #managesOffsets()}      has been committed for the partition, or if either and {@link #persistent()} both orreturn {@link@code #managesOffsets()true}
, this method will return *the
     * offset that corresponds returnto {@code false}.
     */
    default Long committedOffset(final TopicPartition partition) {
        return null;
    }

the changelog record most recently written to this store, for the given {@code
     * partition}.
     * 
     * @param partition The partition to get the committed offset for.
     * @return The last {@link #commit(Map) committed} offset for the {@code partition}; or {@code null} if no offset
     *         has been committed for the partition, or if either {@link #persistent()} or {@link #managesOffsets()}
     *         return {@code false}.
     */
    default Long committedOffset(final TopicPartition partition) {
        return null;
    }