<KR, VR> KStream<KKGroupedTable<KR, VR> outerJoingroupBy(final KTable<K,KeyValueMapper<? VT>super otherK, final ValueJoiner<? super V, ?KeyValue<KR, superVR>> VTselector, ?Serialized<KR, extends VR> joiner, final Joined<K, V, VT> options);

<KR, VR> KGroupedTable<KR, VR> groupBy(final KeyValueMapper<serialized);

KTable<K, V> filter(final Predicate<? super K, ? super VV> predicate, final KeyValue<KRMaterialized<K, VR>> selectorV, Serialized<KRKeyValueStore<Bytes, VR> serializedbyte[]>> materialized);

KTable<K, V> filterfilterNot(final Predicate<? super K, ? super V> predicate, final Materialized<K, V, KeyValueStore<KKeyValueStore<Bytes[], V>>byte[]>> materialized);

<VR> KTable<K, V>VR> filterNotmapValues(final Predicate<ValueMapper<? super KV, ? superextends V>VR> predicatemapper, final Materialized<K, V, KeyValueStore<KKeyValueStore<Bytes[], V>>byte[]>> materialized);

<VR><VO, VR> KTable<K, VR> mapValuesjoin(final ValueMapper<?KTable<K, superVO> Vother,
 ? extends VR> mapper, final Materialized<K, V, KeyValueStore<K, V>> materialized);

void to(final String topic, final Produced<V, V> options);

KTable<K, V> through(final String topic, final Materialized<K, V> options);

<VO, VR> KTable<K, VR> join(final KTable<K, VO> other,
                            final ValueJoiner<? super V, ? super VO, ? extends VR> joiner,
                            final Materialized<K, VR, KeyValueStore<KKeyValueStore<Bytes, VR>>byte[]>> materialized);

<VO, VR> KTable<K, VR> leftJoin(final KTable<K, VO> other,
                                final ValueJoiner<? super V, ? super VO, ? extends VR> joiner,
                                final Materialized<K, VR, KeyValueStore<KKeyValueStore<Bytes, VR>>byte[]>> materialized);

<VO, VR> KTable<K, VR> outerJoin(final KTable<K, VO> other,
                                 final ValueJoiner<? super V, ? super VO, ? extends VR> joiner,
                                 final Materialized<K, VR, KeyValueStore<KKeyValueStore<Bytes, VR>>byte[]>> materialized);
 

public synchronized <K, V> Topology addGlobalStore(final StateStoreBuilder storeSupplier,
                final Serde<V> valueSerde)

public <K, V> StateStoreBuilder<SessionStore<K, V>> sessionStoreBuilder(final BytesStoreSupplier<SessionStore<Bytes, byte[]>> supplier,
																	    final Serde<K> keySerde, 
																        final Serde<V> valueSerde)

public synchronized <K, V> Topology addGlobalStore(final StateStoreBuilder storeSupplier,
        final String sourceName,
                                                final String sourceName,
                                                          final TimestampExtractor timestampExtractor,
                                                          final Deserializer keyDeserializer,
                                                          final Deserializer valueDeserializer,
                                                          final String topic,
                                                          final String processorName,
                                                          final ProcessorSupplier stateUpdateSupplier)
 
public synchronized final Topology addStateStore(final StateStoreBuilder supplier, final String... processorNames)
 

KTable<K, Long> count(final Materialized<K, V, KeyValueStore<KKeyValueStore<Bytes, V>>byte[]>> materialized);

KTable<K, V> reduce(final Reducer<V> adder, final Reducer<V> subtractor, final Materialized<K, V, KeyValueStore<KKeyValueStore<Bytes, V>>byte[]>> materialized);

<VR> KTable<K, VR> aggregate(final Initializer<VR> initializer,
                             final Aggregator<? super K, ? super V, VR> aggregator,
                             final Aggregator<? super K, ? super V, VR> subtractor,
                             final Materialized<K, VR, KeyValueStore<KKeyValueStore<Bytes, VR>>byte[]>> materialized);

public interface TimeWindowedKStream<K, V> {

   final Aggregator<?KTable<Windowed<K>, super K, ? super V, VR> aggregatorLong> count();

    KTable<Windowed<K>, Long> count(final Materialized<K, Long, WindowStore<Bytes, byte[]>> materializedAs);

