class AbstractStream {

    static <K, V, VR> ValueTransformerWithKeySupplier<K, V, VR> toValueTransformerWithKeySupplier(
        final ValueTransformerSupplier<V, VR> valueTransformerSupplier) {
        Objects.requireNonNull(valueTransformerSupplier, "valueTransformerSupplier can't be null");
        return new ValueTransformerWithKeySupplier<K, V, VR>() {
            @Override
            public ValueTransformerWithKey<K, V, VR> get() {
                final ValueTransformer<V, VR> valueTransformer = valueTransformerSupplier.get();
                return new ValueTransformerWithKey<K, V, VR>() {
                    @Override
                    public void init(final ProcessorContext context) {
                        valueTransformer.init(context);
                    }

                    @Override
                    public VR transform(final K readOnlyKey, final V value) {
                        return valueTransformer.transform(value);
                    }

                    @Override
                    public void close() {
                        valueTransformer.close();
                    }
                };
            }

            @Override
            public Set<StoreBuilder<?>> stores() {
                return valueTransformerSupplier.stores();
            }
        };
    }

    public  AbstractStream(final AbstractStream<K, V> stream);
      AbstractStream(final String name,
                   final Serde<K> keySerde,
                   final Serde<V> valueSerde,
                   final Set<String> subTopologySourceNodes,
                   final StreamsGraphNode streamsGraphNode,
                   final InternalStreamsBuilder builder);

}