diff --git a/bom/pom.xml b/bom/pom.xml
index a0bb9cd..5b02437 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -249,6 +249,11 @@
                 <version>${project.version}</version>
             </dependency>
             <dependency>
+                <groupId>org.glassfish.jersey.ext.microprofile</groupId>
+                <artifactId>jersey-mp-rest-client</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+            <dependency>
                 <groupId>org.glassfish.jersey.media</groupId>
                 <artifactId>jersey-media-jaxb</artifactId>
                 <version>${project.version}</version>
diff --git a/containers/jdk-http/pom.xml b/containers/jdk-http/pom.xml
index 6afa5ca..6d6bc69 100644
--- a/containers/jdk-http/pom.xml
+++ b/containers/jdk-http/pom.xml
@@ -94,7 +94,7 @@
         <profile>
             <id>windows</id>
             <activation>
-                <jdk>8</jdk>
+                <jdk>1.8</jdk>
                 <os>
                     <family>windows</family>
                 </os>
diff --git a/core-client/src/main/java/org/glassfish/jersey/client/internal/inject/PrimitiveValueOfInserter.java b/core-client/src/main/java/org/glassfish/jersey/client/internal/inject/PrimitiveValueOfInserter.java
index 9e1ccc8..9c8b33c 100644
--- a/core-client/src/main/java/org/glassfish/jersey/client/internal/inject/PrimitiveValueOfInserter.java
+++ b/core-client/src/main/java/org/glassfish/jersey/client/internal/inject/PrimitiveValueOfInserter.java
@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2010, 2017 Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2018 Payara Foundation and/or its affiliates.
+ * Copyright (c) 2018, 2019 Payara Foundation and/or its affiliates.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -26,9 +26,10 @@
  * @author Paul Sandoz
  * @author Marek Potociar (marek.potociar at oracle.com)
  * @author Gaurav Gupta (gaurav.gupta@payara.fish)
+ * @author Patrik Dudits
  *
  */