    <VR> KTable<Windowed<K>, VR> aggregate(final Initializer<VR> initializer,
                                           final Aggregator<? super K, ? super V, VR> aggregator,);

    <VR> KTable<Windowed<K>, VR> aggregate(final Initializer<VR> initializer,
                                  final Materialized<K, VR, WindowStore<K, VR>> materializedAs);


    KTable<Windowed<K>, V> reduce(final Reducer<V> reducer);

    KTable<Windowed<K>, V> reduce(final Reducer<V> reducer,
Aggregator<? super K, ? super V, VR> aggregator,
                                           final Materialized<K, VVR, WindowStore<KWindowStore<Bytes, V>>byte[]>> materializedAs);


} 

public interface SessionWindowedKStream<K, V> {

    KTable<Windowed<K>, Long>V> countreduce(final Reducer<V> reducer);

    KTable<Windowed<K>, Long>V> countreduce(final Materialized<K,Reducer<V> Longreducer,
 SessionStore<K, Long>> materializedAs);

    <VR, T> KTable<Windowed<K>, VR> aggregate(final Initializer<VR> initializer,
                     final Materialized<K, V, WindowStore<Bytes, byte[]>> materializedAs);


} 

public interface SessionWindowedKStream<K, V> {

    KTable<Windowed<K>, Long> count();

    KTable<Windowed<K>,      Long> count(final Aggregator<? super K, ? super V, VR> aggregatorMaterialized<K, Long, SessionStore<Bytes, byte[]>> materializedAs);

    <VR, T> KTable<Windowed<K>, VR> aggregate(final Initializer<VR> initializer,
                                              final Merger<Aggregator<? super K, T> sessionMerger);

    <VR, T> KTable<Windowed<K>, VR> aggregate(final Initializer<VR> initializer? super V, VR> aggregator,
                                              final Aggregator<Merger<? super K, ? super VT> sessionMerger);

    <VR, T> KTable<Windowed<K>, VR> aggregator aggregate(final Initializer<VR> initializer,
                                              final Merger<Aggregator<? super K, T> ? super V, VR> aggregator,
                                              final Merger<? super K, T> sessionMerger,
                                              final Materialized<K, VR, SessionStore<KSessionStore<Bytes, VR>>byte[]>> materializedAs);


    KTable<Windowed<K>, V> reduce(final Reducer<V> reducer);

    KTable<Windowed<K>, V> reduce(final Reducer<V> reducer,
                                  final Materialized<K, V, SessionStore<KSessionStore<Bytes, V>>byte[]>> materializedAs);
}

/**
 * Optional  public static <K, V, VO>params that can be passed to join, leftJoin, outerJoin operations
 */
public class Joined<K, V, VO> otherValueSerde(final Serde<V> valueSerde){

    public static Joined<K<K, V, VO> withKeySerdeJoined<K, V, VO> with(final Serde<K> keySerde, final Serde <V> valueSerde, final Serde<VO> otherValueSerde)

    public static <K, V, VO> Joined<K, V, VO> withValueSerdekeySerde(final Serde<V>Serde<K> valueSerdekeySerde)

    public static <K, V, VO> Joined<K, V, VO> withOtherValueSerdevalueSerde(final Serde<VO>Serde<V> otherValueSerdevalueSerde)
}

/**
 * Optional arguments thatpublic canstatic be specified when doing to and through operations
 */
public static <K, V> Produced<K, V> with<K, V, VO> Joined<K, V, VO> otherValueSerde(final Serde<V> valueSerde)

    public Joined<K, V, VO> withKeySerde(final Serde<K> keySerde)

    public Joined<K, V, VO> withValueSerde(final Serde<V> valueSerde)

    public static <KJoined<K, V> Produced<KV, V>VO> withwithOtherValueSerde(final Serde<VO> otherValueSerde)
 
	public Serde<K> keySerde, final()
 
    public Serde<V> valueSerde()
 
	public Serde<VO> otherValueSerde()
}

/**
 * Optional arguments that can be specified when doing to and through operations
 */, final StreamPartitioner<K, V> partitioner) 

public static <K, V> Produced<K, V> keySerdewith(final Serde<K> keySerde, final Serde<V> valueSerde)

public static <K, V> Produced<K, V> valueSerdewith(final Serde<K> keySerde, final Serde<V> valueSerde, final StreamPartitioner<K, V> partitioner) 

