/**
     *
     * Join records of this {@code [[KTable]]} with another {@code [[KTable]]'s records KTable} using non-windowed inner join.
   Records  from* this<p>
     * This is tablea areforeign joinedkey accordingjoin, towhere the joining resultkey ofis keyExtractordetermined onby the other{@code KTableforeignKeyExtractor}.
     *
     * @param other the table containing the records              the other {@code KTable} to be joined on with this {@code KTable}. Keyed by KO.
     * @param foreignKeyExtractor extractsa the {@link Function} that extracts the key (KO) from this table's value (V). If the
     * @param joiner specifies how to join the records from both tables
                      * @param materialized the materialized outputresult store
is null, the update is *ignored @paramas namedinvalid.
     * @param joiner <VR>   the value type of the result {@code KTable}
   a {@link *ValueJoiner} @paramthat <KO>computes the keyjoin result typefor ofa thepair otherof {@codematching KTable}records
     * @param <VO><VR> the value type of the other {@code KTable}
          the *value @return
type of the result {@code */KTable}
     <VR,* KO,@param VO><KO> KTable<K, VR> join(final KTable<KO, VO> other,
          the key type of the other {@code KTable}
     * @param <VO>            final Function<V, KO> foreignKeyExtractor,
 the value type of the other {@code KTable}
     * @return a {@code KTable} that contains the result of joining this table with {@code other}
     */
   final ValueJoiner<V<VR, VOKO, VO> KTable<K, VR> joiner join(final KTable<KO, VO> other,
                                    final Named namedFunction<V, KO> foreignKeyExtractor,
                                    final Materialized<KValueJoiner<V, VRVO, KeyValueStore<Bytes, byte[]>> materializedVR> joiner);

    /**
     *
     * Join records of this [[KTable]]{@code KTable} with another {@code [[KTable]]'s recordsKTable} using non-windowed inner join.
 Records    from* this<p>
     * table are joined according to the result of keyExtractor on the other KTableThis is a foreign key join, where the joining key is determined by the {@code foreignKeyExtractor}.
     *
     * @param other the table containing             the recordsother {@code KTable} to be joined onwith this {@code KTable}. Keyed by KO.
     * @param foreignKeyExtractor a {@link Function} that extracts the key (KO) from this table's value (V). If the
     * @param  joiner specifies how to join the records from both tables
     * @param materialized the materialized output store
     *result @paramis <VR>null, the valueupdate typeis ofignored the result {@code KTable}as invalid.
     * @param <KO>joiner the key type of the other {@code KTable}
     * @param <VO> a {@link ValueJoiner} that computes the valuejoin result typefor ofa thepair otherof {@codematching KTable}records
     * @param @return
named     */
    <VR, KO, VO> KTable<K, VR> join(final KTable<KO,a VO> other,
         {@link Named} config used to name the processor in the topology
     * @param <VR>                the value type of finalthe Function<V,result KO> foreignKeyExtractor,{@code KTable}
     * @param <KO>                the key type of the other {@code KTable}
     * final@param ValueJoiner<V,<VO> VO, VR> joiner,
             the value type of the other {@code KTable}
     * @return a {@code KTable} that contains the result of joining finalthis Materialized<K,table VR, KeyValueStore<Bytes, byte[]>> materialized);

with {@code other}
     */**
    <VR, *
KO, VO> KTable<K, VR> join(final *KTable<KO, JoinVO> recordsother,
 of this [[KTable]] with another [[KTable]]'s records using non-windowed left join. Records from   this
     * table are joined according to the result of keyExtractor on the other KTable.
  final Function<V, KO> *foreignKeyExtractor,
       * @param other  the other {@code KTable} to be joined with this {@code KTable}. Keyed by KO
     * @param foreignKeyExtractor extracts the key (KO) fromfinal this table's value (V)ValueJoiner<V, VO, VR> joiner,
     *  @param joiner a {@link ValueJoiner} that computes the join result for a pair of matching records
     * @param named     a {@link final Named} confignamed);

 used to name the processor in the topology /**
     * @paramJoin materializedrecords of athis {@link@code MaterializedKTable} that describes how thewith another {@link@code StateStoreKTable} forusing thenon-windowed resulting {@code KTable}inner join.
     * <p>
     * This is a foreign key join, where the joining key is determined by the  should be materialized. Cannot be {@code null}

{@code foreignKeyExtractor}.
     *
     * @param <VR>other the value type of the result {@code KTable}
     * @param <KO> the key type of the other {@code KTable}
 to be joined with * @param <VO> the value type of the other this {@code KTable}. Keyed by KO.
     * @param @returnforeignKeyExtractor a {@code@link KTableFunction} that extracts the containskey only(KO) thosefrom recordsthis thattable's satisfy the given predicatevalue (V). If the
     */
    <VR, KO, VO> KTable<K, VR> leftJoin(final KTable<KO, VO> other,
                result is null, the update is ignored as invalid.
     * @param joiner         final Function<V, KO> foreignKeyExtractor,
  a {@link ValueJoiner} that computes the join result for a pair of matching records
     * @param materialized        a {@link Materialized} that describes how the {@link StateStore} for finalthe ValueJoiner<V, VO, VR> joiner,resulting {@code KTable}
     *                            should be materialized. Cannot be {@code null}
  final Named named,
 * @param <VR>                the value type of the result {@code KTable}
     * @param <KO>       final Materialized<K, VR, KeyValueStore<Bytes, byte[]>> materialized);

    /**         the key type of the other {@code KTable}
     *
 @param <VO>       * Join records of this [[KTable]] with another [[KTable]]'s records using non-windowed left join. Records from this the value type of the other {@code KTable}
     * @return tablea are{@code joinedKTable} accordingthat tocontains the result of keyExtractorjoining onthis thetable other KTable.
     *
     * @param other  the other {@code KTable} to be joined with this {@code KTable}. Keyed by KOwith {@code other}
     */
    <VR, KO, VO> KTable<K, VR> join(final KTable<KO, VO> other,
                                    final Function<V, KO> foreignKeyExtractor,
                                    final ValueJoiner<V, VO, VR> joiner,
                                    final Materialized<K, VR, KeyValueStore<Bytes, byte[]>> materialized);

    /**
     * Join records of this {@code KTable} with another {@code KTable} using non-windowed inner join.
     * <p>
     * This is a foreign key join, where the joining key is determined by the {@code foreignKeyExtractor}.
     *
     * @param other               the other {@code KTable} to be joined with this {@code KTable}. Keyed by KO.
     * @param foreignKeyExtractor a {@link Function} that extracts the key (KO) from this table's value (V). If the
     *                            result is null, the update is ignored as invalid.
     * @param joiner              a {@link ValueJoiner} that computes the join result for a pair of matching records
     * @param named               a {@link Named} config used to name the processor in the topology
     * @param materialized        a {@link Materialized} that describes how the {@link StateStore} for the resulting {@code KTable}
     *                            should be materialized. Cannot be {@code null}
     * @param <VR>                the value type of the result {@code KTable}
     * @param <KO>                the key type of the other {@code KTable}
     * @param <VO>                the value type of the other {@code KTable}
     * @return a {@code KTable} that contains the result of joining this table with {@code other}
     */
    <VR, KO, VO> KTable<K, VR> join(final KTable<KO, VO> other,
                                    final Function<V, KO> foreignKeyExtractor,
                                    final ValueJoiner<V, VO, VR> joiner,
                                    final Named named,
                                    final Materialized<K, VR, KeyValueStore<Bytes, byte[]>> materialized);

    /**
     * Join records of this {@code KTable} with another {@code KTable} using non-windowed left join.
     * <p>
     * This is a foreign key join, where the joining key is determined by the {@code foreignKeyExtractor}.
     *
     * @param other               the other {@code KTable} to be joined with this {@code KTable}. Keyed by KO.
     * @param foreignKeyExtractor a {@link Function} that extracts the key (KO) from this table's value (V). If the
     *                            result is null, the update is ignored as invalid.
     * @param joiner              a {@link ValueJoiner} that computes the join result for a pair of matching records
     * @param <VR>                the value type of the result {@code KTable}
     * @param <KO>                the key type of the other {@code KTable}
     * @param <VO>                the value type of the other {@code KTable}
     * @return a {@code KTable} that contains only those records that satisfy the given predicate
     */
    <VR, KO, VO> KTable<K, VR> leftJoin(final KTable<KO, VO> other,
                                        final Function<V, KO> foreignKeyExtractor,
                                        final ValueJoiner<V, VO, VR> joiner);

    /**
     * Join records of this {@code KTable} with another {@code KTable} using non-windowed left join.
     * <p>
     * This is a foreign key join, where the joining key is determined by the {@code foreignKeyExtractor}.
     *
     * @param other               the other {@code KTable} to be joined with this {@code KTable}. Keyed by KO.
     * @param foreignKeyExtractor a {@link Function} that extracts the key (KO) from this table's value (V) If the
     *                            result is null, the update is ignored as invalid.
     * @param joiner              a {@link ValueJoiner} that computes the join result for a pair of matching records
     * @param named               a {@link Named} config used to name the processor in the topology
     * @param <VR>                the value type of the result {@code KTable}
     * @param <KO>                the key type of the other {@code KTable}
     * @param <VO>                the value type of the other {@code KTable}
     * @return a {@code KTable} that contains the result of joining this table with {@code other}
     */
    <VR, KO, VO> KTable<K, VR> leftJoin(final KTable<KO, VO> other,
                                        final Function<V, KO> foreignKeyExtractor,
                                        final ValueJoiner<V, VO, VR> joiner,
                                        final Named named);

    /**
     * Join records of this {@code KTable} with another {@code KTable} using non-windowed left join.
     * <p>
     * This is a foreign key join, where the joining key is determined by the {@code foreignKeyExtractor}.
     *
     * @param other               the other {@code KTable} to be joined with this {@code KTable}. Keyed by KO.
     * @param foreignKeyExtractor a {@link Function} that extracts the key (KO) from this table's value (V). If the
     *                            result is null, the update is ignored as invalid.
     * @param joiner              a {@link ValueJoiner} that computes the join result for a pair of matching records
     * @param materialized        a {@link Materialized} that describes how the {@link StateStore} for the resulting {@code KTable}
     *                            should be materialized. Cannot be {@code null}
     * @param <VR>                the value type of the result {@code KTable}
     * @param <KO>                the key type of the other {@code KTable}
     * @param <VO>                the value type of the other {@code KTable}
     * @return a {@code KTable} that contains the result of joining this table with {@code other}
     */
    <VR, KO, VO> KTable<K, VR> leftJoin(final KTable<KO, VO> other,
                                        final Function<V, KO> foreignKeyExtractor,
                                        final ValueJoiner<V, VO, VR> joiner,
                                        final Materialized<K, VR, KeyValueStore<Bytes, byte[]>> materialized);

    /**
     * Join records of this {@code KTable} with another {@code KTable} using non-windowed left join.
     * <p>
     * This is a foreign key join, where the joining key is determined by the {@code foreignKeyExtractor}.
     *
     * @param other               the other {@code KTable} to be joined with this {@code KTable}. Keyed by KO.
     * @param foreignKeyExtractor a {@link Function} that extracts the key (KO) from this table's value (V) If the
     *                            result is null, the update is ignored as invalid.
     * @param foreignKeyExtractor extractsjoiner the key (KO) from this table's value (V)
     * @param joiner a {@link ValueJoiner} that computes the join result for a pair of matching records
     * @param named               a {@link Named} config used to name the processor in the topology
     * @param materialized        a {@link Materialized} that describes how the {@link StateStore} for the resulting {@code KTable}
     *                            should be materialized. Cannot be {@code null}

 {@code null}
     * @param <VR>             * @param <VR> the value type of the result {@code KTable}
     * @param <KO>                the key type of the other {@code KTable}
     * @param <VO>                the value type of the other {@code KTable}
     * @return a {@code KTable} that contains the onlyresult thoseof recordsjoining thatthis satisfytable thewith given{@code predicateother}
     */
    <VR, KO, VO> KTable<K, VR> leftJoin(final KTable<KO, VO> other,
                                        final Function<V, KO> foreignKeyExtractor,
                                        final ValueJoiner<V, VO, VR> joiner,
                                        final Named named,
                                        final Materialized<K, VR, KeyValueStore<Bytes, byte[]>> materialized);