-final class PrimitiveValueOfInserter implements ParameterInserter<Number, String> {
+final class PrimitiveValueOfInserter implements ParameterInserter<Object, String> {
 
     private final String parameter;
     private final String defaultValue;
@@ -61,7 +62,7 @@
     }
 
     @Override
-    public String insert(Number value) {
+    public String insert(Object value) {
         if (value != null) {
             return value.toString();
         } else if (defaultValue != null) {
diff --git a/core-server/src/main/java/org/glassfish/jersey/server/model/IntrospectionModeller.java b/core-server/src/main/java/org/glassfish/jersey/server/model/IntrospectionModeller.java
index 239ab9e..bc263fb 100644
--- a/core-server/src/main/java/org/glassfish/jersey/server/model/IntrospectionModeller.java
+++ b/core-server/src/main/java/org/glassfish/jersey/server/model/IntrospectionModeller.java
@@ -183,8 +183,10 @@
                     method.getGenericParameterTypes()[0],
                     method.getAnnotations());
             if (null != p) {
-                ResourceMethodValidator.validateParameter(p, method.getMethod(), method.getMethod().toGenericString(), "1",
+                if (!disableValidation) {
+                    ResourceMethodValidator.validateParameter(p, method.getMethod(), method.getMethod().toGenericString(), "1",
                         InvocableValidator.isSingleton(handlerClass));
+                }
 
                 // we do not inject entity parameters into class instance fields and properties.
                 if (p.getSource() != Parameter.Source.ENTITY) {
@@ -208,8 +210,11 @@
                         field.getGenericType(),
                         field.getAnnotations());
                 if (null != p) {
-                    ResourceMethodValidator.validateParameter(p, field, field.toGenericString(), field.getName(),
+                    if (!disableValidation) {
+                        ResourceMethodValidator.validateParameter(p, field, field.toGenericString(), field.getName(),
                             isInSingleton);
+                    }
+
                     // we do not inject entity and unknown parameters into class instance fields and properties.
                     if (p.getSource() != Parameter.Source.ENTITY) {
                         injectableParameters.add(p);
diff --git a/ext/cdi/jersey-cdi1x/src/main/java/org/glassfish/jersey/ext/cdi1x/internal/CdiComponentProvider.java b/ext/cdi/jersey-cdi1x/src/main/java/org/glassfish/jersey/ext/cdi1x/internal/CdiComponentProvider.java
index 724b7c0..e557de2 100644
--- a/ext/cdi/jersey-cdi1x/src/main/java/org/glassfish/jersey/ext/cdi1x/internal/CdiComponentProvider.java
+++ b/ext/cdi/jersey-cdi1x/src/main/java/org/glassfish/jersey/ext/cdi1x/internal/CdiComponentProvider.java
@@ -146,7 +146,10 @@
         }
     });
 
-    private final Cache<Class<?>, Boolean> jaxRsResourceCache = new Cache<>(clazz -> Resource.from(clazz) != null);
+    // Check first if a class is a JAX-RS resource, and only if so check with validation.
+    // This prevents unnecessary warnings being logged for pure CDI beans.
+    private final Cache<Class<?>, Boolean> jaxRsResourceCache = new Cache<>(
+            clazz -> Resource.from(clazz, true) != null && Resource.from(clazz) != null);
 
     private final Hk2CustomBoundTypesProvider customHk2TypesProvider;
     private final InjectionManagerStore injectionManagerStore;
diff --git a/ext/microprofile/mp-rest-client/pom.xml b/ext/microprofile/mp-rest-client/pom.xml
new file mode 100644
index 0000000..2fc179e
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/pom.xml
@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+
+    This program and the accompanying materials are made available under the
+    terms of the Eclipse Public License v. 2.0, which is available at
+    http://www.eclipse.org/legal/epl-2.0.
+
+    This Source Code may also be made available under the following Secondary
+    Licenses when the conditions for such availability set forth in the
+    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+    version 2 with the GNU Classpath Exception, which is available at
+    https://www.gnu.org/software/classpath/license.html.
+
+    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>project</artifactId>
+        <groupId>org.glassfish.jersey.ext.microprofile</groupId>
+        <version>2.29-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>jersey-mp-rest-client</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.eclipse.microprofile.rest.client</groupId>
+            <artifactId>microprofile-rest-client-api</artifactId>
+            <version>1.2.1</version>
+        </dependency>
+        <dependency>
+            <groupId>org.eclipse.microprofile.config</groupId>
+            <artifactId>microprofile-config-api</artifactId>
+            <version>1.3</version>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.core</groupId>
+            <artifactId>jersey-client</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.core</groupId>
+            <artifactId>jersey-server</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.inject</groupId>
+            <artifactId>jersey-hk2</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.media</groupId>
+            <artifactId>jersey-media-json-binding</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.ext.cdi</groupId>
+            <artifactId>jersey-cdi1x</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>jakarta.json</groupId>
+            <artifactId>jakarta.json-api</artifactId>
+            <version>${jsonp.ri.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.enterprise</groupId>
+            <artifactId>cdi-api</artifactId>
+            <version>2.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish</groupId>
+            <artifactId>jsonp-jaxrs</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+       <plugins>
+            <plugin>
+                <groupId>org.apache.felix</groupId>
+                <artifactId>maven-bundle-plugin</artifactId>
+                <inherited>true</inherited>
+                <extensions>true</extensions>
+                <configuration>
+                    <instructions>
+                        <Export-Package>
+                            org.glassfish.jersey.restclient.*;version=${project.version}
+                        </Export-Package>
+                        <Import-Package>
+                            *
+                        </Import-Package>
+                    </instructions>
+                    <unpackBundle>true</unpackBundle>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
\ No newline at end of file
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/BeanClassModel.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/BeanClassModel.java
new file mode 100644
index 0000000..a074469
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/BeanClassModel.java
@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.ws.rs.BeanParam;
+import javax.ws.rs.CookieParam;
+import javax.ws.rs.FormParam;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.MatrixParam;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Form;
+import javax.ws.rs.core.MultivaluedMap;
+
+import org.glassfish.jersey.model.Parameter;
+
+/**
+ * Model of method parameter annotated by {@link BeanParam} annotation.
+ *
+ * @author David Kral
+ */
+class BeanClassModel {
+
+    private final Class<?> beanClass;
+    private final List<ParamModel> parameterModels;
+
+    /**
+     * Create new instance of bean annotated parameter.
+     *
+     * @param interfaceModel rest client interface model
+     * @param beanClass      bean annotated parameter class
+     * @return new instance
+     */
+    static BeanClassModel fromClass(InterfaceModel interfaceModel, Class<?> beanClass) {
+        return new Builder(interfaceModel, beanClass)
+                .build();
+    }
+
+    private BeanClassModel(Builder builder) {
+        this.beanClass = builder.beanClass;
+        this.parameterModels = builder.parameterModels;
+    }
+
+    /**
+     * List of all class fields annotated with supported parameter annotation
+     *
+     * @return parameter model list
+     */
+    List<ParamModel> getParameterModels() {
+        return parameterModels;
+    }
+
+    /**
+     * Resolves bean path parameters.
+     *
+     * @param webTarget web target path
+     * @param instance  actual method parameter value
+     * @return updated web target path
+     */
+    @SuppressWarnings("unchecked")
+    WebTarget resolvePath(WebTarget webTarget, Object instance) {
+        AtomicReference<WebTarget> toReturn = new AtomicReference<>(webTarget);
+        parameterModels.stream()
+                .filter(paramModel -> paramModel.handles(PathParam.class))
+                .forEach(parameterModel -> {
+                    Field field = (Field) parameterModel.getAnnotatedElement();
+                    toReturn.set((WebTarget) parameterModel.handleParameter(webTarget,
+                                                                            PathParam.class,
+                                                                            resolveValueFromField(field, instance)));
+                });
+        return toReturn.get();
+    }
+
+    /**
+     * Resolves bean header parameters.
+     *
+     * @param headers  headers
+     * @param instance actual method parameter value
+     * @return updated headers
+     */
+    @SuppressWarnings("unchecked")
+    MultivaluedMap<String, Object> resolveHeaders(MultivaluedMap<String, Object> headers,
+                                                  Object instance) {
+        parameterModels.stream()
+                .filter(paramModel -> paramModel.handles(HeaderParam.class))
+                .forEach(parameterModel -> {
+                    Field field = (Field) parameterModel.getAnnotatedElement();
+                    parameterModel.handleParameter(headers,
+                                                   HeaderParam.class,
+                                                   resolveValueFromField(field, instance));
+                });
+        return headers;
+    }
+
+    /**
+     * Resolves bean cookie parameters.
+     *
+     * @param cookies  cookies
+     * @param instance actual method parameter value
+     * @return updated cookies
+     */
+    @SuppressWarnings("unchecked")
+    Map<String, String> resolveCookies(Map<String, String> cookies,
+                                       Object instance) {
+        parameterModels.stream()
+                .filter(paramModel -> paramModel.handles(CookieParam.class))
+                .forEach(parameterModel -> {
+                    Field field = (Field) parameterModel.getAnnotatedElement();
+                    parameterModel.handleParameter(cookies,
+                                                   CookieParam.class,
+                                                   resolveValueFromField(field, instance));
+                });
+        return cookies;
+    }
+
+    /**
+     * Resolves bean query parameters.
+     *
+     * @param query    queries
+     * @param instance actual method parameter value
+     * @return updated queries
+     */
+    @SuppressWarnings("unchecked")
+    Map<String, Object[]> resolveQuery(Map<String, Object[]> query,
+                                       Object instance) {
+        parameterModels.stream()
+                .filter(paramModel -> paramModel.handles(QueryParam.class))
+                .forEach(parameterModel -> {
+                    Field field = (Field) parameterModel.getAnnotatedElement();
+                    parameterModel.handleParameter(query,
+                                                   QueryParam.class,
+                                                   resolveValueFromField(field, instance));
+                });
+        return query;
+    }
+
+    /**
+     * Resolves bean matrix parameters.
+     *
+     * @param webTarget web target path
+     * @param instance  actual method parameter value
+     * @return updated web target path
+     */
+    @SuppressWarnings("unchecked")
+    WebTarget resolveMatrix(WebTarget webTarget,
+                            Object instance) {
+        AtomicReference<WebTarget> toReturn = new AtomicReference<>(webTarget);
+        parameterModels.stream()
+                .filter(paramModel -> paramModel.handles(MatrixParam.class))
+                .forEach(parameterModel -> {
+                    Field field = (Field) parameterModel.getAnnotatedElement();
+                    toReturn.set((WebTarget) parameterModel.handleParameter(webTarget,
+                                                                            MatrixParam.class,
+                                                                            resolveValueFromField(field, instance)));
+                });
+        return toReturn.get();
+    }
+
+    /**
+     * Resolves bean form parameters.
+     *
+     * @param form     web form
+     * @param instance actual method parameter value
+     * @return updated web form
+     */
+    @SuppressWarnings("unchecked")
+    Form resolveForm(Form form,
+                     Object instance) {
+        parameterModels.stream()
+                .filter(paramModel -> paramModel.handles(FormParam.class))
+                .forEach(parameterModel -> {
+                    Field field = (Field) parameterModel.getAnnotatedElement();
+                    parameterModel.handleParameter(form,
+                                                   FormParam.class,
+                                                   resolveValueFromField(field, instance));
+                });
+        return form;
+    }
+
+    private Object resolveValueFromField(Field field, Object instance) {
+        return AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
+            try {
+                Object toReturn;
+                if (field.isAccessible()) {
+                    return field.get(instance);
+                }
+                field.setAccessible(true);
+                toReturn = field.get(instance);
+                field.setAccessible(false);
+                return toReturn;
+            } catch (IllegalAccessException e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    private static class Builder {
+
+        private final InterfaceModel interfaceModel;
+        private final Class<?> beanClass;
+        private ArrayList<ParamModel> parameterModels = new ArrayList<>();
+
+        private Builder(InterfaceModel interfaceModel, Class<?> beanClass) {
+            this.interfaceModel = interfaceModel;
+            this.beanClass = beanClass;
+        }
+
+        private void processPathFields() {
+            processFieldsByParameterClass(PathParam.class);
+        }
+
+        private void processHeaderFields() {
+            processFieldsByParameterClass(HeaderParam.class);
+        }
+
+        private void processCookieFields() {
+            processFieldsByParameterClass(CookieParam.class);
+        }
+
+        private void processQueryFields() {
+            processFieldsByParameterClass(QueryParam.class);
+        }
+
+        private void processMatrixFields() {
+            processFieldsByParameterClass(MatrixParam.class);
+        }
+
+        private void processFieldsByParameterClass(Class<? extends Annotation> parameterClass) {
+            for (Field field : beanClass.getDeclaredFields()) {
+                if (field.isAnnotationPresent(parameterClass)) {
+                    Parameter parameter = Parameter.create(parameterClass, parameterClass, false,
+                                                           field.getType(), field.getGenericType(),
+                                                           field.getDeclaredAnnotations());
+                    parameterModels.add(ParamModel.from(interfaceModel, field.getType(), field,
+                                                        parameter, -1));
+                }
+            }
+        }
+
+        /**
+         * Creates new BeanClassModel instance.
+         *
+         * @return new instance
+         */
+        BeanClassModel build() {
+            processPathFields();
+            processHeaderFields();
+            processCookieFields();
+            processQueryFields();
+            processMatrixFields();
+            return new BeanClassModel(this);
+        }
+    }
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/BeanParamModel.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/BeanParamModel.java
new file mode 100644
index 0000000..edd8253
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/BeanParamModel.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Annotation;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import javax.ws.rs.BeanParam;
+import javax.ws.rs.CookieParam;
+import javax.ws.rs.FormParam;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.MatrixParam;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Form;
+import javax.ws.rs.core.MultivaluedMap;
+
+/**
+ * Contains information about method parameter or class field which is annotated by {@link BeanParam}.
+ *
+ * @author David Kral
+ */
+class BeanParamModel extends ParamModel<Object> {
+
+    private static final Map<Class<?>, ParamHandler> PARAM_HANDLERS = new IdentityHashMap<>();
+
+    static {
+        PARAM_HANDLERS.put(PathParam.class,
+                           (model, requestPart, instance) -> model.resolvePath((WebTarget) requestPart, instance));
+        PARAM_HANDLERS.put(HeaderParam.class,
+                           (model, requestPart, instance) -> model.resolveHeaders((MultivaluedMap<String, Object>) requestPart,
+                                                                                  instance));
+        PARAM_HANDLERS.put(CookieParam.class,
+                           (model, requestPart, instance) -> model.resolveCookies((Map<String, String>) requestPart, instance));
+        PARAM_HANDLERS.put(QueryParam.class,
+                           (model, requestPart, instance) -> model.resolveQuery((Map<String, Object[]>) requestPart,
+                                                                                  instance));
+        PARAM_HANDLERS.put(MatrixParam.class,
+                           (model, requestPart, instance) -> model.resolveMatrix((WebTarget) requestPart, instance));
+        PARAM_HANDLERS.put(FormParam.class,
+                           (model, requestPart, instance) -> model.resolveForm((Form) requestPart,
+                                                                                  instance));
+    }
+
+    private BeanClassModel beanClassModel;
+
+    BeanParamModel(Builder builder) {
+        super(builder);
+        beanClassModel = BeanClassModel.fromClass(interfaceModel, (Class<?>) getType());
+    }
+
+    @Override
+    public Object handleParameter(Object requestPart, Class<?> annotationClass, Object instance) {
+        ParamHandler handler = PARAM_HANDLERS.get(annotationClass);
+
+        if (null == handler) {
+            throw new UnsupportedOperationException(annotationClass.getName() + " is not supported!");
+        }
+
+        return handler.handle(beanClassModel, requestPart, instance);
+    }
+
+    @Override
+    public boolean handles(Class<Annotation> annotation) {
+        return PARAM_HANDLERS.containsKey(annotation);
+    }
+
+    /**
+     * Returns {@link List} of all parameters annotated by searched annotation.
+     *
+     * @param paramAnnotation searched annotation
+     * @return filtered list
+     */
+    List<ParamModel> getAllParamsWithType(Class<? extends Annotation> paramAnnotation) {
+        return beanClassModel.getParameterModels().stream()
+                .filter(paramModel -> paramModel.handles(paramAnnotation))
+                .collect(Collectors.toList());
+    }
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ClientHeaderParamModel.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ClientHeaderParamModel.java
new file mode 100644
index 0000000..fa5d3af
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ClientHeaderParamModel.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.reflect.Method;
+
+import org.eclipse.microprofile.rest.client.annotation.ClientHeaderParam;
+
+/**
+ * Contains information about method annotation {@link ClientHeaderParam}.
+ *
+ * @author David Kral
+ */
+class ClientHeaderParamModel {
+
+    private final String headerName;
+    private final String[] headerValue;
+    private final Method computeMethod;
+    private final boolean required;
+
+    ClientHeaderParamModel(Class<?> iClass, ClientHeaderParam clientHeaderParam) {
+        headerName = clientHeaderParam.name();
+        headerValue = clientHeaderParam.value();
+        computeMethod = InterfaceUtil.parseComputeMethod(iClass, headerValue);
+        required = clientHeaderParam.required();
+    }
+
+    /**
+     * Returns header name.
+     *
+     * @return header name
+     */
+    String getHeaderName() {
+        return headerName;
+    }
+
+    /**
+     * Returns header value.
+     *
+     * @return header value
+     */
+    String[] getHeaderValue() {
+        return headerValue;
+    }
+
+    /**
+     * Returns method which is used to compute header value.
+     *
+     * @return compute method
+     */
+    Method getComputeMethod() {
+        return computeMethod;
+    }
+
+    /**
+     * Returns true if header is required and false if not. It header is not required and exception
+     * is thrown during compute method invocation, this header will be ignored and not included to request.
+     *
+     * @return if header is required
+     */
+    boolean isRequired() {
+        return required;
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ConfigWrapper.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ConfigWrapper.java
new file mode 100644
index 0000000..fec7869
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ConfigWrapper.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import javax.ws.rs.RuntimeType;
+import javax.ws.rs.core.Configuration;
+import javax.ws.rs.core.Feature;
+
+/**
+ * Configuration wrapper for {@link Configuration}. This class is needed due to custom provider registrations.
+ *
+ * @author David Kral
+ */
+class ConfigWrapper implements Configuration {
+
+    private final Configuration jerseyBuilderConfig;
+    private final Map<Class<?>, Map<Class<?>, Integer>> customProviders;
+
+    ConfigWrapper(Configuration jerseyBuilderConfig) {
+        this.jerseyBuilderConfig = jerseyBuilderConfig;
+        this.customProviders = new HashMap<>();
+    }
+
+    void addCustomProvider(Class<?> provider, Map<Class<?>, Integer> contracts) {
+        if (customProviders.containsKey(provider)) {
+            customProviders.get(provider).putAll(contracts);
+        } else {
+            customProviders.put(provider, contracts);
+        }
+    }
+
+    @Override
+    public RuntimeType getRuntimeType() {
+        return jerseyBuilderConfig.getRuntimeType();
+    }
+
+    @Override
+    public Map<String, Object> getProperties() {
+        return jerseyBuilderConfig.getProperties();
+    }
+
+    @Override
+    public Object getProperty(String name) {
+        return jerseyBuilderConfig.getProperty(name);
+    }
+
+    @Override
+    public Collection<String> getPropertyNames() {
+        return jerseyBuilderConfig.getPropertyNames();
+    }
+
+    @Override
+    public boolean isEnabled(Feature feature) {
+        return jerseyBuilderConfig.isEnabled(feature);
+    }
+
+    @Override
+    public boolean isEnabled(Class<? extends Feature> featureClass) {
+        return jerseyBuilderConfig.isEnabled(featureClass);
+    }
+
+    @Override
+    public boolean isRegistered(Object component) {
+        return jerseyBuilderConfig.isRegistered(component);
+    }
+
+    @Override
+    public boolean isRegistered(Class<?> componentClass) {
+        return jerseyBuilderConfig.isRegistered(componentClass);
+    }
+
+    @Override
+    public Map<Class<?>, Integer> getContracts(Class<?> componentClass) {
+        Map<Class<?>, Integer> map = new HashMap<>(jerseyBuilderConfig.getContracts(componentClass));
+        if (customProviders.containsKey(componentClass)) {
+            map.putAll(customProviders.get(componentClass));
+        }
+        return map;
+    }
+
+    @Override
+    public Set<Class<?>> getClasses() {
+        return jerseyBuilderConfig.getClasses();
+    }
+
+    @Override
+    public Set<Object> getInstances() {
+        return jerseyBuilderConfig.getInstances();
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/CookieParamModel.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/CookieParamModel.java
new file mode 100644
index 0000000..7daf367
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/CookieParamModel.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Annotation;
+import java.util.Map;
+
+import javax.ws.rs.CookieParam;
+
+/**
+ * Contains information about method parameter or class field which is annotated by {@link CookieParam}.
+ *
+ * @author David Kral
+ */
+class CookieParamModel extends ParamModel<Map<String, String>> {
+
+    private final String cookieParamName;
+
+    CookieParamModel(Builder builder, CookieParam annotation) {
+        super(builder);
+        cookieParamName = annotation.value();
+}
+
+    @Override
+    Map<String, String> handleParameter(Map<String, String> requestPart, Class<?> annotationClass, Object instance) {
+        Object resolvedValue = interfaceModel.resolveParamValue(instance, parameter);
+        requestPart.put(cookieParamName, (String) resolvedValue);
+        return requestPart;
+    }
+
+    @Override
+    boolean handles(Class<Annotation> annotation) {
+        return CookieParam.class.equals(annotation);
+    }
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/DefaultResponseExceptionMapper.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/DefaultResponseExceptionMapper.java
new file mode 100644
index 0000000..1099040
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/DefaultResponseExceptionMapper.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Response;
+
+import org.eclipse.microprofile.rest.client.ext.ResponseExceptionMapper;
+
+/**
+ * Default {@link ResponseExceptionMapper} implementation
+ *
+ * @author David Kral
+ */
+class DefaultResponseExceptionMapper implements ResponseExceptionMapper {
+    @Override
+    public Throwable toThrowable(Response response) {
+        return new WebApplicationException("Unknown error, status code " + response.getStatus(), response);
+    }
+
+    @Override
+    public int getPriority() {
+        return Integer.MAX_VALUE;
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ExecutorServiceWrapper.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ExecutorServiceWrapper.java
new file mode 100644
index 0000000..54599e8
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ExecutorServiceWrapper.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.stream.Collectors;
+
+import org.eclipse.microprofile.rest.client.ext.AsyncInvocationInterceptor;
+
+/**
+ * Invokes all {@link AsyncInvocationInterceptor} for every new thread.
+ *
+ * @author David Kral
+ */
+class ExecutorServiceWrapper implements ExecutorService {
+
+    private final ExecutorService wrapped;
+    private final List<AsyncInvocationInterceptor> asyncInterceptors;
+
+    ExecutorServiceWrapper(ExecutorService wrapped,
+                           List<AsyncInvocationInterceptor> asyncInterceptors) {
+        this.wrapped = wrapped;
+        this.asyncInterceptors = asyncInterceptors;
+    }
+
+    @Override
+    public void shutdown() {
+        wrapped.shutdown();
+    }
+
+    @Override
+    public List<Runnable> shutdownNow() {
+        return wrapped.shutdownNow();
+    }
+
+    @Override
+    public boolean isShutdown() {
+        return wrapped.isShutdown();
+    }
+
+    @Override
+    public boolean isTerminated() {
+        return wrapped.isTerminated();
+    }
+
+    @Override
+    public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+        return wrapped.awaitTermination(timeout, unit);
+    }
+
+    @Override
+    public <T> Future<T> submit(Callable<T> task) {
+        return wrapped.submit(wrap(task));
+    }
+
+    @Override
+    public <T> Future<T> submit(Runnable task, T result) {
+        return wrapped.submit(wrap(task), result);
+    }
+
+    @Override
+    public Future<?> submit(Runnable task) {
+        return wrapped.submit(wrap(task));
+    }
+
+    @Override
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
+        return wrapped.invokeAll(wrap(tasks));
+    }
+
+    @Override
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+            throws InterruptedException {
+        return wrapped.invokeAll(wrap(tasks), timeout, unit);
+    }
+
+    @Override
+    public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
+        return wrapped.invokeAny(wrap(tasks));
+    }
+
+    @Override
+    public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+            throws InterruptedException, ExecutionException, TimeoutException {
+        return wrapped.invokeAny(wrap(tasks), timeout, unit);
+    }
+
+    @Override
+    public void execute(Runnable command) {
+        wrapped.execute(wrap(command));
+    }
+
+    private <T> Callable<T> wrap(Callable<T> task) {
+        return () -> {
+            asyncInterceptors.forEach(AsyncInvocationInterceptor::applyContext);
+            return task.call();
+        };
+    }
+
+    private Runnable wrap(Runnable task) {
+        return () -> {
+            asyncInterceptors.forEach(AsyncInvocationInterceptor::applyContext);
+            task.run();
+        };
+    }
+
+
+    private <T> Collection<? extends Callable<T>> wrap(Collection<? extends Callable<T>> tasks) {
+        return tasks.stream()
+                .map(this::wrap)
+                .collect(Collectors.toList());
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/FormParamModel.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/FormParamModel.java
new file mode 100644
index 0000000..46ed76e
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/FormParamModel.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Annotation;
+import java.util.Collection;
+
+import javax.ws.rs.FormParam;
+import javax.ws.rs.core.Form;
+
+/**
+ * Contains information about method parameter or class field which is annotated by {@link FormParam}.
+ *
+ * @author David Kral
+ */
+class FormParamModel extends ParamModel<Form> {
+
+    private final String formParamName;
+
+    FormParamModel(Builder builder, FormParam annotation) {
+        super(builder);
+        formParamName = annotation.value();
+    }
+
+    @Override
+    Form handleParameter(Form form, Class<?> annotationClass, Object instance) {
+        Object resolvedValue = interfaceModel.resolveParamValue(instance, parameter);
+        if (resolvedValue instanceof Collection) {
+            for (final Object v : ((Collection) resolvedValue)) {
+                form.param(formParamName, v.toString());
+            }
+        } else {
+            form.param(formParamName, resolvedValue.toString());
+        }
+        return form;
+    }
+
+    @Override
+    boolean handles(Class<Annotation> annotation) {
+        return FormParam.class.equals(annotation);
+    }
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/HeaderParamModel.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/HeaderParamModel.java
new file mode 100644
index 0000000..17d53c4
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/HeaderParamModel.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Annotation;
+import java.util.Collections;
+
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.core.MultivaluedMap;
+
+/**
+ * Contains information about method parameter or class field which is annotated by {@link HeaderParam}.
+ *
+ * @author David Kral
+ */
+class HeaderParamModel extends ParamModel<MultivaluedMap<String, Object>> {
+
+    private String headerParamName;
+
+    HeaderParamModel(Builder builder, HeaderParam annotation) {
+        super(builder);
+        this.headerParamName = annotation.value();
+    }
+
+    @Override
+    MultivaluedMap<String, Object> handleParameter(MultivaluedMap<String, Object> requestPart,
+                                                          Class<?> annotationClass, Object instance) {
+        Object resolvedValue = interfaceModel.resolveParamValue(instance, parameter);
+        requestPart.put(headerParamName, Collections.singletonList(resolvedValue));
+        return requestPart;
+    }
+
+    @Override
+    boolean handles(Class<Annotation> annotation) {
+        return HeaderParam.class.equals(annotation);
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/HeadersContext.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/HeadersContext.java
new file mode 100644
index 0000000..8de244e
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/HeadersContext.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.util.Optional;
+import java.util.function.Supplier;
+
+import javax.ws.rs.core.MultivaluedMap;
+
+/**
+ *
+ * @author David Kral
+ */
+final class HeadersContext {
+
+    /**
+     * Headers context thread local, used by internal implementations of header filters.
+     */
+    private static final ThreadLocal<HeadersContext> HEADERS_CONTEXT = new ThreadLocal<>();
+
+    private final MultivaluedMap<String, String> inboundHeaders;
+
+    /**
+     * The instance associated with the current thread.
+     * @return context for current thread or {@code empty} if none associated
+     */
+    static Optional<HeadersContext> get() {
+        return Optional.ofNullable(HEADERS_CONTEXT.get());
+    }
+
+    /**
+     * Computes the instance and associates it with current thread if none
+     * associated, or returns the instance already associated.
+     *
+     * @param contextSupplier supplier for header context to be associated with the thread if none is
+     * @return an instance associated with the current context, either from other provider, or from contextSupplier
+     */
+    static HeadersContext compute(Supplier<HeadersContext> contextSupplier) {
+        HeadersContext headersContext = HEADERS_CONTEXT.get();
+        if (null == headersContext) {
+            set(contextSupplier.get());
+        }
+
+        return get().orElseThrow(() -> new IllegalStateException("Computed result was null"));
+    }
+
+    /**
+     * Set the header context to be associated with current thread.
+     *
+     * @param context context to associate
+     */
+    static void set(HeadersContext context) {
+        HEADERS_CONTEXT.set(context);
+    }
+
+    /**
+     * Remove the header context associated with current thread.
+     */
+    static void remove() {
+        HEADERS_CONTEXT.remove();
+    }
+
+    /**
+     * Create a new header context with client tracing enabled.
+     *
+     * @param inboundHeaders inbound header to be used for context propagation
+     * @return a new header context (not associated with current thread)
+     * @see #set(HeadersContext)
+     */
+    static HeadersContext create(MultivaluedMap<String, String> inboundHeaders) {
+        return new HeadersContext(inboundHeaders);
+    }
+
+    private HeadersContext(MultivaluedMap<String, String> inboundHeaders) {
+        this.inboundHeaders = inboundHeaders;
+    }
+
+    /**
+     * Map of headers that were received by server for an inbound call,
+     * may be used to propagate additional headers fro outbound request.
+     *
+     * @return map of inbound headers
+     */
+    MultivaluedMap<String, String> inboundHeaders() {
+        return inboundHeaders;
+    }
+
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/HeadersRequestFilter.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/HeadersRequestFilter.java
new file mode 100644
index 0000000..28e284a
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/HeadersRequestFilter.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.io.IOException;
+
+import javax.ws.rs.ConstrainedTo;
+import javax.ws.rs.RuntimeType;
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.container.ContainerRequestFilter;
+import javax.ws.rs.container.ContainerResponseContext;
+import javax.ws.rs.container.ContainerResponseFilter;
+
+/**
+ * Server side request filter used for propagation of request headers to server client request.
+ *
+ * @author David Kral
+ */
+@ConstrainedTo(RuntimeType.SERVER)
+public class HeadersRequestFilter implements ContainerRequestFilter, ContainerResponseFilter {
+
+    @Override
+    public void filter(ContainerRequestContext requestContext) {
+        HeadersContext.compute(() -> HeadersContext.create(requestContext.getHeaders()));
+    }
+
+    @Override
+    public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) throws IOException {
+        HeadersContext.remove();
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/InterceptorInvocationContext.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/InterceptorInvocationContext.java
new file mode 100644
index 0000000..d559fb7
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/InterceptorInvocationContext.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.enterprise.inject.spi.InterceptionType;
+import javax.enterprise.inject.spi.Interceptor;
+import javax.interceptor.InvocationContext;
+import javax.ws.rs.client.WebTarget;
+
+/**
+ * Invokes all interceptors bound to the target.
+ *
+ * This approach needs to be used due to CDI does not handle properly interceptor invocation
+ * on proxy instances.
+ *
+ * @author David Kral
+ */
+class InterceptorInvocationContext implements InvocationContext {
+
+    private final MethodModel methodModel;
+    private final Method method;
+    private final Map<String, Object> contextData;
+    private final List<InvocationInterceptor> interceptors;
+    private final WebTarget classLevelWebTarget;
+    private Object[] args;
+    private int currentPosition;
+
+    /**
+     * Creates new instance of InterceptorInvocationContext.
+     *
+     * @param classLevelWebTarget class level web target
+     * @param methodModel method model
+     * @param method reflection method
+     * @param args actual method arguments
+     */
+    InterceptorInvocationContext(WebTarget classLevelWebTarget,
+                                 MethodModel methodModel,
+                                 Method method,
+                                 Object[] args) {
+        this.contextData = new HashMap<>();
+        this.currentPosition = 0;
+        this.methodModel = methodModel;
+        this.method = method;
+        this.args = args;
+        this.classLevelWebTarget = classLevelWebTarget;
+        this.interceptors = methodModel.getInvocationInterceptors();
+
+    }
+
+    @Override
+    public Object getTarget() {
+        return methodModel;
+    }
+
+    @Override
+    public Object getTimer() {
+        return null;
+    }
+
+    @Override
+    public Method getMethod() {
+        return method;
+    }
+
+    @Override
+    public Constructor<?> getConstructor() {
+        return null;
+    }
+
+    @Override
+    public Object[] getParameters() {
+        return args;
+    }
+
+    @Override
+    public void setParameters(Object[] params) {
+        this.args = params;
+    }
+
+    @Override
+    public Map<String, Object> getContextData() {
+        return contextData;
+    }
+
+    @Override
+    public Object proceed() {
+        if (currentPosition < interceptors.size()) {
+            return interceptors.get(currentPosition++).intercept(this);
+        } else {
+            return methodModel.invokeMethod(classLevelWebTarget, method, args);
+        }
+    }
+
+    /**
+     * Contains actual interceptor instance and interceptor itself.
+     */
+    static class InvocationInterceptor {
+
+        private final Object interceptorInstance;
+        private final Interceptor interceptor;
+
+        InvocationInterceptor(Object interceptorInstance, Interceptor interceptor) {
+            this.interceptorInstance = interceptorInstance;
+            this.interceptor = interceptor;
+        }
+
+        /**
+         * Invokes interceptor with interception type AROUND_INVOKE.
+         *
+         * @param ctx invocation context
+         * @return interception result
+         */
+        @SuppressWarnings("unchecked")
+        Object intercept(InvocationContext ctx) {
+            try {
+                return interceptor.intercept(InterceptionType.AROUND_INVOKE, interceptorInstance, ctx);
+            } catch (Exception e) {
+                if (e instanceof RuntimeException) {
+                    throw (RuntimeException) e;
+                }
+                throw new RuntimeException(e);
+            }
+        }
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/InterfaceModel.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/InterfaceModel.java
new file mode 100644
index 0000000..259110c
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/InterfaceModel.java
@@ -0,0 +1,371 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019 Payara Foundation and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import javax.enterprise.context.spi.CreationalContext;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.CDI;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.ext.ParamConverterProvider;
+
+import org.eclipse.microprofile.rest.client.RestClientDefinitionException;
+import org.eclipse.microprofile.rest.client.annotation.ClientHeaderParam;
+import org.eclipse.microprofile.rest.client.annotation.RegisterClientHeaders;
+import org.eclipse.microprofile.rest.client.ext.AsyncInvocationInterceptor;
+import org.eclipse.microprofile.rest.client.ext.ClientHeadersFactory;
+import org.eclipse.microprofile.rest.client.ext.ResponseExceptionMapper;
+import org.glassfish.jersey.client.inject.ParameterInserter;
+import org.glassfish.jersey.client.inject.ParameterInserterProvider;
+import org.glassfish.jersey.internal.inject.InjectionManager;
+import org.glassfish.jersey.internal.inject.Providers;
+import org.glassfish.jersey.model.Parameter;
+
+/**
+ * Model of interface and its annotation.
+ *
+ * @author David Kral
+ * @author Patrik Dudits
+ */
+class InterfaceModel {
+
+    private final InjectionManager injectionManager;
+    private final Class<?> restClientClass;
+    private final String[] produces;
+    private final String[] consumes;
+    private final String path;
+    private final ClientHeadersFactory clientHeadersFactory;
+    private final CreationalContext<?> creationalContext;
+
+    private final List<ClientHeaderParamModel> clientHeaders;
+    private final List<AsyncInvocationInterceptor> asyncInterceptors;
+    private final Set<ResponseExceptionMapper> responseExceptionMappers;
+    private final Set<ParamConverterProvider> paramConverterProviders;
+    private final Set<Annotation> interceptorAnnotations;
+    private final BeanManager beanManager;
+
+    /**
+     * Creates new model based on interface class. Interface is parsed according to specific annotations.
+     *
+     * @param restClientClass          interface class
+     * @param responseExceptionMappers registered exception mappers
+     * @param paramConverterProviders  registered parameter providers
+     * @param asyncInterceptors        async interceptors
+     * @param injectionManager
+     * @return new model instance
+     */
+    static InterfaceModel from(Class<?> restClientClass,
+                               Set<ResponseExceptionMapper> responseExceptionMappers,
+                               Set<ParamConverterProvider> paramConverterProviders,
+                               List<AsyncInvocationInterceptor> asyncInterceptors,
+                               InjectionManager injectionManager,
+                               BeanManager beanManager) {
+        return new Builder(restClientClass,
+                           responseExceptionMappers,
+                           paramConverterProviders,
+                           asyncInterceptors,
+                           injectionManager,
+                           beanManager).build();
+    }
+
+    private InterfaceModel(Builder builder) {
+        this.injectionManager = builder.injectionManager;
+        this.restClientClass = builder.restClientClass;
+        this.path = builder.pathValue;
+        this.produces = builder.produces;
+        this.consumes = builder.consumes;
+        this.clientHeaders = builder.clientHeaders;
+        this.clientHeadersFactory = builder.clientHeadersFactory;
+        this.responseExceptionMappers = builder.responseExceptionMappers;
+        this.paramConverterProviders = builder.paramConverterProviders;
+        this.interceptorAnnotations = builder.interceptorAnnotations;
+        this.creationalContext = builder.creationalContext;
+        this.asyncInterceptors = builder.asyncInterceptors;
+        this.beanManager = builder.beanManager;
+    }
+
+    /**
+     * Returns rest client interface class.
+     *
+     * @return interface class
+     */
+    Class<?> getRestClientClass() {
+        return restClientClass;
+    }
+
+    /**
+     * Returns defined produces media types.
+     *
+     * @return produces
+     */
+    String[] getProduces() {
+        return produces;
+    }
+
+    /**
+     * Returns defined consumes media types.
+     *
+     * @return consumes
+     */
+    String[] getConsumes() {
+        return consumes;
+    }
+
+    /**
+     * Returns path value defined on interface level.
+     *
+     * @return path value
+     */
+    String getPath() {
+        return path;
+    }
+
+    /**
+     * Returns registered instance of {@link ClientHeadersFactory}.
+     *
+     * @return registered factory
+     */
+    Optional<ClientHeadersFactory> getClientHeadersFactory() {
+        return Optional.ofNullable(clientHeadersFactory);
+    }
+
+    /**
+     * Returns {@link List} of processed annotation {@link ClientHeaderParam} to {@link ClientHeaderParamModel}
+     *
+     * @return registered factories
+     */
+    List<ClientHeaderParamModel> getClientHeaders() {
+        return clientHeaders;
+    }
+
+    /**
+     * Returns {@link List} of registered {@link AsyncInvocationInterceptor}
+     *
+     * @return registered async interceptors
+     */
+    List<AsyncInvocationInterceptor> getAsyncInterceptors() {
+        return asyncInterceptors;
+    }
+
+    /**
+     * Returns {@link Set} of registered {@link ResponseExceptionMapper}
+     *
+     * @return registered exception mappers
+     */
+    Set<ResponseExceptionMapper> getResponseExceptionMappers() {
+        return responseExceptionMappers;
+    }
+
+    /**
+     * Returns {@link Set} of registered {@link ParamConverterProvider}
+     *
+     * @return registered param converter providers
+     */
+    Set<ParamConverterProvider> getParamConverterProviders() {
+        return paramConverterProviders;
+    }
+
+    /**
+     * Returns {@link Set} of interceptor annotations
+     *
+     * @return interceptor annotations
+     */
+    Set<Annotation> getInterceptorAnnotations() {
+        return interceptorAnnotations;
+    }
+
+    /**
+     * Context bound to this model.
+     *
+     * @return context
+     */
+    CreationalContext<?> getCreationalContext() {
+        return creationalContext;
+    }
+
+    /**
+     * @return
+     */
+    public InjectionManager getInjectionManager() {
+        return injectionManager;
+    }
+
+    /**
+     * Resolves value of the method argument.
+     *
+     * @param arg actual argument value
+     * @return converted value of argument
+     */
+    Object resolveParamValue(Object arg, Parameter parameter) {
+        final Iterable<ParameterInserterProvider> parameterInserterProviders
+                = Providers.getAllProviders(injectionManager, ParameterInserterProvider.class);
+        for (final ParameterInserterProvider parameterInserterProvider : parameterInserterProviders) {
+            if (parameterInserterProvider != null) {
+                ParameterInserter<Object, Object> inserter =
+                        (ParameterInserter<Object, Object>) parameterInserterProvider.get(parameter);
+                return inserter.insert(arg);
+            }
+        }
+        return arg;
+    }
+
+    BeanManager getBeanManager() {
+        return beanManager;
+    }
+
+    private static class Builder {
+
+        private final Class<?> restClientClass;
+
+        private final InjectionManager injectionManager;
+        private final BeanManager beanManager;
+        private String pathValue;
+        private String[] produces;
+        private String[] consumes;
+        private ClientHeadersFactory clientHeadersFactory;
+        private CreationalContext<?> creationalContext;
+        private List<ClientHeaderParamModel> clientHeaders;
+        private List<AsyncInvocationInterceptor> asyncInterceptors;
+        private Set<ResponseExceptionMapper> responseExceptionMappers;
+        private Set<ParamConverterProvider> paramConverterProviders;
+        private Set<Annotation> interceptorAnnotations;
+
+        private Builder(Class<?> restClientClass,
+                        Set<ResponseExceptionMapper> responseExceptionMappers,
+                        Set<ParamConverterProvider> paramConverterProviders,
+                        List<AsyncInvocationInterceptor> asyncInterceptors,
+                        InjectionManager injectionManager,
+                        BeanManager beanManager) {
+            this.injectionManager = injectionManager;
+            this.restClientClass = restClientClass;
+            this.responseExceptionMappers = responseExceptionMappers;
+            this.paramConverterProviders = paramConverterProviders;
+            this.asyncInterceptors = asyncInterceptors;
+            this.beanManager = beanManager;
+            filterAllInterceptorAnnotations();
+        }
+
+        private void filterAllInterceptorAnnotations() {
+            creationalContext = null;
+            interceptorAnnotations = new HashSet<>();
+            if (beanManager != null) {
+                creationalContext = beanManager.createCreationalContext(null);
+                for (Annotation annotation : restClientClass.getAnnotations()) {
+                    if (beanManager.isInterceptorBinding(annotation.annotationType())) {
+                        interceptorAnnotations.add(annotation);
+                    }
+                }
+            }
+        }
+
+        /**
+         * Path value from {@link Path} annotation. If annotation is null, empty String is set as path.
+         *
+         * @param path {@link Path} annotation
+         * @return updated Builder instance
+         */
+        Builder pathValue(Path path) {
+            this.pathValue = path != null ? path.value() : "";
+            //if only / is added to path like this "localhost:80/test" it makes invalid path "localhost:80/test/"
+            this.pathValue = pathValue.equals("/") ? "" : pathValue;
+            return this;
+        }
+
+        /**
+         * Extracts MediaTypes from {@link Produces} annotation.
+         * If annotation is null, new String array with {@link MediaType#WILDCARD} is set.
+         *
+         * @param produces {@link Produces} annotation
+         * @return updated Builder instance
+         */
+        Builder produces(Produces produces) {
+            this.produces = produces != null ? produces.value() : new String[] {MediaType.WILDCARD};
+            return this;
+        }
+
+        /**
+         * Extracts MediaTypes from {@link Consumes} annotation.
+         * If annotation is null, new String array with {@link MediaType#WILDCARD} is set.
+         *
+         * @param consumes {@link Consumes} annotation
+         * @return updated Builder instance
+         */
+        Builder consumes(Consumes consumes) {
+            this.consumes = consumes != null ? consumes.value() : new String[] {MediaType.WILDCARD};
+            return this;
+        }
+
+        /**
+         * Process data from {@link ClientHeaderParam} annotation to extract methods and values.
+         *
+         * @param clientHeaderParams {@link ClientHeaderParam} annotations
+         * @return updated Builder instance
+         */
+        Builder clientHeaders(ClientHeaderParam[] clientHeaderParams) {
+            clientHeaders = Arrays.stream(clientHeaderParams)
+                    .map(clientHeaderParam -> new ClientHeaderParamModel(restClientClass, clientHeaderParam))
+                    .collect(Collectors.toList());
+            return this;
+        }
+
+        Builder clientHeadersFactory(RegisterClientHeaders registerClientHeaders) {
+            clientHeadersFactory = registerClientHeaders != null
+                    ? ReflectionUtil.createInstance(registerClientHeaders.value())
+                    : null;
+            return this;
+        }
+
+        /**
+         * Creates new InterfaceModel instance.
+         *
+         * @return new instance
+         */
+        InterfaceModel build() {
+            pathValue(restClientClass.getAnnotation(Path.class));
+            produces(restClientClass.getAnnotation(Produces.class));
+            consumes(restClientClass.getAnnotation(Consumes.class));
+            clientHeaders(restClientClass.getAnnotationsByType(ClientHeaderParam.class));
+            clientHeadersFactory(restClientClass.getAnnotation(RegisterClientHeaders.class));
+            validateHeaderDuplicityNames();
+            return new InterfaceModel(this);
+        }
+
+        private void validateHeaderDuplicityNames() {
+            ArrayList<String> names = new ArrayList<>();
+            for (ClientHeaderParamModel clientHeaderParamModel : clientHeaders) {
+                String headerName = clientHeaderParamModel.getHeaderName();
+                if (names.contains(headerName)) {
+                    throw new RestClientDefinitionException("Header name cannot be registered more then once on the same target."
+                                                                    + "See " + restClientClass.getName());
+                }
+                names.add(headerName);
+            }
+        }
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/InterfaceUtil.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/InterfaceUtil.java
new file mode 100644
index 0000000..83aa97a
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/InterfaceUtil.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.security.AccessController;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import javax.ws.rs.HttpMethod;
+
+import org.eclipse.microprofile.rest.client.RestClientDefinitionException;
+import org.eclipse.microprofile.rest.client.annotation.ClientHeaderParam;
+import org.glassfish.jersey.internal.util.ReflectionHelper;
+
+/**
+ * Utils for interface handling.
+ *
+ * @author David Kral
+ */
+class InterfaceUtil {
+
+    private static final String PARAMETER_PARSE_REGEXP = "(?<=\\{).+?(?=\\})";
+    private static final Pattern PATTERN = Pattern.compile(PARAMETER_PARSE_REGEXP);
+
+    /**
+     * Parses all required parameters from template string.
+     *
+     * @param template template string
+     * @return parsed parameters
+     */
+    static List<String> parseParameters(String template) {
+        List<String> allMatches = new ArrayList<>();
+        Matcher m = PATTERN.matcher(template);
+        while (m.find()) {
+            allMatches.add(m.group());
+        }
+        return allMatches;
+    }
+
+    /**
+     * Validates and returns proper compute method defined in {@link ClientHeaderParam}.
+     *
+     * @param iClass interface class
+     * @param headerValue value of the header
+     * @return parsed method
+     */
+    static Method parseComputeMethod(Class<?> iClass, String[] headerValue) {
+        List<String> computeMethodNames = InterfaceUtil.parseParameters(Arrays.toString(headerValue));
+        /*if more than one string is specified as the value attribute, and one of the strings is a
+          compute method (surrounded by curly braces), then the implementation will throw a
+          RestClientDefinitionException*/
+        if (headerValue.length > 1 && computeMethodNames.size() > 0) {
+            throw new RestClientDefinitionException("@ClientHeaderParam annotation should not contain compute method "
+                                                            + "when multiple values are present in value attribute. "
+                                                            + "See " + iClass.getName());
+        }
+        if (computeMethodNames.size() == 1) {
+            String methodName = computeMethodNames.get(0);
+            List<Method> computeMethods = getAnnotationComputeMethod(iClass, methodName);
+            if (computeMethods.size() != 1) {
+                throw new RestClientDefinitionException("No valid compute method found for name: " + methodName);
+            }
+            return computeMethods.get(0);
+        }
+        return null;
+    }
+
+    private static List<Method> getAnnotationComputeMethod(Class<?> iClass, String methodName) {
+        if (methodName.contains(".")) {
+            return getStaticComputeMethod(methodName);
+        }
+        return getComputeMethod(iClass, methodName);
+    }
+
+    private static List<Method> getStaticComputeMethod(String methodName) {
+        int lastIndex = methodName.lastIndexOf(".");
+        String className = methodName.substring(0, lastIndex);
+        String staticMethodName = methodName.substring(lastIndex + 1);
+        Class<?> classWithStaticMethod = AccessController.doPrivileged(ReflectionHelper.classForNamePA(className));
+        if (classWithStaticMethod == null) {
+            throw new IllegalStateException("No class with following name found: " + className);
+        }
+        return getComputeMethod(classWithStaticMethod, staticMethodName);
+    }
+
+    private static List<Method> getComputeMethod(Class<?> iClass, String methodName) {
+        return Arrays.stream(iClass.getMethods())
+                // filter out methods with specified name only
+                .filter(method -> method.getName().equals(methodName))
+                // filter out other methods than default and static
+                .filter(method -> method.isDefault() || Modifier.isStatic(method.getModifiers()))
+                // filter out methods without required return type
+                .filter(method -> method.getReturnType().equals(String.class)
+                        || method.getReturnType().equals(String[].class))
+                // filter out methods without required parameter types
+                .filter(method -> method.getParameterTypes().length == 0 || (
+                        method.getParameterTypes().length == 1
+                                && method.getParameterTypes()[0].equals(String.class)))
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Returns {@link List} of annotations which are type of {@link HttpMethod}.
+     *
+     * @param annotatedElement element with annotations
+     * @return annotations of given type
+     */
+    static List<Class<?>> getHttpAnnotations(AnnotatedElement annotatedElement) {
+        return Arrays.stream(annotatedElement.getDeclaredAnnotations())
+                .filter(annotation -> annotation.annotationType().getAnnotation(HttpMethod.class) != null)
+                .map(Annotation::annotationType)
+                .collect(Collectors.toList());
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/JerseyRestClientBuilderResolver.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/JerseyRestClientBuilderResolver.java
new file mode 100644
index 0000000..db8e918
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/JerseyRestClientBuilderResolver.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import org.eclipse.microprofile.rest.client.RestClientBuilder;
+import org.eclipse.microprofile.rest.client.spi.RestClientBuilderResolver;
+
+/**
+ *
+ *
+ * @author David Kral
+ */
+public class JerseyRestClientBuilderResolver extends RestClientBuilderResolver {
+    @Override
+    public RestClientBuilder newBuilder() {
+        return new RestClientBuilderImpl();
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/MatrixParamModel.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/MatrixParamModel.java
new file mode 100644
index 0000000..1788d31
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/MatrixParamModel.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Annotation;
+import java.util.Collection;
+
+import javax.ws.rs.MatrixParam;
+import javax.ws.rs.client.WebTarget;
+
+/**
+ * Contains information to method parameter which is annotated by {@link MatrixParam}.
+ *
+ * @author David Kral
+ */
+class MatrixParamModel extends ParamModel<WebTarget> {
+
+    private final String matrixParamName;
+
+    /**
+     * Creates new matrix model.
+     *
+     * @param builder
+     * @param annotation
+     */
+    MatrixParamModel(Builder builder, MatrixParam annotation) {
+        super(builder);
+        matrixParamName = annotation.value();
+    }
+
+    @Override
+    public WebTarget handleParameter(WebTarget requestPart, Class<?> annotationClass, Object instance) {
+        Object resolvedValue = interfaceModel.resolveParamValue(instance, parameter);
+        if (resolvedValue instanceof Collection) {
+            return requestPart.matrixParam(matrixParamName, ((Collection) resolvedValue).toArray());
+        } else {
+            return requestPart.matrixParam(matrixParamName, resolvedValue);
+        }
+    }
+
+    @Override
+    public boolean handles(Class<Annotation> annotation) {
+        return MatrixParam.class.equals(annotation);
+    }
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/MethodModel.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/MethodModel.java
new file mode 100644
index 0000000..c70f7e4
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/MethodModel.java
@@ -0,0 +1,673 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019 Payara Foundation and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.InterceptionType;
+import javax.enterprise.inject.spi.Interceptor;
+import javax.json.JsonValue;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.CookieParam;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.FormParam;
+import javax.ws.rs.GET;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.MatrixParam;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.Invocation;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Form;
+import javax.ws.rs.core.GenericType;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriBuilder;
+
+import org.eclipse.microprofile.rest.client.RestClientDefinitionException;
+import org.eclipse.microprofile.rest.client.annotation.ClientHeaderParam;
+import org.eclipse.microprofile.rest.client.ext.AsyncInvocationInterceptor;
+import org.eclipse.microprofile.rest.client.ext.ResponseExceptionMapper;
+
+/**
+ * Method model contains all information about method defined in rest client interface.
+ *
+ * @author David Kral
+ * @author Patrik Dudits
+ */
+class MethodModel {
+
+    private static final String INVOKED_METHOD = "org.eclipse.microprofile.rest.client.invokedMethod";
+
+    private final InterfaceModel interfaceModel;
+
+    private final Method method;
+    private final GenericType<?> returnType;
+    private final String httpMethod;
+    private final String path;
+    private final String[] produces;
+    private final String[] consumes;
+    private final List<ParamModel> parameterModels;
+    private final List<ClientHeaderParamModel> clientHeaders;
+    private final List<InterceptorInvocationContext.InvocationInterceptor> invocationInterceptors;
+    private final RestClientModel subResourceModel;
+
+    /**
+     * Processes interface method and creates new instance of the model.
+     *
+     * @param interfaceModel
+     * @param method
+     * @return
+     */
+    static MethodModel from(InterfaceModel interfaceModel, Method method) {
+        return new Builder(interfaceModel, method).build();
+    }
+
+    private MethodModel(Builder builder) {
+        this.method = builder.method;
+        this.interfaceModel = builder.interfaceModel;
+        this.returnType = builder.returnType;
+        this.httpMethod = builder.httpMethod;
+        this.path = builder.pathValue;
+        this.produces = builder.produces;
+        this.consumes = builder.consumes;
+        this.parameterModels = builder.parameterModels;
+        this.clientHeaders = builder.clientHeaders;
+        this.invocationInterceptors = builder.invocationInterceptors;
+        if (httpMethod.isEmpty()) {
+            subResourceModel = RestClientModel.from(returnType.getRawType(),
+                                                    interfaceModel.getResponseExceptionMappers(),
+                                                    interfaceModel.getParamConverterProviders(),
+                                                    interfaceModel.getAsyncInterceptors(),
+                                                    interfaceModel.getInjectionManager(),
+                                                    interfaceModel.getBeanManager());
+        } else {
+            subResourceModel = null;
+        }
+    }
+
+    /**
+     * Returns all registered cdi interceptors to this method.
+     *
+     * @return registered interceptors
+     */
+    List<InterceptorInvocationContext.InvocationInterceptor> getInvocationInterceptors() {
+        return invocationInterceptors;
+    }
+
+    /**
+     * Invokes corresponding method according to
+     *
+     * @param classLevelTarget
+     * @param method
+     * @param args
+     * @return
+     */
+    @SuppressWarnings("unchecked")
+    //I am checking the type of parameter and I know it should handle instance I am sending
+    Object invokeMethod(WebTarget classLevelTarget, Method method, Object[] args) {
+        WebTarget methodLevelTarget = classLevelTarget.path(path);
+
+        AtomicReference<Object> entity = new AtomicReference<>();
+        AtomicReference<WebTarget> webTargetAtomicReference = new AtomicReference<>(methodLevelTarget);
+        parameterModels.stream()
+                .filter(parameterModel -> parameterModel.handles(PathParam.class))
+                .forEach(parameterModel ->
+                                 webTargetAtomicReference.set((WebTarget)
+                                                                      parameterModel
+                                                                              .handleParameter(webTargetAtomicReference.get(),
+                                                                                               PathParam.class,
+                                                                                               args[parameterModel
+                                                                                                       .getParamPosition()])));
+
+        parameterModels.stream()
+                .filter(ParamModel::isEntity)
+                .findFirst()
+                .ifPresent(parameterModel -> entity.set(args[parameterModel.getParamPosition()]));
+
+        Form form = handleForm(args);
+
+        WebTarget webTarget = webTargetAtomicReference.get();
+        if (httpMethod.isEmpty()) {
+            //sub resource method
+            return subResourceProxy(webTarget, returnType.getRawType());
+        }
+        webTarget = addQueryParams(webTarget, args);
+        webTarget = addMatrixParams(webTarget, args);
+
+        Invocation.Builder builder = webTarget
+                .request(produces)
+                .property(INVOKED_METHOD, method)
+                .headers(addCustomHeaders(args));
+        builder = addCookies(builder, args);
+
+        Object entityToUse = entity.get();
+        if (entityToUse == null && !form.asMap().isEmpty()) {
+            entityToUse = form;
+        }
+
+        Object response;
+
+        if (CompletionStage.class.isAssignableFrom(method.getReturnType())) {
+            response = asynchronousCall(builder, entityToUse, method);
+        } else {
+            response = synchronousCall(builder, entityToUse, method);
+        }
+        return response;
+    }
+
+    @SuppressWarnings("unchecked")
+    private Form handleForm(Object[] args) {
+        final Form form = new Form();
+        parameterModels.stream()
+                .filter(parameterModel -> parameterModel.handles(FormParam.class))
+                .forEach(parameterModel -> parameterModel.handleParameter(form,
+                                                                          FormParam.class,
+                                                                          args[parameterModel.getParamPosition()]));
+        return form;
+    }
+
+    private Object synchronousCall(Invocation.Builder builder, Object entity, Method method) {
+        Response response;
+
+        if (entity != null
+                && !httpMethod.equals(GET.class.getSimpleName())
+                && !httpMethod.equals(DELETE.class.getSimpleName())) {
+            response = builder.method(httpMethod, Entity.entity(entity, consumes[0]));
+        } else {
+            response = builder.method(httpMethod);
+        }
+
+        evaluateResponse(response, method);
+
+        if (returnType.getType().equals(Void.class)) {
+            return null;
+        } else if (returnType.getType().equals(Response.class)) {
+            return response;
+        }
+        return response.readEntity(returnType);
+    }
+
+    private CompletableFuture asynchronousCall(Invocation.Builder builder, Object entity, Method method) {
+        CompletableFuture<Object> result = new CompletableFuture<>();
+        Future<Response> theFuture;
+        if (entity != null
+                && !httpMethod.equals(GET.class.getSimpleName())
+                && !httpMethod.equals(DELETE.class.getSimpleName())) {
+            theFuture = builder.async().method(httpMethod, Entity.entity(entity, consumes[0]));
+        } else {
+            theFuture = builder.async().method(httpMethod);
+        }
+
+        CompletableFuture<Response> completableFuture = (CompletableFuture<Response>) theFuture;
+        completableFuture.thenAccept(response -> {
+            interfaceModel.getAsyncInterceptors().forEach(AsyncInvocationInterceptor::removeContext);
+            try {
+                evaluateResponse(response, method);
+                if (returnType.getType().equals(Void.class)) {
+                    result.complete(null);
+                } else if (returnType.getType().equals(Response.class)) {
+                    result.complete(response);
+                } else {
+                    result.complete(response.readEntity(returnType));
+                }
+            } catch (Exception e) {
+                result.completeExceptionally(e);
+            }
+        }).exceptionally(throwable -> {
+            interfaceModel.getAsyncInterceptors().forEach(AsyncInvocationInterceptor::removeContext);
+            result.completeExceptionally(throwable);
+            return null;
+        });
+
+        return result;
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T> T subResourceProxy(WebTarget webTarget, Class<T> subResourceType) {
+        return (T) Proxy.newProxyInstance(subResourceType.getClassLoader(),
+                                          new Class[] {subResourceType},
+                                          new ProxyInvocationHandler(webTarget, subResourceModel)
+        );
+    }
+
+    @SuppressWarnings("unchecked") //I am checking the type of parameter and I know it should handle instance I am sending
+    private WebTarget addQueryParams(WebTarget webTarget, Object[] args) {
+        Map<String, Object[]> queryParams = new HashMap<>();
+        WebTarget toReturn = webTarget;
+        parameterModels.stream()
+                .filter(parameterModel -> parameterModel.handles(QueryParam.class))
+                .forEach(parameterModel -> parameterModel.handleParameter(queryParams,
+                                                                          QueryParam.class,
+                                                                          args[parameterModel.getParamPosition()]));
+
+        for (Map.Entry<String, Object[]> entry : queryParams.entrySet()) {
+            toReturn = toReturn.queryParam(entry.getKey(), entry.getValue());
+        }
+        return toReturn;
+    }
+
+    @SuppressWarnings("unchecked") //I am checking the type of parameter and I know it should handle instance I am sending
+    private WebTarget addMatrixParams(WebTarget webTarget, Object[] args) {
+        AtomicReference<WebTarget> toReturn = new AtomicReference<>(webTarget);
+        parameterModels.stream()
+                .filter(parameterModel -> parameterModel.handles(MatrixParam.class))
+                .forEach(parameterModel -> toReturn
+                        .set((WebTarget) parameterModel.handleParameter(toReturn.get(),
+                                                                        MatrixParam.class,
+                                                                        args[parameterModel.getParamPosition()])));
+        return toReturn.get();
+    }
+
+    @SuppressWarnings("unchecked") //I am checking the type of parameter and I know it should handle instance I am sending
+    private Invocation.Builder addCookies(Invocation.Builder builder, Object[] args) {
+        Map<String, String> cookies = new HashMap<>();
+        Invocation.Builder toReturn = builder;
+        parameterModels.stream()
+                .filter(parameterModel -> parameterModel.handles(CookieParam.class))
+                .forEach(parameterModel -> parameterModel.handleParameter(cookies,
+                                                                          CookieParam.class,
+                                                                          args[parameterModel.getParamPosition()]));
+
+        for (Map.Entry<String, String> entry : cookies.entrySet()) {
+            toReturn = toReturn.cookie(entry.getKey(), entry.getValue());
+        }
+        return toReturn;
+    }
+
+    private MultivaluedMap<String, Object> addCustomHeaders(Object[] args) {
+        MultivaluedMap<String, Object> result = new MultivaluedHashMap<>();
+        for (Map.Entry<String, List<String>> entry : resolveCustomHeaders(args).entrySet()) {
+            entry.getValue().forEach(val -> result.add(entry.getKey(), val));
+        }
+        for (String produce : produces) {
+            result.add(HttpHeaders.ACCEPT, produce);
+        }
+        result.add(HttpHeaders.CONTENT_TYPE, consumes[0]);
+        return result;
+    }
+
+    @SuppressWarnings("unchecked") //I am checking the type of parameter and I know it should handle instance I am sending
+    private MultivaluedMap<String, String> resolveCustomHeaders(Object[] args) {
+        MultivaluedMap<String, String> customHeaders = new MultivaluedHashMap<>();
+        customHeaders.putAll(createMultivaluedHeadersMap(interfaceModel.getClientHeaders()));
+        customHeaders.putAll(createMultivaluedHeadersMap(clientHeaders));
+        parameterModels.stream()
+                .filter(parameterModel -> parameterModel.handles(HeaderParam.class))
+                .forEach(parameterModel -> parameterModel.handleParameter(customHeaders,
+                                                                          HeaderParam.class,
+                                                                          args[parameterModel.getParamPosition()]));
+
+        MultivaluedMap<String, String> inbound = new MultivaluedHashMap<>();
+        HeadersContext.get().ifPresent(headersContext -> inbound.putAll(headersContext.inboundHeaders()));
+
+        AtomicReference<MultivaluedMap<String, String>> toReturn = new AtomicReference<>(customHeaders);
+        interfaceModel.getClientHeadersFactory().ifPresent(clientHeadersFactory -> toReturn
+                .set(clientHeadersFactory.update(inbound, customHeaders)));
+        return toReturn.get();
+    }
+
+    private <T> MultivaluedMap<String, String> createMultivaluedHeadersMap(List<ClientHeaderParamModel> clientHeaders) {
+        MultivaluedMap<String, String> customHeaders = new MultivaluedHashMap<>();
+        for (ClientHeaderParamModel clientHeaderParamModel : clientHeaders) {
+            if (clientHeaderParamModel.getComputeMethod() == null) {
+                customHeaders
+                        .put(clientHeaderParamModel.getHeaderName(), Arrays.asList(clientHeaderParamModel.getHeaderValue()));
+            } else {
+                try {
+                    Method method = clientHeaderParamModel.getComputeMethod();
+                    if (method.isDefault()) {
+                        //method is interface default
+                        //we need to create instance of the interface to be able to call default method
+                        T instance = (T) ReflectionUtil.createProxyInstance(interfaceModel.getRestClientClass());
+                        if (method.getParameterCount() > 0) {
+                            customHeaders.put(clientHeaderParamModel.getHeaderName(),
+                                              createList(method.invoke(instance, clientHeaderParamModel.getHeaderName())));
+                        } else {
+                            customHeaders.put(clientHeaderParamModel.getHeaderName(),
+                                              createList(method.invoke(instance, null)));
+                        }
+                    } else {
+                        //Method is static
+                        if (method.getParameterCount() > 0) {
+                            customHeaders.put(clientHeaderParamModel.getHeaderName(),
+                                              createList(method.invoke(null, clientHeaderParamModel.getHeaderName())));
+                        } else {
+                            customHeaders.put(clientHeaderParamModel.getHeaderName(),
+                                              createList(method.invoke(null, null)));
+                        }
+                    }
+                } catch (IllegalAccessException e) {
+                    throw new RuntimeException(e);
+                } catch (InvocationTargetException e) {
+                    if (clientHeaderParamModel.isRequired()) {
+                        if (e.getCause() instanceof RuntimeException) {
+                            throw (RuntimeException) e.getCause();
+                        }
+                        throw new RuntimeException(e.getCause());
+                    }
+                }
+            }
+        }
+        return customHeaders;
+    }
+
+    private static List<String> createList(Object value) {
+        if (value instanceof String[]) {
+            String[] array = (String[]) value;
+            return Arrays.asList(array);
+        }
+        String s = (String) value;
+        return Collections.singletonList(s);
+    }
+
+    /**
+     * Evaluation of {@link Response} if it is applicable for any of the registered {@link ResponseExceptionMapper} providers.
+     *
+     * @param response obtained response
+     * @param method   called method
+     */
+    private void evaluateResponse(Response response, Method method) {
+        ResponseExceptionMapper lowestMapper = null;
+        Throwable throwable = null;
+        for (ResponseExceptionMapper responseExceptionMapper : interfaceModel.getResponseExceptionMappers()) {
+            if (responseExceptionMapper.handles(response.getStatus(), response.getHeaders())) {
+                if (lowestMapper == null
+                        || throwable == null
+                        || lowestMapper.getPriority() > responseExceptionMapper.getPriority()) {
+                    lowestMapper = responseExceptionMapper;
+                    Throwable tmp = lowestMapper.toThrowable(response);
+                    if (tmp != null) {
+                        throwable = tmp;
+                    }
+                }
+            }
+        }
+        if (throwable != null) {
+            if (throwable instanceof RuntimeException) {
+                throw (RuntimeException) throwable;
+            } else if (throwable instanceof Error) {
+                throw (Error) throwable;
+            }
+            for (Class<?> exception : method.getExceptionTypes()) {
+                if (throwable.getClass().isAssignableFrom(exception)) {
+                    throw new WebApplicationException(throwable);
+                }
+            }
+        }
+    }
+
+    private static String parseHttpMethod(InterfaceModel classModel, Method method) {
+        List<Class<?>> httpAnnotations = InterfaceUtil.getHttpAnnotations(method);
+        if (httpAnnotations.size() > 1) {
+            throw new RestClientDefinitionException("Method can't have more then one annotation of @HttpMethod type. "
+                                                            + "See " + classModel.getRestClientClass().getName()
+                                                            + "::" + method.getName());
+        } else if (httpAnnotations.isEmpty()) {
+            //Sub resource method
+            return "";
+        }
+        return httpAnnotations.get(0).getSimpleName();
+    }
+
+    private static List<ParamModel> parameterModels(InterfaceModel classModel, Method method) {
+        ArrayList<ParamModel> parameterModels = new ArrayList<>();
+        final List<org.glassfish.jersey.model.Parameter> jerseyParameters = org.glassfish.jersey.model.Parameter
+                .create(classModel.getRestClientClass(), classModel.getRestClientClass(),
+                        method, false);
+        Parameter[] parameters = method.getParameters();
+        for (int i = 0; i < parameters.length; i++) {
+            parameterModels.add(ParamModel.from(classModel, parameters[i].getType(), parameters[i], jerseyParameters.get(i), i));
+        }
+        return parameterModels;
+    }
+
+    private static class Builder {
+
+        private final InterfaceModel interfaceModel;
+        private final Method method;
+
+        private GenericType<?> returnType;
+        private String httpMethod;
+        private String pathValue;
+        private String[] produces;
+        private String[] consumes;
+        private List<ParamModel> parameterModels;
+        private List<ClientHeaderParamModel> clientHeaders;
+        private List<InterceptorInvocationContext.InvocationInterceptor> invocationInterceptors;
+
+        private Builder(InterfaceModel interfaceModel, Method method) {
+            this.interfaceModel = interfaceModel;
+            this.method = method;
+            filterAllInterceptorAnnotations();
+        }
+
+        private void filterAllInterceptorAnnotations() {
+            invocationInterceptors = new ArrayList<>();
+            BeanManager beanManager = interfaceModel.getBeanManager();
+            if (beanManager != null) {
+                Set<Annotation> interceptorAnnotations = new HashSet<>();
+                for (Annotation annotation : method.getAnnotations()) {
+                    if (beanManager.isInterceptorBinding(annotation.annotationType())) {
+                        interceptorAnnotations.add(annotation);
+                    }
+                }
+                interceptorAnnotations.addAll(interfaceModel.getInterceptorAnnotations());
+                Annotation[] allInterceptorAnnotations = interceptorAnnotations.toArray(new Annotation[0]);
+                if (allInterceptorAnnotations.length == 0) {
+                    return;
+                }
+                List<Interceptor<?>> interceptors = beanManager.resolveInterceptors(InterceptionType.AROUND_INVOKE,
+                                                                                    allInterceptorAnnotations);
+                if (!interceptors.isEmpty()) {
+                    for (Interceptor<?> interceptor : interceptors) {
+                        Object interceptorInstance = beanManager.getReference(interceptor,
+                                                                              interceptor.getBeanClass(),
+                                                                              interfaceModel.getCreationalContext());
+                        invocationInterceptors.add(new InterceptorInvocationContext
+                                .InvocationInterceptor(interceptorInstance,
+                                                       interceptor));
+                    }
+                }
+            }
+        }
+
+        /**
+         * Return type of the method.
+         *
+         * @param returnType Method return type
+         */
+        private void returnType(Type returnType) {
+            if (returnType instanceof ParameterizedType
+                    && CompletionStage.class.isAssignableFrom((Class<?>) ((ParameterizedType) returnType).getRawType())) {
+                this.returnType = new GenericType<>(((ParameterizedType) returnType).getActualTypeArguments()[0]);
+            } else {
+                this.returnType = new GenericType<>(returnType);
+            }
+        }
+
+        /**
+         * HTTP method of the method.
+         *
+         * @param httpMethod HTTP method of the method
+         */
+        private void httpMethod(String httpMethod) {
+            this.httpMethod = httpMethod;
+        }
+
+        /**
+         * Path value from {@link Path} annotation. If annotation is null, empty String is set as path.
+         *
+         * @param path {@link Path} annotation
+         */
+        private void pathValue(Path path) {
+            this.pathValue = path != null ? path.value() : "";
+            //if only / is added to path like this "localhost:80/test" it makes invalid path "localhost:80/test/"
+            this.pathValue = pathValue.equals("/") ? "" : pathValue;
+        }
+
+        /**
+         * Extracts MediaTypes from {@link Produces} annotation.
+         * If annotation is null, value from {@link InterfaceModel} is set.
+         *
+         * @param produces {@link Produces} annotation
+         */
+        private void produces(Produces produces) {
+            this.produces = produces == null ? interfaceModel.getProduces() : produces.value();
+        }
+
+        /**
+         * Extracts MediaTypes from {@link Consumes} annotation.
+         * If annotation is null, value from {@link InterfaceModel} is set.
+         *
+         * @param consumes {@link Consumes} annotation
+         */
+        private void consumes(Consumes consumes) {
+            this.consumes = consumes == null ? interfaceModel.getConsumes() : consumes.value();
+        }
+
+        /**
+         * {@link List} of transformed method parameters.
+         *
+         * @param parameterModels {@link List} of parameters
+         */
+        private void parameters(List<ParamModel> parameterModels) {
+            this.parameterModels = parameterModels;
+        }
+
+        /**
+         * Process data from {@link ClientHeaderParam} annotation to extract methods and values.
+         *
+         * @param clientHeaderParams {@link ClientHeaderParam} annotations
+         */
+        private void clientHeaders(ClientHeaderParam[] clientHeaderParams) {
+            clientHeaders = Arrays.stream(clientHeaderParams)
+                    .map(clientHeaderParam -> new ClientHeaderParamModel(interfaceModel.getRestClientClass(), clientHeaderParam))
+                    .collect(Collectors.toList());
+        }
+
+        /**
+         * Creates new MethodModel instance.
+         *
+         * @return new instance
+         */
+        MethodModel build() {
+            returnType(method.getGenericReturnType());
+            httpMethod(parseHttpMethod(interfaceModel, method));
+            pathValue(method.getAnnotation(Path.class));
+            produces(method.getAnnotation(Produces.class));
+            consumes(method.getAnnotation(Consumes.class));
+            parameters(parameterModels(interfaceModel, method));
+            clientHeaders(method.getAnnotationsByType(ClientHeaderParam.class));
+
+            validateParameters();
+            validateHeaderDuplicityNames();
+            Optional<ParamModel> entity = parameterModels.stream()
+                    .filter(ParamModel::isEntity)
+                    .findFirst();
+            if (returnType.getType() instanceof Class && JsonValue.class.isAssignableFrom((Class<?>) returnType.getType())
+                    || (
+                    entity.isPresent() && entity.get().getType() instanceof Class
+                            && JsonValue.class.isAssignableFrom((Class<?>) entity.get().getType()))) {
+                this.consumes = new String[] {MediaType.APPLICATION_JSON};
+            }
+            return new MethodModel(this);
+        }
+
+        private void validateParameters() {
+            UriBuilder uriBuilder = UriBuilder.fromUri(interfaceModel.getPath()).path(pathValue);
+            List<String> parameters = InterfaceUtil.parseParameters(uriBuilder.toTemplate());
+            List<String> methodPathParameters = new ArrayList<>();
+            List<ParamModel> pathHandlingParams = parameterModels.stream()
+                    .filter(parameterModel -> parameterModel.handles(PathParam.class))
+                    .collect(Collectors.toList());
+            for (ParamModel paramModel : pathHandlingParams) {
+                if (paramModel instanceof PathParamModel) {
+                    methodPathParameters.add(((PathParamModel) paramModel).getPathParamName());
+                } else if (paramModel instanceof BeanParamModel) {
+                    for (ParamModel beanPathParams : ((BeanParamModel) paramModel).getAllParamsWithType(PathParam.class)) {
+                        methodPathParameters.add(((PathParamModel) beanPathParams).getPathParamName());
+                    }
+                }
+            }
+            for (String parameterName : methodPathParameters) {
+                if (!parameters.contains(parameterName)) {
+                    throw new RestClientDefinitionException("Parameter name " + parameterName + " on "
+                                                                    + interfaceModel.getRestClientClass().getName()
+                                                                    + "::" + method.getName()
+                                                                    + " doesn't match any @Path variable name.");
+                }
+                parameters.remove(parameterName);
+            }
+            if (!parameters.isEmpty()) {
+                throw new RestClientDefinitionException("Some variable names does not have matching @PathParam "
+                                                                + "defined on method " + interfaceModel.getRestClientClass()
+                        .getName()
+                                                                + "::" + method.getName());
+            }
+            List<ParamModel> entities = parameterModels.stream()
+                    .filter(ParamModel::isEntity)
+                    .collect(Collectors.toList());
+            if (entities.size() > 1) {
+                throw new RestClientDefinitionException("You cant have more than 1 entity method parameter! Check "
+                                                                + interfaceModel.getRestClientClass().getName()
+                                                                + "::" + method.getName());
+            }
+        }
+
+        private void validateHeaderDuplicityNames() {
+            ArrayList<String> names = new ArrayList<>();
+            for (ClientHeaderParamModel clientHeaderParamModel : clientHeaders) {
+                String headerName = clientHeaderParamModel.getHeaderName();
+                if (names.contains(headerName)) {
+                    throw new RestClientDefinitionException("Header name cannot be registered more then once on the same target."
+                                                                    + "See " + interfaceModel.getRestClientClass().getName());
+                }
+                names.add(headerName);
+            }
+        }
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ParamHandler.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ParamHandler.java
new file mode 100644
index 0000000..c268918
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ParamHandler.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+/**
+ * Handles behavior for each JAX-RS annotated element.
+ *
+ * @author David Kral
+ */
+@FunctionalInterface
+interface ParamHandler {
+
+    /**
+     * Handles behavior for specific annotated element.
+     *
+     * @param beanClassModel bean class model
+     * @param requestPart part of the request
+     * @param instance actual value
+     * @return updated request part
+     */
+    Object handle(BeanClassModel beanClassModel, Object requestPart, Object instance);
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ParamModel.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ParamModel.java
new file mode 100644
index 0000000..02afd7d
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ParamModel.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiFunction;
+
+import javax.ws.rs.BeanParam;
+import javax.ws.rs.CookieParam;
+import javax.ws.rs.FormParam;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.MatrixParam;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.QueryParam;
+
+import org.glassfish.jersey.model.Parameter;
+
+/**
+ * Abstract model for all elements with parameter annotation.
+ *
+ * @author David Kral
+ */
+abstract class ParamModel<T> {
+
+    public static final Map<Class<? extends Annotation>,
+            BiFunction<Builder, Annotation, ParamModel<?>>> PARAM_ANNOTATIONS = new HashMap<>();
+
+    static {
+        PARAM_ANNOTATIONS.put(PathParam.class,
+                              (builder, annotation) -> new PathParamModel(builder, (PathParam) annotation));
+        PARAM_ANNOTATIONS.put(HeaderParam.class,
+                              (builder, annotation) -> new HeaderParamModel(builder, (HeaderParam) annotation));
+        PARAM_ANNOTATIONS.put(CookieParam.class,
+                              (builder, annotation) -> new CookieParamModel(builder, (CookieParam) annotation));
+        PARAM_ANNOTATIONS.put(QueryParam.class,
+                              (builder, annotation) -> new QueryParamModel(builder, (QueryParam) annotation));
+        PARAM_ANNOTATIONS.put(MatrixParam.class,
+                              (builder, annotation) -> new MatrixParamModel(builder, (MatrixParam) annotation));
+        PARAM_ANNOTATIONS.put(FormParam.class,
+                              (builder, annotation) -> new FormParamModel(builder, (FormParam) annotation));
+        PARAM_ANNOTATIONS.put(BeanParam.class,
+                              (builder, annotation) -> new BeanParamModel(builder));
+    }
+
+    protected final InterfaceModel interfaceModel;
+    protected final Parameter parameter;
+    private final Type type;
+    private final AnnotatedElement annotatedElement;
+    private final int paramPosition;
+    private final boolean entity;
+
+    /**
+     * Processes parameter annotations and creates new instance of the model corresponding model.
+     *
+     * @param interfaceModel   model of the interface
+     * @param type             annotated element type
+     * @param annotatedElement annotated element
+     * @param position         position in method params
+     * @return new parameter instance
+     */
+    static ParamModel from(InterfaceModel interfaceModel, Type type, AnnotatedElement annotatedElement,
+                           Parameter parameter, int position) {
+        return new Builder(interfaceModel, type, annotatedElement, parameter, position).build();
+    }
+
+    ParamModel(Builder builder) {
+        this.interfaceModel = builder.interfaceModel;
+        this.type = builder.type;
+        this.annotatedElement = builder.annotatedElement;
+        this.entity = builder.entity;
+        this.paramPosition = builder.paramPosition;
+        this.parameter = builder.parameter;
+    }
+
+    /**
+     * Returns {@link Type} of the parameter.
+     *
+     * @return parameter type
+     */
+    Type getType() {
+        return type;
+    }
+
+    /**
+     * Returns annotated element.
+     *
+     * @return annotated element
+     */
+    AnnotatedElement getAnnotatedElement() {
+        return annotatedElement;
+    }
+
+    int getParamPosition() {
+        return paramPosition;
+    }
+
+    /**
+     * Returns value if parameter is entity or not.
+     *
+     * @return if parameter is entity
+     */
+    boolean isEntity() {
+        return entity;
+    }
+
+    /**
+     * Transforms parameter to be part of the request.
+     *
+     * @param requestPart     part of a request
+     * @param annotationClass annotation type
+     * @param instance        actual method parameter value
+     * @return updated request part
+     */
+    abstract T handleParameter(T requestPart, Class<?> annotationClass, Object instance);
+
+    /**
+     * Evaluates if the annotation passed in parameter is supported by this parameter.
+     *
+     * @param annotation checked annotation
+     * @return if annotation is supported
+     */
+    abstract boolean handles(Class<Annotation> annotation);
+
+    protected static class Builder {
+
+        private InterfaceModel interfaceModel;
+        private Type type;
+        private AnnotatedElement annotatedElement;
+        private Parameter parameter;
+        private boolean entity;
+        private int paramPosition;
+
+        private Builder(InterfaceModel interfaceModel,
+                        Type type,
+                        AnnotatedElement annotatedElement,
+                        Parameter parameter,
+                        int position) {
+            this.interfaceModel = interfaceModel;
+            this.type = type;
+            this.annotatedElement = annotatedElement;
+            this.parameter = parameter;
+            this.paramPosition = position;
+        }
+
+        /**
+         * Creates new ParamModel instance.
+         *
+         * @return new instance
+         */
+        ParamModel build() {
+            for (Class<? extends Annotation> paramAnnotation : PARAM_ANNOTATIONS.keySet()) {
+                Annotation annot = annotatedElement.getAnnotation(paramAnnotation);
+                if (annot != null) {
+                    return PARAM_ANNOTATIONS.get(paramAnnotation).apply(this, annot);
+                }
+            }
+
+            entity = true;
+            return new ParamModel(this) {
+                @Override
+                public Object handleParameter(Object requestPart, Class annotationClass, Object instance) {
+                    return requestPart;
+                }
+
+                @Override
+                public boolean handles(Class annotation) {
+                    return false;
+                }
+            };
+        }
+
+    }
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/PathParamModel.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/PathParamModel.java
new file mode 100644
index 0000000..6c8cd5f
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/PathParamModel.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Annotation;
+
+import javax.ws.rs.PathParam;
+import javax.ws.rs.client.WebTarget;
+
+/**
+ * Contains information about method parameter or class field which is annotated by {@link PathParam}.
+ *
+ * @author David Kral
+ */
+class PathParamModel extends ParamModel<WebTarget> {
+
+    private final String pathParamName;
+
+    PathParamModel(Builder builder, PathParam annotation) {
+        super(builder);
+        pathParamName = annotation.value();
+    }
+
+    public String getPathParamName() {
+        return pathParamName;
+    }
+
+    @Override
+    public WebTarget handleParameter(WebTarget requestPart, Class<?> annotationClass, Object instance) {
+        Object resolvedValue = interfaceModel.resolveParamValue(instance, parameter);
+        return requestPart.resolveTemplate(pathParamName, resolvedValue);
+    }
+
+    @Override
+    public boolean handles(Class<Annotation> annotation) {
+        return PathParam.class.equals(annotation);
+    }
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ProxyInvocationHandler.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ProxyInvocationHandler.java
new file mode 100644
index 0000000..2a2675e
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ProxyInvocationHandler.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+
+import javax.ws.rs.client.WebTarget;
+
+/**
+ * Invocation handler for interface proxy.
+ *
+ * @author David Kral
+ */
+class ProxyInvocationHandler implements InvocationHandler {
+
+    private final WebTarget target;
+    private final RestClientModel restClientModel;
+
+    ProxyInvocationHandler(WebTarget target,
+                           RestClientModel restClientModel) {
+        this.target = target;
+        this.restClientModel = restClientModel;
+    }
+
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args) {
+        if (method.getName().contains("toString") && (args == null || args.length == 0)) {
+            return restClientModel.toString();
+        }
+        return restClientModel.invokeMethod(target, method, args);
+    }
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/QueryParamModel.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/QueryParamModel.java
new file mode 100644
index 0000000..1f6fcfe
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/QueryParamModel.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Annotation;
+import java.util.Map;
+
+import javax.ws.rs.QueryParam;
+
+/**
+ * Model which contains information about query parameter
+ *
+ * @author David Kral
+ */
+class QueryParamModel extends ParamModel<Map<String, Object[]>> {
+
+    private final String queryParamName;
+
+    QueryParamModel(Builder builder, QueryParam annotation) {
+        super(builder);
+        queryParamName = annotation.value();
+    }
+
+    @Override
+    public Map<String, Object[]> handleParameter(Map<String, Object[]> requestPart,
+                                                 Class<?> annotationClass,
+                                                 Object instance) {
+        Object resolvedValue = interfaceModel.resolveParamValue(instance, parameter);
+        if (resolvedValue instanceof Object[]) {
+            requestPart.put(queryParamName, (Object[]) resolvedValue);
+        } else {
+            requestPart.put(queryParamName, new Object[] {resolvedValue});
+        }
+        return requestPart;
+    }
+
+    @Override
+    public boolean handles(Class<Annotation> annotation) {
+        return QueryParam.class.equals(annotation);
+    }
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ReflectionUtil.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ReflectionUtil.java
new file mode 100644
index 0000000..27344cb
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/ReflectionUtil.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Proxy;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+import org.glassfish.jersey.internal.util.ReflectionHelper;
+
+/**
+ * Created by David Kral.
+ */
+class ReflectionUtil {
+
+    static <T> T createInstance(Class<T> tClass) {
+        return AccessController.doPrivileged((PrivilegedAction<T>) () -> {
+            try {
+                return tClass.newInstance();
+            } catch (Throwable t) {
+                throw new RuntimeException("No default constructor in class " + tClass + " present. Class cannot be created!", t);
+            }
+        });
+    }
+
+    @SuppressWarnings("unchecked")
+    static <T> T createProxyInstance(Class<T> restClientClass) {
+        return AccessController.doPrivileged((PrivilegedAction<T>) () -> (T) Proxy.newProxyInstance(
+                Thread.currentThread().getContextClassLoader(),
+                new Class[] {restClientClass},
+                (proxy, m, args) -> {
+                    Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
+                            .getDeclaredConstructor(Class.class);
+                    constructor.setAccessible(true);
+                    return constructor.newInstance(restClientClass)
+                            .in(restClientClass)
+                            .unreflectSpecial(m, restClientClass)
+                            .bindTo(proxy)
+                            .invokeWithArguments(args);
+                }));
+    }
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RequestHeaderAutoDiscoverable.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RequestHeaderAutoDiscoverable.java
new file mode 100644
index 0000000..05b2155
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RequestHeaderAutoDiscoverable.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import javax.ws.rs.ConstrainedTo;
+import javax.ws.rs.RuntimeType;
+import javax.ws.rs.core.FeatureContext;
+
+import org.glassfish.jersey.internal.spi.ForcedAutoDiscoverable;
+
+/**
+ * Auto discoverable feature to bind into jersey runtime.
+ */
+@ConstrainedTo(RuntimeType.SERVER)
+public class RequestHeaderAutoDiscoverable implements ForcedAutoDiscoverable {
+    @Override
+    public void configure(FeatureContext context) {
+        if (!context.getConfiguration().isRegistered(HeadersRequestFilter.class)) {
+            context.register(HeadersRequestFilter.class);
+        }
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RestClientBuilderImpl.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RestClientBuilderImpl.java
new file mode 100644
index 0000000..00116a7
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RestClientBuilderImpl.java
@@ -0,0 +1,369 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019 Payara Foundation and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.reflect.Proxy;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.security.AccessController;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.ServiceLoader;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import javax.annotation.Priority;
+import javax.ws.rs.Priorities;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Configuration;
+import javax.ws.rs.core.Feature;
+import javax.ws.rs.core.FeatureContext;
+import javax.ws.rs.ext.ParamConverterProvider;
+
+import org.eclipse.microprofile.config.Config;
+import org.eclipse.microprofile.config.ConfigProvider;
+import org.eclipse.microprofile.rest.client.RestClientBuilder;
+import org.eclipse.microprofile.rest.client.RestClientDefinitionException;
+import org.eclipse.microprofile.rest.client.annotation.RegisterProvider;
+import org.eclipse.microprofile.rest.client.ext.AsyncInvocationInterceptor;
+import org.eclipse.microprofile.rest.client.ext.AsyncInvocationInterceptorFactory;
+import org.eclipse.microprofile.rest.client.ext.ResponseExceptionMapper;
+import org.eclipse.microprofile.rest.client.spi.RestClientListener;
+import org.glassfish.jersey.client.Initializable;
+import org.glassfish.jersey.ext.cdi1x.internal.CdiUtil;
+import org.glassfish.jersey.internal.inject.InjectionManager;
+import org.glassfish.jersey.internal.inject.InjectionManagerSupplier;
+import org.glassfish.jersey.internal.util.ReflectionHelper;
+
+/**
+ * Rest client builder implementation. Creates proxy instance of requested interface.
+ *
+ * @author David Kral
+ * @author Patrik Dudits
+ */
+class RestClientBuilderImpl implements RestClientBuilder {
+
+    private static final String CONFIG_DISABLE_DEFAULT_MAPPER = "microprofile.rest.client.disable.default.mapper";
+    private static final String CONFIG_PROVIDERS = "/mp-rest/providers";
+    private static final String CONFIG_PROVIDER_PRIORITY = "/priority";
+    private static final String PROVIDER_SEPARATOR = ",";
+
+    private final Set<ResponseExceptionMapper> responseExceptionMappers;
+    private final Set<ParamConverterProvider> paramConverterProviders;
+    private final List<AsyncInvocationInterceptorFactory> asyncInterceptorFactories;
+    private final Config config;
+    private final ConfigWrapper configWrapper;
+    private URI uri;
+    private ClientBuilder clientBuilder;
+    private Supplier<ExecutorService> executorService;
+
+    RestClientBuilderImpl() {
+        clientBuilder = ClientBuilder.newBuilder();
+        responseExceptionMappers = new HashSet<>();
+        paramConverterProviders = new HashSet<>();
+        asyncInterceptorFactories = new ArrayList<>();
+        config = ConfigProvider.getConfig();
+        configWrapper = new ConfigWrapper(clientBuilder.getConfiguration());
+        executorService = Executors::newCachedThreadPool;
+    }
+
+    @Override
+    public RestClientBuilder baseUrl(URL url) {
+        try {
+            this.uri = url.toURI();
+            return this;
+        } catch (URISyntaxException e) {
+            throw new RuntimeException(e.getMessage());
+        }
+    }
+
+    @Override
+    public RestClientBuilder connectTimeout(long timeout, TimeUnit unit) {
+        clientBuilder.connectTimeout(timeout, unit);
+        return this;
+    }
+
+    @Override
+    public RestClientBuilder readTimeout(long timeout, TimeUnit unit) {
+        clientBuilder.readTimeout(timeout, unit);
+        return this;
+    }
+
+    @Override
+    public RestClientBuilder executorService(ExecutorService executor) {
+        if (executor == null) {
+            throw new IllegalArgumentException("ExecutorService cannot be null.");
+        }
+        executorService = () -> executor;
+        return this;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> T build(Class<T> interfaceClass) throws IllegalStateException, RestClientDefinitionException {
+
+        if (uri == null) {
+            throw new IllegalStateException("Base uri/url cannot be null!");
+        }
+
+        //Provider registration part
+        processProviders(interfaceClass);
+        InjectionManagerExposer injectionManagerExposer = new InjectionManagerExposer();
+        register(injectionManagerExposer);
+
+        for (RestClientListener restClientListener : ServiceLoader.load(RestClientListener.class)) {
+            restClientListener.onNewClient(interfaceClass, this);
+        }
+
+        //We need to check first if default exception mapper was not disabled by property on builder.
+        registerExceptionMapper();
+
+        //AsyncInterceptors initialization
+        List<AsyncInvocationInterceptor> asyncInterceptors = asyncInterceptorFactories.stream()
+                .map(AsyncInvocationInterceptorFactory::newInterceptor)
+                .collect(Collectors.toList());
+        asyncInterceptors.forEach(AsyncInvocationInterceptor::prepareContext);
+
+        clientBuilder.executorService(new ExecutorServiceWrapper(executorService.get(), asyncInterceptors));
+
+        Client client = clientBuilder.build();
+        if (client instanceof Initializable) {
+            ((Initializable) client).preInitialize();
+        }
+        WebTarget webTarget = client.target(this.uri);
+
+        RestClientModel restClientModel = RestClientModel.from(interfaceClass,
+                                                               responseExceptionMappers,
+                                                               paramConverterProviders,
+                                                               asyncInterceptors,
+                                                               injectionManagerExposer.injectionManager,
+                                                               CdiUtil.getBeanManager());
+
+        return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(),
+                                          new Class[] {interfaceClass},
+                                          new ProxyInvocationHandler(webTarget, restClientModel)
+        );
+    }
+
+    private void registerExceptionMapper() {
+        Object disableDefaultMapperJersey = clientBuilder.getConfiguration().getProperty(CONFIG_DISABLE_DEFAULT_MAPPER);
+        if (disableDefaultMapperJersey != null && disableDefaultMapperJersey.equals(Boolean.FALSE)) {
+            register(new DefaultResponseExceptionMapper());
+        } else if (disableDefaultMapperJersey == null) {
+            //If property was not set on Jersey ClientBuilder, we need to check config.
+            Optional<Boolean> disableDefaultMapperConfig = config.getOptionalValue(CONFIG_DISABLE_DEFAULT_MAPPER, boolean.class);
+            if (!disableDefaultMapperConfig.isPresent() || !disableDefaultMapperConfig.get()) {
+                register(new DefaultResponseExceptionMapper());
+            }
+        }
+    }
+
+    private <T> void processProviders(Class<T> interfaceClass) {
+        Object providersFromJerseyConfig = clientBuilder.getConfiguration()
+                .getProperty(interfaceClass.getName() + CONFIG_PROVIDERS);
+        if (providersFromJerseyConfig instanceof String && !((String) providersFromJerseyConfig).isEmpty()) {
+            String[] providerArray = ((String) providersFromJerseyConfig).split(PROVIDER_SEPARATOR);
+            processConfigProviders(interfaceClass, providerArray);
+        }
+        Optional<String> providersFromConfig = config.getOptionalValue(interfaceClass.getName() + CONFIG_PROVIDERS, String.class);
+        providersFromConfig.ifPresent(providers -> {
+            if (!providers.isEmpty()) {
+                String[] providerArray = providersFromConfig.get().split(PROVIDER_SEPARATOR);
+                processConfigProviders(interfaceClass, providerArray);
+            }
+        });
+        RegisterProvider[] registerProviders = interfaceClass.getAnnotationsByType(RegisterProvider.class);
+        for (RegisterProvider registerProvider : registerProviders) {
+            register(registerProvider.value(), registerProvider.priority() < 0 ? Priorities.USER : registerProvider.priority());
+        }
+    }
+
+    private void processConfigProviders(Class<?> restClientInterface, String[] providerArray) {
+        for (String provider : providerArray) {
+            Class<?> providerClass = AccessController.doPrivileged(ReflectionHelper.classForNamePA(provider));
+            if (providerClass == null) {
+                throw new IllegalStateException("No provider class with following name found: " + provider);
+            }
+            int priority = getProviderPriority(restClientInterface, providerClass);
+            register(providerClass, priority);
+        }
+    }
+
+    private int getProviderPriority(Class<?> restClientInterface, Class<?> providerClass) {
+        String property = restClientInterface.getName() + CONFIG_PROVIDERS + "/"
+                + providerClass.getName() + CONFIG_PROVIDER_PRIORITY;
+        Object providerPriorityJersey = clientBuilder.getConfiguration().getProperty(property);
+        if (providerPriorityJersey == null) {
+            //If property was not set on Jersey ClientBuilder, we need to check MP config.
+            Optional<Integer> providerPriorityMP = config.getOptionalValue(property, int.class);
+            if (providerPriorityMP.isPresent()) {
+                return providerPriorityMP.get();
+            }
+        } else if (providerPriorityJersey instanceof Integer) {
+            return (int) providerPriorityJersey;
+        }
+        Priority priority = providerClass.getAnnotation(Priority.class);
+        return priority == null ? -1 : priority.value();
+    }
+
+    @Override
+    public Configuration getConfiguration() {
+        return configWrapper;
+    }
+
+    @Override
+    public RestClientBuilder property(String name, Object value) {
+        clientBuilder.property(name, value);
+        return this;
+    }
+
+    @Override
+    public RestClientBuilder register(Class<?> componentClass) {
+        if (isSupportedCustomProvider(componentClass)) {
+            register(ReflectionUtil.createInstance(componentClass));
+        } else {
+            clientBuilder.register(componentClass);
+        }
+        return this;
+    }
+
+    @Override
+    public RestClientBuilder register(Class<?> componentClass, int priority) {
+        if (isSupportedCustomProvider(componentClass)) {
+            register(ReflectionUtil.createInstance(componentClass), priority);
+        } else {
+            clientBuilder.register(componentClass, priority);
+        }
+        return this;
+    }
+
+    @Override
+    public RestClientBuilder register(Class<?> componentClass, Class<?>... contracts) {
+        if (isSupportedCustomProvider(componentClass)) {
+            register(ReflectionUtil.createInstance(componentClass), contracts);
+        } else {
+            clientBuilder.register(componentClass, contracts);
+        }
+        return this;
+    }
+
+    @Override
+    public RestClientBuilder register(Class<?> componentClass, Map<Class<?>, Integer> contracts) {
+        if (isSupportedCustomProvider(componentClass)) {
+            register(ReflectionUtil.createInstance(componentClass), contracts);
+        } else {
+            clientBuilder.register(componentClass, contracts);
+        }
+        return this;
+    }
+
+    @Override
+    public RestClientBuilder register(Object component) {
+        if (component instanceof ResponseExceptionMapper) {
+            ResponseExceptionMapper mapper = (ResponseExceptionMapper) component;
+            registerCustomProvider(component, -1);
+            clientBuilder.register(mapper, mapper.getPriority());
+        } else {
+            clientBuilder.register(component);
+            registerCustomProvider(component, -1);
+        }
+        return this;
+    }
+
+    @Override
+    public RestClientBuilder register(Object component, int priority) {
+        clientBuilder.register(component, priority);
+        registerCustomProvider(component, priority);
+        return this;
+    }
+
+    @Override
+    public RestClientBuilder register(Object component, Class<?>... contracts) {
+        for (Class<?> contract : contracts) {
+            if (isSupportedCustomProvider(contract)) {
+                register(component);
+            }
+        }
+        clientBuilder.register(component, contracts);
+        return this;
+    }
+
+    @Override
+    public RestClientBuilder register(Object component, Map<Class<?>, Integer> contracts) {
+        if (isSupportedCustomProvider(component.getClass())) {
+            if (component instanceof ResponseExceptionMapper) {
+                registerCustomProvider(component, contracts.get(ResponseExceptionMapper.class));
+            } else if (component instanceof ParamConverterProvider) {
+                registerCustomProvider(component, contracts.get(ParamConverterProvider.class));
+            }
+        }
+        clientBuilder.register(component, contracts);
+        return this;
+    }
+
+    private boolean isSupportedCustomProvider(Class<?> providerClass) {
+        return ResponseExceptionMapper.class.isAssignableFrom(providerClass)
+                || ParamConverterProvider.class.isAssignableFrom(providerClass)
+                || AsyncInvocationInterceptorFactory.class.isAssignableFrom(providerClass);
+    }
+
+    private void registerCustomProvider(Object instance, int priority) {
+        if (!isSupportedCustomProvider(instance.getClass())) {
+            return;
+        }
+        if (instance instanceof ResponseExceptionMapper) {
+            responseExceptionMappers.add((ResponseExceptionMapper) instance);
+            //needs to be registered separately due to it is not possible to register custom provider in jersey
+            Map<Class<?>, Integer> contracts = new HashMap<>();
+            contracts.put(ResponseExceptionMapper.class, priority);
+            configWrapper.addCustomProvider(instance.getClass(), contracts);
+        }
+        if (instance instanceof ParamConverterProvider) {
+            paramConverterProviders.add((ParamConverterProvider) instance);
+        }
+        if (instance instanceof AsyncInvocationInterceptorFactory) {
+            asyncInterceptorFactories.add((AsyncInvocationInterceptorFactory) instance);
+        }
+    }
+
+    private static class InjectionManagerExposer implements Feature {
+        InjectionManager injectionManager;
+
+        @Override
+        public boolean configure(FeatureContext context) {
+            if (context instanceof InjectionManagerSupplier) {
+                this.injectionManager = ((InjectionManagerSupplier) context).getInjectionManager();
+                return true;
+            } else {
+                throw new IllegalArgumentException("The client needs Jersey runtime to work properly");
+            }
+        }
+    }
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RestClientExtension.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RestClientExtension.java
new file mode 100644
index 0000000..58fca82
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RestClientExtension.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.enterprise.event.Observes;
+import javax.enterprise.inject.spi.AfterBeanDiscovery;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.DeploymentException;
+import javax.enterprise.inject.spi.Extension;
+import javax.enterprise.inject.spi.InjectionPoint;
+import javax.enterprise.inject.spi.ProcessAnnotatedType;
+import javax.enterprise.inject.spi.ProcessInjectionPoint;
+import javax.enterprise.inject.spi.WithAnnotations;
+import javax.enterprise.util.AnnotationLiteral;
+import javax.inject.Qualifier;
+
+import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;
+import org.eclipse.microprofile.rest.client.inject.RestClient;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+/**
+ * Filters out all interfaces annotated with {@link RegisterRestClient}
+ * and creates new Producer from each of these selected interfaces.
+ *
+ * Also adds support for injection of rest client instances to fields
+ * without {@link RestClient} annotation.
+ *
+ * @author David Kral
+ */
+public class RestClientExtension implements Extension {
+
+    private Set<Class<?>> interfaces = new HashSet<>();
+
+    /**
+     * Filters out all interfaces annotated with {@link RegisterRestClient} annotation and
+     * adds them to the collection for further processing.
+     *
+     * @param processAnnotatedType filtered annotated types
+     */
+    public void collectClientRegistrations(@Observes
+                                           @WithAnnotations({RegisterRestClient.class})
+                                                   ProcessAnnotatedType<?> processAnnotatedType) {
+        Class<?> typeDef = processAnnotatedType.getAnnotatedType().getJavaClass();
+        if (typeDef.isInterface()) {
+            interfaces.add(typeDef);
+        } else {
+            throw new DeploymentException("RegisterRestClient annotation has to be on interface! " + typeDef + " is not "
+                    + "interface.");
+        }
+    }
+
+    /**
+     * Creates new producers based on collected interfaces.
+     *
+     * @param abd after bean discovery instance
+     * @param bm bean manager instance
+     */
+    public void restClientRegistration(@Observes AfterBeanDiscovery abd, BeanManager bm) {
+        interfaces.forEach(type -> abd.addBean(new RestClientProducer(type, bm)));
+    }
+
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RestClientModel.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RestClientModel.java
new file mode 100644
index 0000000..4e81ca3
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RestClientModel.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019 Payara Foundation and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.enterprise.inject.spi.BeanManager;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.ext.ParamConverterProvider;
+
+import org.eclipse.microprofile.rest.client.ext.AsyncInvocationInterceptor;
+import org.eclipse.microprofile.rest.client.ext.ResponseExceptionMapper;
+import org.glassfish.jersey.internal.inject.InjectionManager;
+
+/**
+ * Model of the rest client interface.
+ *
+ * @author David Kral
+ * @author Patrik Dudits
+ */
+class RestClientModel {
+
+    private final InterfaceModel interfaceModel;
+    private final Map<Method, MethodModel> methodModels;
+
+    /**
+     * Creates new instance of the {@link RestClientModel} base on interface class.
+     *
+     * @param restClientClass          rest client interface
+     * @param responseExceptionMappers registered exception mappers
+     * @param paramConverterProviders  registered param converters
+     * @param asyncInterceptors        registered async interceptor factories
+     * @param injectionManager
+     * @return new instance
+     */
+    static RestClientModel from(Class<?> restClientClass,
+                                Set<ResponseExceptionMapper> responseExceptionMappers,
+                                Set<ParamConverterProvider> paramConverterProviders,
+                                List<AsyncInvocationInterceptor> asyncInterceptors,
+                                InjectionManager injectionManager,
+                                BeanManager beanManager) {
+        InterfaceModel interfaceModel = InterfaceModel.from(restClientClass,
+                                                            responseExceptionMappers,
+                                                            paramConverterProviders,
+                                                            asyncInterceptors,
+                                                            injectionManager,
+                                                            beanManager);
+        return new Builder()
+                .interfaceModel(interfaceModel)
+                .methodModels(parseMethodModels(interfaceModel))
+                .build();
+    }
+
+    private RestClientModel(Builder builder) {
+        this.interfaceModel = builder.classModel;
+        this.methodModels = builder.methodModels;
+    }
+
+    /**
+     * Invokes desired rest client method.
+     *
+     * @param baseWebTarget path to endpoint
+     * @param method        desired method
+     * @param args          actual method parameters
+     * @return method return value
+     */
+    <T> Object invokeMethod(WebTarget baseWebTarget, Method method, Object[] args) {
+        WebTarget classLevelTarget = baseWebTarget.path(interfaceModel.getPath());
+        MethodModel methodModel = methodModels.get(method);
+        if (methodModel != null) {
+            return new InterceptorInvocationContext(classLevelTarget, methodModel, method, args).proceed();
+        }
+        try {
+            if (method.isDefault()) {
+                T instance = (T) ReflectionUtil.createProxyInstance(interfaceModel.getRestClientClass());
+                return method.invoke(instance, args);
+            } else {
+                throw new UnsupportedOperationException("This method is not supported!");
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static Map<Method, MethodModel> parseMethodModels(InterfaceModel classModel) {
+        Map<Method, MethodModel> methodMap = new HashMap<>();
+        for (Method method : classModel.getRestClientClass().getMethods()) {
+            if (method.isDefault() || Modifier.isStatic(method.getModifiers())) {
+                continue;
+            }
+            //Skip method processing if method does not have HTTP annotation
+            //and is not sub resource (does not have Path annotation)
+            methodMap.put(method, MethodModel.from(classModel, method));
+        }
+        return methodMap;
+    }
+
+    private static class Builder {
+
+        private InterfaceModel classModel;
+        private Map<Method, MethodModel> methodModels;
+
+        private Builder() {
+        }
+
+        /**
+         * Rest client class converted to {@link InterfaceModel}
+         *
+         * @param classModel {@link InterfaceModel} instance
+         * @return Updated Builder instance
+         */
+        Builder interfaceModel(InterfaceModel classModel) {
+            this.classModel = classModel;
+            return this;
+        }
+
+        /**
+         * Rest client class methods converted to {@link Map} of {@link MethodModel}
+         *
+         * @param methodModels Method models
+         * @return Updated Builder instance
+         */
+        Builder methodModels(Map<Method, MethodModel> methodModels) {
+            this.methodModels = methodModels;
+            return this;
+        }
+
+        /**
+         * Creates new RestClientModel instance.
+         *
+         * @return new instance
+         */
+        public RestClientModel build() {
+            return new RestClientModel(this);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return interfaceModel.getRestClientClass().getName();
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RestClientProducer.java b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RestClientProducer.java
new file mode 100644
index 0000000..eb3acb9
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/java/org/glassfish/jersey/microprofile/restclient/RestClientProducer.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.microprofile.restclient;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.security.AccessController;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import javax.enterprise.context.Dependent;
+import javax.enterprise.context.spi.CreationalContext;
+import javax.enterprise.inject.Any;
+import javax.enterprise.inject.Default;
+import javax.enterprise.inject.spi.Bean;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.DeploymentException;
+import javax.enterprise.inject.spi.InjectionPoint;
+import javax.enterprise.inject.spi.PassivationCapable;
+import javax.enterprise.util.AnnotationLiteral;
+
+import org.eclipse.microprofile.config.Config;
+import org.eclipse.microprofile.config.ConfigProvider;
+import org.eclipse.microprofile.rest.client.RestClientBuilder;
+import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;
+import org.eclipse.microprofile.rest.client.inject.RestClient;
+import org.glassfish.jersey.internal.util.ReflectionHelper;
+
+/**
+ * Handles proper rest client injection.
+ *
+ * Contains information about the rest client interface and extracts additional parameters from
+ * config.
+ *
+ * @author David Kral
+ */
+class RestClientProducer implements Bean<Object>, PassivationCapable {
+
+    private static final String CONFIG_URL = "/mp-rest/url";
+    private static final String CONFIG_URI = "/mp-rest/uri";
+    private static final String CONFIG_SCOPE = "/mp-rest/scope";
+    private static final String CONFIG_CONNECTION_TIMEOUT = "/mp-rest/connectTimeout";
+    private static final String CONFIG_READ_TIMEOUT = "/mp-rest/readTimeout";
+
+    private final BeanManager beanManager;
+    private final Class<?> interfaceType;
+    private final Class<? extends Annotation> scope;
+    private final Config config;
+    private final String baseUrl;
+
+    /**
+     * Creates new instance of RestClientProducer.
+     *
+     * @param interfaceType rest client interface
+     * @param beanManager   bean manager
+     */
+    RestClientProducer(Class<?> interfaceType,
+                       BeanManager beanManager) {
+        this.interfaceType = interfaceType;
+        this.beanManager = beanManager;
+        this.config = ConfigProvider.getConfig();
+        this.baseUrl = getBaseUrl(interfaceType);
+        this.scope = resolveProperClientScope();
+    }
+
+    private String getBaseUrl(Class<?> interfaceType) {
+        Optional<String> uri = config.getOptionalValue(interfaceType.getName() + CONFIG_URI, String.class);
+        return uri.orElse(config.getOptionalValue(interfaceType.getName() + CONFIG_URL, String.class).orElseGet(
+                () -> {
+                    RegisterRestClient registerRestClient = interfaceType.getAnnotation(RegisterRestClient.class);
+                    if (registerRestClient != null) {
+                        return registerRestClient.baseUri();
+                    }
+                    throw new DeploymentException("This interface has to be annotated with @RegisterRestClient annotation.");
+                }
+        ));
+    }
+
+    @Override
+    public Class<?> getBeanClass() {
+        return interfaceType;
+    }
+
+    @Override
+    public Set<InjectionPoint> getInjectionPoints() {
+        return Collections.emptySet();
+    }
+
+    @Override
+    public boolean isNullable() {
+        return false;
+    }
+
+    @Override
+    public Object create(CreationalContext<Object> creationalContext) {
+        try {
+            RestClientBuilder restClientBuilder = RestClientBuilder.newBuilder().baseUrl(new URL(baseUrl));
+            config.getOptionalValue(interfaceType.getName() + CONFIG_CONNECTION_TIMEOUT, Long.class)
+                    .ifPresent(aLong -> restClientBuilder.connectTimeout(aLong, TimeUnit.MILLISECONDS));
+            config.getOptionalValue(interfaceType.getName() + CONFIG_READ_TIMEOUT, Long.class)
+                    .ifPresent(aLong -> restClientBuilder.readTimeout(aLong, TimeUnit.MILLISECONDS));
+            return restClientBuilder.build(interfaceType);
+        } catch (MalformedURLException e) {
+            throw new IllegalStateException("URL is not in valid format for Rest interface " + interfaceType.getName()
+                    + ": " + baseUrl);
+        }
+    }
+
+    @Override
+    public void destroy(Object instance, CreationalContext<Object> creationalContext) {
+    }
+
+    @Override
+    public Set<Type> getTypes() {
+        return Collections.singleton(interfaceType);
+    }
+
+    @Override
+    public Set<Annotation> getQualifiers() {
+        Set<Annotation> annotations = new HashSet<>();
+        annotations.add(new AnnotationLiteral<Default>() {});
+        annotations.add(new AnnotationLiteral<Any>() {});
+        annotations.add(RestClient.LITERAL);
+        return annotations;
+    }
+
+    @Override
+    public Class<? extends Annotation> getScope() {
+        return scope;
+    }
+
+    @Override
+    public String getName() {
+        return interfaceType.getName() + "RestClient";
+    }
+
+    @Override
+    public Set<Class<? extends Annotation>> getStereotypes() {
+        return Collections.emptySet();
+    }
+
+    @Override
+    public boolean isAlternative() {
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return "RestClientProducer [ interfaceType: " + interfaceType.getSimpleName()
+                + " ] with Qualifiers [" + getQualifiers() + "]";
+    }
+
+    @Override
+    public String getId() {
+        return interfaceType.getName();
+    }
+
+    private Class<? extends Annotation> resolveProperClientScope() {
+        String configScope = config.getOptionalValue(interfaceType.getName() + CONFIG_SCOPE, String.class).orElse(null);
+        if (configScope != null) {
+            Class<Annotation> scope = AccessController.doPrivileged(ReflectionHelper.classForNamePA(configScope));
+            if (scope == null) {
+                throw new IllegalStateException("Invalid scope from config: " + configScope);
+            }
+            return scope;
+        }
+        List<Annotation> possibleScopes = Arrays.stream(interfaceType.getDeclaredAnnotations())
+                .filter(annotation -> beanManager.isScope(annotation.annotationType()))
+                .collect(Collectors.toList());
+
+        if (possibleScopes.size() == 1) {
+            return possibleScopes.get(0).annotationType();
+        } else if (possibleScopes.isEmpty()) {
+            return Dependent.class;
+        } else {
+            throw new IllegalArgumentException("Client should have only one scope defined: "
+                                                       + interfaceType + " has " + possibleScopes);
+        }
+    }
+}
diff --git a/ext/microprofile/mp-rest-client/src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension b/ext/microprofile/mp-rest-client/src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension
new file mode 100644
index 0000000..bca39a9
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension
@@ -0,0 +1,17 @@
+#
+# Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+org.glassfish.jersey.microprofile.restclient.RestClientExtension
\ No newline at end of file
diff --git a/ext/microprofile/mp-rest-client/src/main/resources/META-INF/services/org.eclipse.microprofile.rest.client.spi.RestClientBuilderResolver b/ext/microprofile/mp-rest-client/src/main/resources/META-INF/services/org.eclipse.microprofile.rest.client.spi.RestClientBuilderResolver
new file mode 100644
index 0000000..e23142f
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/resources/META-INF/services/org.eclipse.microprofile.rest.client.spi.RestClientBuilderResolver
@@ -0,0 +1,17 @@
+#
+# Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+org.glassfish.jersey.microprofile.restclient.JerseyRestClientBuilderResolver
\ No newline at end of file
diff --git a/ext/microprofile/mp-rest-client/src/main/resources/META-INF/services/org.glassfish.jersey.internal.spi.ForcedAutoDiscoverable b/ext/microprofile/mp-rest-client/src/main/resources/META-INF/services/org.glassfish.jersey.internal.spi.ForcedAutoDiscoverable
new file mode 100644
index 0000000..d9a1262
--- /dev/null
+++ b/ext/microprofile/mp-rest-client/src/main/resources/META-INF/services/org.glassfish.jersey.internal.spi.ForcedAutoDiscoverable
@@ -0,0 +1,17 @@
+#
+# Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+org.glassfish.jersey.microprofile.restclient.RequestHeaderAutoDiscoverable
\ No newline at end of file
diff --git a/ext/microprofile/pom.xml b/ext/microprofile/pom.xml
new file mode 100644
index 0000000..3cac0c8
--- /dev/null
+++ b/ext/microprofile/pom.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>project</artifactId>
+        <groupId>org.glassfish.jersey.ext</groupId>
+        <version>2.29-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.glassfish.jersey.ext.microprofile</groupId>
+    <artifactId>project</artifactId>
+    <packaging>pom</packaging>
+
+    <modules>
+        <module>mp-rest-client</module>
+    </modules>
+
+
+</project>
\ No newline at end of file
diff --git a/ext/pom.xml b/ext/pom.xml
index 22245f1..df0ccd7 100644
--- a/ext/pom.xml
+++ b/ext/pom.xml
@@ -56,6 +56,7 @@
         <module>spring4</module>
         <module>spring5</module>
         <module>wadl-doclet</module>
+        <module>microprofile</module>
     </modules>
 
     <dependencies>
diff --git a/pom.xml b/pom.xml
index 239ede6..7f4ec50 100644
--- a/pom.xml
+++ b/pom.xml
@@ -2074,7 +2074,7 @@
         <hk2.config.version>5.1.0-RC2</hk2.config.version>
         <httpclient.version>4.5</httpclient.version> <!-- TODO: 4.5.2 doesn't work; apache client connector tests -->
         <istack.commons.runtime.version>3.0.8</istack.commons.runtime.version>
-        <jackson.version>2.9.8</jackson.version>
+        <jackson.version>2.9.9</jackson.version>
         <jackson1.version>1.9.13</jackson1.version>
         <jakarta.activation.version>1.2.1</jakarta.activation.version>
         <javassist.version>3.25.0-GA</javassist.version>
diff --git a/tests/integration/microprofile/rest-client/pom.xml b/tests/integration/microprofile/rest-client/pom.xml
new file mode 100644
index 0000000..43ec537
--- /dev/null
+++ b/tests/integration/microprofile/rest-client/pom.xml
@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>project</artifactId>
+        <groupId>org.glassfish.jersey.tests.integration</groupId>
+        <version>2.29-SNAPSHOT</version>
+        <relativePath>../../pom.xml</relativePath>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>jersey-rest-client-tck</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.glassfish.jersey.ext.microprofile</groupId>
+            <artifactId>jersey-mp-rest-client</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!-- Overrides CDI from parent pom -->
+        <dependency>
+            <groupId>javax.enterprise</groupId>
+            <artifactId>cdi-api</artifactId>
+            <version>2.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jboss.weld.se</groupId>
+            <artifactId>weld-se-core</artifactId>
+            <version>3.0.3.Final</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.smallrye</groupId>
+            <artifactId>smallrye-config</artifactId>
+            <version>1.3.6</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.eclipse.microprofile.rest.client</groupId>
+            <artifactId>microprofile-rest-client-tck</artifactId>
+            <version>1.2.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.github.tomakehurst</groupId>
+            <artifactId>wiremock</artifactId>
+            <version>2.21.0</version>
+            <scope>test</scope>
+        </dependency>
+<!--        <dependency>-->
+<!--            <groupId>org.jboss.arquillian.testng</groupId>-->
+<!--            <artifactId>arquillian-testng-container</artifactId>-->
+<!--            <version>1.4.1.Final</version>-->
+<!--            <scope>test</scope>-->
+<!--        </dependency>-->
+<!--        <dependency>-->
+<!--            <groupId>org.jboss.arquillian.container</groupId>-->
+<!--            <artifactId>arquillian-container-test-spi</artifactId>-->
+<!--            <version>1.4.1.Final</version>-->
+<!--            <scope>test</scope>-->
+<!--        </dependency>-->
+<!--        <dependency>-->
+<!--            <groupId>org.jboss.arquillian.container</groupId>-->
+<!--            <artifactId>arquillian-weld-embedded</artifactId>-->
+<!--            <version>2.0.1.Final</version>-->
+<!--            <scope>test</scope>-->
+<!--        </dependency>-->
+        <dependency>
+            <groupId>org.glassfish.jersey.test-framework</groupId>
+            <artifactId>jersey-test-framework-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.test-framework.providers</groupId>
+            <artifactId>jersey-test-framework-provider-bundle</artifactId>
+            <type>pom</type>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <suiteXmlFiles>
+                        <suiteXmlFile>tck-suite.xml</suiteXmlFile>
+                    </suiteXmlFiles>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>uk.co.deliverymind</groupId>
+                <artifactId>wiremock-maven-plugin</artifactId>
+                <version>2.7.0</version>
+                <executions>
+                    <execution>
+                        <phase>test-compile</phase>
+                        <goals>
+                            <goal>run</goal>
+                        </goals>
+                        <configuration>
+                            <dir>target/classes</dir>
+                            <params>--port=8765 --verbose</params>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <surefire.security.argline>-Djava.security.manager -Djava.security.policy=${project.build.directory}/test-classes/server.policy</surefire.security.argline>
+    </properties>
+
+
+</project>
\ No newline at end of file
diff --git a/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/message/internal/StringMessageProvider.java b/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/message/internal/StringMessageProvider.java
new file mode 100644
index 0000000..203ecbc
--- /dev/null
+++ b/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/message/internal/StringMessageProvider.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.message.internal;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+
+import javax.inject.Singleton;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+
+import org.glassfish.jersey.message.internal.AbstractMessageReaderWriterProvider;
+
+/*
+ * This class was copied from Jersey Common 2.26 due to TCK workaround reasons.
+ */
+
+/**
+ *
+ * @author Paul Sandoz
+ */
+@Produces
+@Consumes
+@Singleton
+final class StringMessageProvider extends AbstractMessageReaderWriterProvider<String> {
+
+    @Override
+    public boolean isReadable(Class<?> type, Type genericType, Annotation annotations[], MediaType mediaType) {
+        return type == String.class;
+    }
+
+    @Override
+    public String readFrom(
+            Class<String> type,
+            Type genericType,
+            Annotation annotations[],
+            MediaType mediaType,
+            MultivaluedMap<String, String> httpHeaders,
+            InputStream entityStream) throws IOException {
+        return readFromAsString(entityStream, mediaType);
+    }
+
+    @Override
+    public boolean isWriteable(Class<?> type, Type genericType, Annotation annotations[], MediaType mediaType) {
+        return type == String.class;
+    }
+
+    @Override
+    public long getSize(String s, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
+        return s.length();
+    }
+
+    @Override
+    public void writeTo(
+            String t,
+            Class<?> type,
+            Type genericType,
+            Annotation annotations[],
+            MediaType mediaType,
+            MultivaluedMap<String, Object> httpHeaders,
+            OutputStream entityStream) throws IOException {
+        writeToAsString(t, entityStream, mediaType);
+    }
+}
diff --git a/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/restclient/ApplicationResource.java b/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/restclient/ApplicationResource.java
new file mode 100644
index 0000000..0f6f8f6
--- /dev/null
+++ b/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/restclient/ApplicationResource.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.restclient;
+
+import java.util.List;
+import java.util.Map;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+
+/**
+ * Created by David Kral.
+ */
+
+@Path("resource")
+public interface ApplicationResource {
+
+    @GET
+    List<String> getValue();
+
+
+    @GET
+    @Path("map")
+    Map<String, String> getTestMap();
+
+    @POST
+    String postAppendValue(String value);
+
+    default String sayHi() {
+        return "Hi";
+    }
+
+
+}
diff --git a/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/restclient/ApplicationResourceImpl.java b/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/restclient/ApplicationResourceImpl.java
new file mode 100644
index 0000000..10c1a45
--- /dev/null
+++ b/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/restclient/ApplicationResourceImpl.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.restclient;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by David Kral.
+ */
+public class ApplicationResourceImpl implements ApplicationResource {
+    @Override
+    public List<String> getValue() {
+        return Arrays.asList("This is default value!", "Test");
+    }
+
+    @Override
+    public Map<String, String> getTestMap() {
+        Map<String, String> testMap = new HashMap<>();
+        testMap.put("firstKey", "firstValue");
+        testMap.put("secondKey", "secondValue");
+        return testMap;
+    }
+
+    @Override
+    public String postAppendValue(String value) {
+        return null;
+    }
+
+}
diff --git a/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/restclient/CorrectInterface.java b/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/restclient/CorrectInterface.java
new file mode 100644
index 0000000..8a15121
--- /dev/null
+++ b/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/restclient/CorrectInterface.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.restclient;
+
+import javax.ws.rs.BeanParam;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+
+import org.eclipse.microprofile.rest.client.annotation.ClientHeaderParam;
+
+/**
+ * Correct test interface for validation
+ *
+ * @author David Kral
+ */
+
+@Path("test/{first}")
+public interface CorrectInterface {
+
+    @GET
+    @Path("{second}")
+    @ClientHeaderParam(name = "test", value = "someValue")
+    void firstMethod(@PathParam("first") String first, @PathParam("second") String second);
+
+    @GET
+    @ClientHeaderParam(name = "test", value = "{value}")
+    void secondMethod(@PathParam("first") String first, String second);
+
+    @POST
+    @ClientHeaderParam(name = "test",
+                       value = "org.glassfish.jersey.org.glassfish.jersey.restclient.CustomHeaderGenerator.customHeader")
+    void thirdMethod(@PathParam("first") String first);
+
+    @GET
+    @Path("{second}")
+    void fourthMethod(@PathParam("first") String first, @BeanParam BeanWithPathParam second);
+
+    default String value() {
+        return "testValue";
+    }
+
+    class CustomHeaderGenerator {
+
+        public static String customHeader() {
+            return "static";
+        }
+
+    }
+
+    class BeanWithPathParam {
+
+        @PathParam("second")
+        public String pathParam;
+
+    }
+
+}
diff --git a/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/restclient/RestClientModelTest.java b/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/restclient/RestClientModelTest.java
new file mode 100644
index 0000000..186b3c6
--- /dev/null
+++ b/tests/integration/microprofile/rest-client/src/test/java/org/glassfish/jersey/restclient/RestClientModelTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.restclient;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.microprofile.rest.client.RestClientBuilder;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.test.JerseyTest;
+import org.glassfish.jersey.test.TestProperties;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Created by David Kral.
+ */
+public class RestClientModelTest extends JerseyTest {
+    @Override
+    protected ResourceConfig configure() {
+        enable(TestProperties.LOG_TRAFFIC);
+        return new ResourceConfig(ApplicationResourceImpl.class);
+    }
+
+    @Test
+    public void testGetIt() throws URISyntaxException {
+        ApplicationResource app = RestClientBuilder.newBuilder()
+                .baseUri(new URI("http://localhost:9998"))
+                .build(ApplicationResource.class);
+        List<String> collection = app.getValue();
+        assertEquals(2, collection.size());
+        assertEquals("This is default value!", collection.get(0));
+        assertEquals("Test", collection.get(1));
+
+        Map<String, String> map = app.getTestMap();
+        assertEquals(2, map.size());
+        assertEquals("firstValue", map.get("firstKey"));
+        assertEquals("secondValue", map.get("secondKey"));
+
+        assertEquals("Hi", app.sayHi());
+    }
+}
diff --git a/tests/integration/microprofile/rest-client/src/test/resources/arquillian.xml b/tests/integration/microprofile/rest-client/src/test/resources/arquillian.xml
new file mode 100644
index 0000000..e748760
--- /dev/null
+++ b/tests/integration/microprofile/rest-client/src/test/resources/arquillian.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+
+    This program and the accompanying materials are made available under the
+    terms of the Eclipse Public License v. 2.0, which is available at
+    http://www.eclipse.org/legal/epl-2.0.
+
+    This Source Code may also be made available under the following Secondary
+    Licenses when the conditions for such availability set forth in the
+    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+    version 2 with the GNU Classpath Exception, which is available at
+    https://www.gnu.org/software/classpath/license.html.
+
+    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<arquillian xmlns="http://jboss.org/schema/arquillian"
+            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+            xsi:schemaLocation="
+        http://jboss.org/schema/arquillian
+        http://jboss.org/schema/arquillian/arquillian_1_0.xsd">
+
+    <engine>
+        <property name="deploymentExportPath">target/deployments</property>
+    </engine>
+</arquillian>
diff --git a/tests/integration/microprofile/rest-client/src/test/resources/server.policy b/tests/integration/microprofile/rest-client/src/test/resources/server.policy
new file mode 100644
index 0000000..0a3ee57
--- /dev/null
+++ b/tests/integration/microprofile/rest-client/src/test/resources/server.policy
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+grant {
+  permission java.security.AllPermission;
+};
diff --git a/tests/integration/microprofile/rest-client/tck-suite.xml b/tests/integration/microprofile/rest-client/tck-suite.xml
new file mode 100644
index 0000000..3106d69
--- /dev/null
+++ b/tests/integration/microprofile/rest-client/tck-suite.xml
@@ -0,0 +1,42 @@
+<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!--
+
+    Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+
+    This program and the accompanying materials are made available under the
+    terms of the Eclipse Public License v. 2.0, which is available at
+    http://www.eclipse.org/legal/epl-2.0.
+
+    This Source Code may also be made available under the following Secondary
+    Licenses when the conditions for such availability set forth in the
+    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+    version 2 with the GNU Classpath Exception, which is available at
+    https://www.gnu.org/software/classpath/license.html.
+
+    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+<suite name="microprofile-rest-client-TCK" verbose="2" configfailurepolicy="continue" >
+
+    <test name="microprofile-rest-client TCK">
+        <packages>
+            <package name="org.eclipse.microprofile.rest.client.tck.*">
+            </package>
+        </packages>
+        <classes>
+            <class name="org.eclipse.microprofile.rest.client.tck.InvokeWithJsonBProviderTest">
+                <methods>
+                    <exclude name="testGetExecutesForBothClients"/> <!-- Json in this test is malformed -->
+                </methods>
+            </class>
+        </classes>
+<!--        <classes>-->
+<!--            <class name="org.eclipse.microprofile.rest.client.tck.asynctests.AsyncMethodTest">-->
+<!--                <methods>-->
+<!--                    <include name="testAsyncInvocationInterceptorProvider"/>-->
+<!--                </methods>-->
+<!--            </class>-->
+<!--        </classes>-->
+    </test>
+
+</suite>
\ No newline at end of file
diff --git a/tests/integration/pom.xml b/tests/integration/pom.xml
index da87c12..8f6c1fc 100644
--- a/tests/integration/pom.xml
+++ b/tests/integration/pom.xml
@@ -136,6 +136,7 @@
         <module>tracing-support</module>
         <module>microprofile/config/helidon</module>
         <module>microprofile/config/webapp</module>
+<!--        <module>microprofile/rest-client</module>-->
     </modules>
 
     <profiles>