public static <K, V> Produced<K, V> keySerde(final Serde<K> keySerde)

public static <K, V> Produced<K, V> valueSerde(final Serde<V> valueSerde) 

public static <K, V> Produced<K, V> streamPartitioner(final StreamPartitioner<K, V> partitioner) 

public Produced<K, V> withStreamPartitioner(final StreamPartitioner<K, V> partitioner) 
public Produced<K, V> withValueSerde(final Serde<V> valueSerde) 
public Produced<K, V> withKeySerde(final Serde<K> keySerde)
public Serde<K> keySerde()
public Serde<K> valueSerde()
public StreamPartitioner<K, V> streamPartitioner()

 
/**
 * 

 
/**
 * options that can be used when printing to stdout our writing to a file
 */
public class Printed<K, V> {
    public static <K, V> Printed<K, V> toFile(final String filepath)

    public static <K, V> Printed<K, V> toSysOut()

    public Printed<K, V> withLabel(final String label)

    public Printed<K, V> withKeyValueMapper(final KeyValueMapper<? super K, ? super V, String> mapper)

    public ProcessorSupplier<K, V> build(final String processorName)
}

/**
 * 

/**
 * Implementations of this will provide the ability to wrap a given StateStore
 * with or without caching/loggging etc.
 */
public interface StateStoreBuilder<TStoreBuilder<T extends StateStore> {

    StateStoreBuilder<T>StoreBuilder<T> withCachingEnabled();
    StateStoreBuilder<T>StoreBuilder<T> withLoggingEnabled(Map<String, String> config);
    T build();
};
    StoreBuilder<T> withLoggingDisabled()
    T build();
    Map<String, String> logConfig();
    boolean loggingEnabled();
}

public interface StoreSupplier<T extends StateStore> {

    /**
     * Return the name of this state store supplier.
     * This must be a valid Kafka topic name; valid characters are ASCII alphanumerics, '.', '_' and '-'
     *
     * @return the name of this state store supplier
     */
    String name();

    /**
     * Return a new {@link StateStore} instance.
     *
     * @return a new {@link StateStore} instance of type T
     */
    T get();
 
	/**
     * Return a String that is used as the scope for metrics recorded by Metered stores
 	 * @return metricsScope
 	 */
    String metricsScope();

}

/**
 * A store supplier that can be used to create one or more {@link WindowStore} instances of type <Byte, byte[]>
 */
public interface WindowBytesStoreSupplier extends StoreSupplier<WindowStore<Bytes, byte[]>> {
    /**
     * The number of segments the store has. If your store is segmented then this should be the number of segments
     * in the underlying store. It is also used to reduce the amount of data that is scanned when caching is enabled
     *
     * @return number of segments
     */
    int segments();

    /**
     * The size of the windows any store created from this supplier is creating
     * @return window size
     */
    long windowSize();

    /**
     * Whether or not this store is retaining duplicate keys. Usually only true if the store is being used
     * for joins. Note this should return false if caching is enabled
     * @return true if duplicates should be retained
     */
    boolean retainDuplicates();

    /**
     * The time period for which the {@link WindowStore} will retain historic data
     * @return retentionPeriod
     */
    long retentionPeriod();
}

/**
 * A store supplier that can be used to create one or more {@link KeyValueStore} instances of type <Byte, byte[]>
 */
public interface KeyValueBytesStoreSupplier extends StoreSupplier<KeyValueStore<Bytes, byte[]>> {

}

/**
 * A store supplier that can be used to create one or more {@link SessionStore} instances of type <Byte, byte[]>
 */
public interface SessionBytesStoreSupplier extends StoreSupplier<SessionStore<Bytes, byte[]>> {

    /*

public interface BytesStoreSupplier<T extends StateStore> {

    /**
     * Return the name of this state store supplier.
     * This must be a valid Kafka topic name; valid characters are ASCII alphanumerics, '.', '_' and '-'
     *
     * @returnThe thesize name of thisa statesegment, storein supplier
milliseconds. Used when caching is */
enabled to segment  String name();

the cache
     /**
 and reduce the amount *of Returndata athat newneeds {@linkto StateStore} instance.
     *be scanned when performing range queries
     *
 @return a new {@link StateStore}* instance@return ofsegmentInterval typein Tmilliseconds
     */
    Tlong getsegmentIntervalMs();

}