diff --git a/sdk/include/opentelemetry/sdk/configuration/console_log_record_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/console_log_record_exporter_builder.h
new file mode 100644
index 0000000000..29d99bec5c
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/console_log_record_exporter_builder.h
@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/console_log_record_exporter_configuration.h"
+#include "opentelemetry/sdk/logs/exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ConsoleLogRecordExporterBuilder
+{
+public:
+  ConsoleLogRecordExporterBuilder()                                              = default;
+  ConsoleLogRecordExporterBuilder(ConsoleLogRecordExporterBuilder &&)            = default;
+  ConsoleLogRecordExporterBuilder(const ConsoleLogRecordExporterBuilder &)       = default;
+  ConsoleLogRecordExporterBuilder &operator=(ConsoleLogRecordExporterBuilder &&) = default;
+  ConsoleLogRecordExporterBuilder &operator=(const ConsoleLogRecordExporterBuilder &other) =
+      default;
+  virtual ~ConsoleLogRecordExporterBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::logs::LogRecordExporter> Build(
+      const opentelemetry::sdk::configuration::ConsoleLogRecordExporterConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/console_push_metric_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/console_push_metric_exporter_builder.h
new file mode 100644
index 0000000000..0fe0725aa7
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/console_push_metric_exporter_builder.h
@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/console_push_metric_exporter_configuration.h"
+#include "opentelemetry/sdk/metrics/push_metric_exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ConsolePushMetricExporterBuilder
+{
+public:
+  ConsolePushMetricExporterBuilder()                                               = default;
+  ConsolePushMetricExporterBuilder(ConsolePushMetricExporterBuilder &&)            = default;
+  ConsolePushMetricExporterBuilder(const ConsolePushMetricExporterBuilder &)       = default;
+  ConsolePushMetricExporterBuilder &operator=(ConsolePushMetricExporterBuilder &&) = default;
+  ConsolePushMetricExporterBuilder &operator=(const ConsolePushMetricExporterBuilder &other) =
+      default;
+  virtual ~ConsolePushMetricExporterBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::metrics::PushMetricExporter> Build(
+      const opentelemetry::sdk::configuration::ConsolePushMetricExporterConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/console_span_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/console_span_exporter_builder.h
new file mode 100644
index 0000000000..0db9ba9e5b
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/console_span_exporter_builder.h
@@ -0,0 +1,34 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/console_span_exporter_configuration.h"
+#include "opentelemetry/sdk/trace/exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ConsoleSpanExporterBuilder
+{
+public:
+  ConsoleSpanExporterBuilder()                                                   = default;
+  ConsoleSpanExporterBuilder(ConsoleSpanExporterBuilder &&)                      = default;
+  ConsoleSpanExporterBuilder(const ConsoleSpanExporterBuilder &)                 = default;
+  ConsoleSpanExporterBuilder &operator=(ConsoleSpanExporterBuilder &&)           = default;
+  ConsoleSpanExporterBuilder &operator=(const ConsoleSpanExporterBuilder &other) = default;
+  virtual ~ConsoleSpanExporterBuilder()                                          = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::trace::SpanExporter> Build(
+      const opentelemetry::sdk::configuration::ConsoleSpanExporterConfiguration *model) const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/extension_log_record_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/extension_log_record_exporter_builder.h
new file mode 100644
index 0000000000..e9a7c102cb
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/extension_log_record_exporter_builder.h
@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/extension_log_record_exporter_configuration.h"
+#include "opentelemetry/sdk/logs/exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ExtensionLogRecordExporterBuilder
+{
+public:
+  ExtensionLogRecordExporterBuilder()                                                = default;
+  ExtensionLogRecordExporterBuilder(ExtensionLogRecordExporterBuilder &&)            = default;
+  ExtensionLogRecordExporterBuilder(const ExtensionLogRecordExporterBuilder &)       = default;
+  ExtensionLogRecordExporterBuilder &operator=(ExtensionLogRecordExporterBuilder &&) = default;
+  ExtensionLogRecordExporterBuilder &operator=(const ExtensionLogRecordExporterBuilder &other) =
+      default;
+  virtual ~ExtensionLogRecordExporterBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::logs::LogRecordExporter> Build(
+      const opentelemetry::sdk::configuration::ExtensionLogRecordExporterConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/extension_log_record_processor_builder.h b/sdk/include/opentelemetry/sdk/configuration/extension_log_record_processor_builder.h
new file mode 100644
index 0000000000..51d21fd010
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/extension_log_record_processor_builder.h
@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/extension_log_record_processor_configuration.h"
+#include "opentelemetry/sdk/logs/processor.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ExtensionLogRecordProcessorBuilder
+{
+public:
+  ExtensionLogRecordProcessorBuilder()                                                 = default;
+  ExtensionLogRecordProcessorBuilder(ExtensionLogRecordProcessorBuilder &&)            = default;
+  ExtensionLogRecordProcessorBuilder(const ExtensionLogRecordProcessorBuilder &)       = default;
+  ExtensionLogRecordProcessorBuilder &operator=(ExtensionLogRecordProcessorBuilder &&) = default;
+  ExtensionLogRecordProcessorBuilder &operator=(const ExtensionLogRecordProcessorBuilder &other) =
+      default;
+  virtual ~ExtensionLogRecordProcessorBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::logs::LogRecordProcessor> Build(
+      const opentelemetry::sdk::configuration::ExtensionLogRecordProcessorConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/extension_pull_metric_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/extension_pull_metric_exporter_builder.h
new file mode 100644
index 0000000000..fc621c2b78
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/extension_pull_metric_exporter_builder.h
@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/extension_pull_metric_exporter_configuration.h"
+#include "opentelemetry/sdk/metrics/metric_reader.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ExtensionPullMetricExporterBuilder
+{
+public:
+  ExtensionPullMetricExporterBuilder()                                                 = default;
+  ExtensionPullMetricExporterBuilder(ExtensionPullMetricExporterBuilder &&)            = default;
+  ExtensionPullMetricExporterBuilder(const ExtensionPullMetricExporterBuilder &)       = default;
+  ExtensionPullMetricExporterBuilder &operator=(ExtensionPullMetricExporterBuilder &&) = default;
+  ExtensionPullMetricExporterBuilder &operator=(const ExtensionPullMetricExporterBuilder &other) =
+      default;
+  virtual ~ExtensionPullMetricExporterBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::metrics::MetricReader> Build(
+      const opentelemetry::sdk::configuration::ExtensionPullMetricExporterConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/extension_push_metric_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/extension_push_metric_exporter_builder.h
new file mode 100644
index 0000000000..b3eacfc770
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/extension_push_metric_exporter_builder.h
@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/extension_push_metric_exporter_configuration.h"
+#include "opentelemetry/sdk/metrics/push_metric_exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ExtensionPushMetricExporterBuilder
+{
+public:
+  ExtensionPushMetricExporterBuilder()                                                 = default;
+  ExtensionPushMetricExporterBuilder(ExtensionPushMetricExporterBuilder &&)            = default;
+  ExtensionPushMetricExporterBuilder(const ExtensionPushMetricExporterBuilder &)       = default;
+  ExtensionPushMetricExporterBuilder &operator=(ExtensionPushMetricExporterBuilder &&) = default;
+  ExtensionPushMetricExporterBuilder &operator=(const ExtensionPushMetricExporterBuilder &other) =
+      default;
+  virtual ~ExtensionPushMetricExporterBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::metrics::PushMetricExporter> Build(
+      const opentelemetry::sdk::configuration::ExtensionPushMetricExporterConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/extension_sampler_builder.h b/sdk/include/opentelemetry/sdk/configuration/extension_sampler_builder.h
new file mode 100644
index 0000000000..3ac5d7263b
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/extension_sampler_builder.h
@@ -0,0 +1,34 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/extension_sampler_configuration.h"
+#include "opentelemetry/sdk/trace/sampler.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ExtensionSamplerBuilder
+{
+public:
+  ExtensionSamplerBuilder()                                                = default;
+  ExtensionSamplerBuilder(ExtensionSamplerBuilder &&)                      = default;
+  ExtensionSamplerBuilder(const ExtensionSamplerBuilder &)                 = default;
+  ExtensionSamplerBuilder &operator=(ExtensionSamplerBuilder &&)           = default;
+  ExtensionSamplerBuilder &operator=(const ExtensionSamplerBuilder &other) = default;
+  virtual ~ExtensionSamplerBuilder()                                       = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::trace::Sampler> Build(
+      const opentelemetry::sdk::configuration::ExtensionSamplerConfiguration *model) const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/extension_span_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/extension_span_exporter_builder.h
new file mode 100644
index 0000000000..50a5ac12d7
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/extension_span_exporter_builder.h
@@ -0,0 +1,34 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/extension_span_exporter_configuration.h"
+#include "opentelemetry/sdk/trace/exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ExtensionSpanExporterBuilder
+{
+public:
+  ExtensionSpanExporterBuilder()                                                     = default;
+  ExtensionSpanExporterBuilder(ExtensionSpanExporterBuilder &&)                      = default;
+  ExtensionSpanExporterBuilder(const ExtensionSpanExporterBuilder &)                 = default;
+  ExtensionSpanExporterBuilder &operator=(ExtensionSpanExporterBuilder &&)           = default;
+  ExtensionSpanExporterBuilder &operator=(const ExtensionSpanExporterBuilder &other) = default;
+  virtual ~ExtensionSpanExporterBuilder()                                            = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::trace::SpanExporter> Build(
+      const opentelemetry::sdk::configuration::ExtensionSpanExporterConfiguration *model) const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/extension_span_processor_builder.h b/sdk/include/opentelemetry/sdk/configuration/extension_span_processor_builder.h
new file mode 100644
index 0000000000..86732e7817
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/extension_span_processor_builder.h
@@ -0,0 +1,35 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/extension_span_processor_configuration.h"
+#include "opentelemetry/sdk/trace/processor.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ExtensionSpanProcessorBuilder
+{
+public:
+  ExtensionSpanProcessorBuilder()                                                      = default;
+  ExtensionSpanProcessorBuilder(ExtensionSpanProcessorBuilder &&)                      = default;
+  ExtensionSpanProcessorBuilder(const ExtensionSpanProcessorBuilder &)                 = default;
+  ExtensionSpanProcessorBuilder &operator=(ExtensionSpanProcessorBuilder &&)           = default;
+  ExtensionSpanProcessorBuilder &operator=(const ExtensionSpanProcessorBuilder &other) = default;
+  virtual ~ExtensionSpanProcessorBuilder()                                             = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::trace::SpanProcessor> Build(
+      const opentelemetry::sdk::configuration::ExtensionSpanProcessorConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/otlp_file_log_record_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/otlp_file_log_record_exporter_builder.h
new file mode 100644
index 0000000000..c7be2657cc
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/otlp_file_log_record_exporter_builder.h
@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/otlp_file_log_record_exporter_configuration.h"
+#include "opentelemetry/sdk/logs/exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class OtlpFileLogRecordExporterBuilder
+{
+public:
+  OtlpFileLogRecordExporterBuilder()                                               = default;
+  OtlpFileLogRecordExporterBuilder(OtlpFileLogRecordExporterBuilder &&)            = default;
+  OtlpFileLogRecordExporterBuilder(const OtlpFileLogRecordExporterBuilder &)       = default;
+  OtlpFileLogRecordExporterBuilder &operator=(OtlpFileLogRecordExporterBuilder &&) = default;
+  OtlpFileLogRecordExporterBuilder &operator=(const OtlpFileLogRecordExporterBuilder &other) =
+      default;
+  virtual ~OtlpFileLogRecordExporterBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::logs::LogRecordExporter> Build(
+      const opentelemetry::sdk::configuration::OtlpFileLogRecordExporterConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/otlp_file_push_metric_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/otlp_file_push_metric_exporter_builder.h
new file mode 100644
index 0000000000..79d60f1ca4
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/otlp_file_push_metric_exporter_builder.h
@@ -0,0 +1,37 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/otlp_file_push_metric_exporter_configuration.h"
+#include "opentelemetry/sdk/configuration/push_metric_exporter_configuration.h"
+#include "opentelemetry/sdk/metrics/push_metric_exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class OtlpFilePushMetricExporterBuilder
+{
+public:
+  OtlpFilePushMetricExporterBuilder()                                                = default;
+  OtlpFilePushMetricExporterBuilder(OtlpFilePushMetricExporterBuilder &&)            = default;
+  OtlpFilePushMetricExporterBuilder(const OtlpFilePushMetricExporterBuilder &)       = default;
+  OtlpFilePushMetricExporterBuilder &operator=(OtlpFilePushMetricExporterBuilder &&) = default;
+  OtlpFilePushMetricExporterBuilder &operator=(const OtlpFilePushMetricExporterBuilder &other) =
+      default;
+  virtual ~OtlpFilePushMetricExporterBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::metrics::PushMetricExporter> Build(
+      const opentelemetry::sdk::configuration::OtlpFilePushMetricExporterConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/otlp_file_span_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/otlp_file_span_exporter_builder.h
new file mode 100644
index 0000000000..c2bec566df
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/otlp_file_span_exporter_builder.h
@@ -0,0 +1,34 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/otlp_file_span_exporter_configuration.h"
+#include "opentelemetry/sdk/trace/exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class OtlpFileSpanExporterBuilder
+{
+public:
+  OtlpFileSpanExporterBuilder()                                                    = default;
+  OtlpFileSpanExporterBuilder(OtlpFileSpanExporterBuilder &&)                      = default;
+  OtlpFileSpanExporterBuilder(const OtlpFileSpanExporterBuilder &)                 = default;
+  OtlpFileSpanExporterBuilder &operator=(OtlpFileSpanExporterBuilder &&)           = default;
+  OtlpFileSpanExporterBuilder &operator=(const OtlpFileSpanExporterBuilder &other) = default;
+  virtual ~OtlpFileSpanExporterBuilder()                                           = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::trace::SpanExporter> Build(
+      const opentelemetry::sdk::configuration::OtlpFileSpanExporterConfiguration *model) const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/otlp_grpc_log_record_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/otlp_grpc_log_record_exporter_builder.h
new file mode 100644
index 0000000000..e560e6bc7d
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/otlp_grpc_log_record_exporter_builder.h
@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/otlp_grpc_log_record_exporter_configuration.h"
+#include "opentelemetry/sdk/logs/exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class OtlpGrpcLogRecordExporterBuilder
+{
+public:
+  OtlpGrpcLogRecordExporterBuilder()                                               = default;
+  OtlpGrpcLogRecordExporterBuilder(OtlpGrpcLogRecordExporterBuilder &&)            = default;
+  OtlpGrpcLogRecordExporterBuilder(const OtlpGrpcLogRecordExporterBuilder &)       = default;
+  OtlpGrpcLogRecordExporterBuilder &operator=(OtlpGrpcLogRecordExporterBuilder &&) = default;
+  OtlpGrpcLogRecordExporterBuilder &operator=(const OtlpGrpcLogRecordExporterBuilder &other) =
+      default;
+  virtual ~OtlpGrpcLogRecordExporterBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::logs::LogRecordExporter> Build(
+      const opentelemetry::sdk::configuration::OtlpGrpcLogRecordExporterConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/otlp_grpc_push_metric_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/otlp_grpc_push_metric_exporter_builder.h
new file mode 100644
index 0000000000..61adf7c089
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/otlp_grpc_push_metric_exporter_builder.h
@@ -0,0 +1,37 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/otlp_grpc_push_metric_exporter_configuration.h"
+#include "opentelemetry/sdk/configuration/push_metric_exporter_configuration.h"
+#include "opentelemetry/sdk/metrics/push_metric_exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class OtlpGrpcPushMetricExporterBuilder
+{
+public:
+  OtlpGrpcPushMetricExporterBuilder()                                                = default;
+  OtlpGrpcPushMetricExporterBuilder(OtlpGrpcPushMetricExporterBuilder &&)            = default;
+  OtlpGrpcPushMetricExporterBuilder(const OtlpGrpcPushMetricExporterBuilder &)       = default;
+  OtlpGrpcPushMetricExporterBuilder &operator=(OtlpGrpcPushMetricExporterBuilder &&) = default;
+  OtlpGrpcPushMetricExporterBuilder &operator=(const OtlpGrpcPushMetricExporterBuilder &other) =
+      default;
+  virtual ~OtlpGrpcPushMetricExporterBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::metrics::PushMetricExporter> Build(
+      const opentelemetry::sdk::configuration::OtlpGrpcPushMetricExporterConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/otlp_grpc_span_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/otlp_grpc_span_exporter_builder.h
new file mode 100644
index 0000000000..79550ee830
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/otlp_grpc_span_exporter_builder.h
@@ -0,0 +1,34 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/otlp_grpc_span_exporter_configuration.h"
+#include "opentelemetry/sdk/trace/exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class OtlpGrpcSpanExporterBuilder
+{
+public:
+  OtlpGrpcSpanExporterBuilder()                                                    = default;
+  OtlpGrpcSpanExporterBuilder(OtlpGrpcSpanExporterBuilder &&)                      = default;
+  OtlpGrpcSpanExporterBuilder(const OtlpGrpcSpanExporterBuilder &)                 = default;
+  OtlpGrpcSpanExporterBuilder &operator=(OtlpGrpcSpanExporterBuilder &&)           = default;
+  OtlpGrpcSpanExporterBuilder &operator=(const OtlpGrpcSpanExporterBuilder &other) = default;
+  virtual ~OtlpGrpcSpanExporterBuilder()                                           = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::trace::SpanExporter> Build(
+      const opentelemetry::sdk::configuration::OtlpGrpcSpanExporterConfiguration *model) const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/otlp_http_log_record_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/otlp_http_log_record_exporter_builder.h
new file mode 100644
index 0000000000..a8d1313da4
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/otlp_http_log_record_exporter_builder.h
@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/otlp_http_log_record_exporter_configuration.h"
+#include "opentelemetry/sdk/logs/exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class OtlpHttpLogRecordExporterBuilder
+{
+public:
+  OtlpHttpLogRecordExporterBuilder()                                               = default;
+  OtlpHttpLogRecordExporterBuilder(OtlpHttpLogRecordExporterBuilder &&)            = default;
+  OtlpHttpLogRecordExporterBuilder(const OtlpHttpLogRecordExporterBuilder &)       = default;
+  OtlpHttpLogRecordExporterBuilder &operator=(OtlpHttpLogRecordExporterBuilder &&) = default;
+  OtlpHttpLogRecordExporterBuilder &operator=(const OtlpHttpLogRecordExporterBuilder &other) =
+      default;
+  virtual ~OtlpHttpLogRecordExporterBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::logs::LogRecordExporter> Build(
+      const opentelemetry::sdk::configuration::OtlpHttpLogRecordExporterConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/otlp_http_push_metric_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/otlp_http_push_metric_exporter_builder.h
new file mode 100644
index 0000000000..c407eca52c
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/otlp_http_push_metric_exporter_builder.h
@@ -0,0 +1,37 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/otlp_http_push_metric_exporter_configuration.h"
+#include "opentelemetry/sdk/configuration/push_metric_exporter_configuration.h"
+#include "opentelemetry/sdk/metrics/push_metric_exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class OtlpHttpPushMetricExporterBuilder
+{
+public:
+  OtlpHttpPushMetricExporterBuilder()                                                = default;
+  OtlpHttpPushMetricExporterBuilder(OtlpHttpPushMetricExporterBuilder &&)            = default;
+  OtlpHttpPushMetricExporterBuilder(const OtlpHttpPushMetricExporterBuilder &)       = default;
+  OtlpHttpPushMetricExporterBuilder &operator=(OtlpHttpPushMetricExporterBuilder &&) = default;
+  OtlpHttpPushMetricExporterBuilder &operator=(const OtlpHttpPushMetricExporterBuilder &other) =
+      default;
+  virtual ~OtlpHttpPushMetricExporterBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::metrics::PushMetricExporter> Build(
+      const opentelemetry::sdk::configuration::OtlpHttpPushMetricExporterConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/otlp_http_span_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/otlp_http_span_exporter_builder.h
new file mode 100644
index 0000000000..8dda6f2b9e
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/otlp_http_span_exporter_builder.h
@@ -0,0 +1,34 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/otlp_http_span_exporter_configuration.h"
+#include "opentelemetry/sdk/trace/exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class OtlpHttpSpanExporterBuilder
+{
+public:
+  OtlpHttpSpanExporterBuilder()                                                    = default;
+  OtlpHttpSpanExporterBuilder(OtlpHttpSpanExporterBuilder &&)                      = default;
+  OtlpHttpSpanExporterBuilder(const OtlpHttpSpanExporterBuilder &)                 = default;
+  OtlpHttpSpanExporterBuilder &operator=(OtlpHttpSpanExporterBuilder &&)           = default;
+  OtlpHttpSpanExporterBuilder &operator=(const OtlpHttpSpanExporterBuilder &other) = default;
+  virtual ~OtlpHttpSpanExporterBuilder()                                           = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::trace::SpanExporter> Build(
+      const opentelemetry::sdk::configuration::OtlpHttpSpanExporterConfiguration *model) const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/prometheus_pull_metric_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/prometheus_pull_metric_exporter_builder.h
new file mode 100644
index 0000000000..4a4496dc49
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/prometheus_pull_metric_exporter_builder.h
@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/prometheus_pull_metric_exporter_configuration.h"
+#include "opentelemetry/sdk/metrics/metric_reader.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class PrometheusPullMetricExporterBuilder
+{
+public:
+  PrometheusPullMetricExporterBuilder()                                                  = default;
+  PrometheusPullMetricExporterBuilder(PrometheusPullMetricExporterBuilder &&)            = default;
+  PrometheusPullMetricExporterBuilder(const PrometheusPullMetricExporterBuilder &)       = default;
+  PrometheusPullMetricExporterBuilder &operator=(PrometheusPullMetricExporterBuilder &&) = default;
+  PrometheusPullMetricExporterBuilder &operator=(const PrometheusPullMetricExporterBuilder &other) =
+      default;
+  virtual ~PrometheusPullMetricExporterBuilder() = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::metrics::MetricReader> Build(
+      const opentelemetry::sdk::configuration::PrometheusPullMetricExporterConfiguration *model)
+      const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/registry.h b/sdk/include/opentelemetry/sdk/configuration/registry.h
new file mode 100644
index 0000000000..81d38d2ef6
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/registry.h
@@ -0,0 +1,283 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <map>
+#include <string>
+
+#include "opentelemetry/sdk/configuration/console_log_record_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/console_push_metric_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/console_span_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/extension_log_record_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/extension_log_record_processor_builder.h"
+#include "opentelemetry/sdk/configuration/extension_pull_metric_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/extension_push_metric_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/extension_sampler_builder.h"
+#include "opentelemetry/sdk/configuration/extension_span_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/extension_span_processor_builder.h"
+#include "opentelemetry/sdk/configuration/otlp_file_log_record_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/otlp_file_push_metric_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/otlp_file_span_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/otlp_grpc_log_record_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/otlp_grpc_push_metric_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/otlp_grpc_span_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/otlp_http_log_record_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/otlp_http_push_metric_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/otlp_http_span_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/prometheus_pull_metric_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/text_map_propagator_builder.h"
+#include "opentelemetry/sdk/configuration/zipkin_span_exporter_builder.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class Registry
+{
+public:
+  Registry();
+  Registry(Registry &&)                      = delete;
+  Registry(const Registry &)                 = delete;
+  Registry &operator=(Registry &&)           = delete;
+  Registry &operator=(const Registry &other) = delete;
+
+  ~Registry() = default;
+
+  /* Core optional components. */
+
+  const OtlpHttpSpanExporterBuilder *GetOtlpHttpSpanBuilder() const
+  {
+    return otlp_http_span_builder_.get();
+  }
+
+  void SetOtlpHttpSpanBuilder(std::unique_ptr<OtlpHttpSpanExporterBuilder> &&builder)
+  {
+    otlp_http_span_builder_ = std::move(builder);
+  }
+
+  const OtlpGrpcSpanExporterBuilder *GetOtlpGrpcSpanBuilder() const
+  {
+    return otlp_grpc_span_builder_.get();
+  }
+
+  void SetOtlpGrpcSpanBuilder(std::unique_ptr<OtlpGrpcSpanExporterBuilder> &&builder)
+  {
+    otlp_grpc_span_builder_ = std::move(builder);
+  }
+
+  const OtlpFileSpanExporterBuilder *GetOtlpFileSpanBuilder() const
+  {
+    return otlp_file_span_builder_.get();
+  }
+
+  void SetOtlpFileSpanBuilder(std::unique_ptr<OtlpFileSpanExporterBuilder> &&builder)
+  {
+    otlp_file_span_builder_ = std::move(builder);
+  }
+
+  const ConsoleSpanExporterBuilder *GetConsoleSpanBuilder() const
+  {
+    return console_span_builder_.get();
+  }
+
+  void SetConsoleSpanBuilder(std::unique_ptr<ConsoleSpanExporterBuilder> &&builder)
+  {
+    console_span_builder_ = std::move(builder);
+  }
+
+  const ZipkinSpanExporterBuilder *GetZipkinSpanBuilder() const
+  {
+    return zipkin_span_builder_.get();
+  }
+
+  void SetZipkinSpanBuilder(std::unique_ptr<ZipkinSpanExporterBuilder> &&builder)
+  {
+    zipkin_span_builder_ = std::move(builder);
+  }
+
+  const OtlpHttpPushMetricExporterBuilder *GetOtlpHttpPushMetricExporterBuilder() const
+  {
+    return otlp_http_push_metric_builder_.get();
+  }
+
+  void SetOtlpHttpPushMetricExporterBuilder(
+      std::unique_ptr<OtlpHttpPushMetricExporterBuilder> &&builder)
+  {
+    otlp_http_push_metric_builder_ = std::move(builder);
+  }
+
+  const OtlpGrpcPushMetricExporterBuilder *GetOtlpGrpcPushMetricExporterBuilder() const
+  {
+    return otlp_grpc_push_metric_builder_.get();
+  }
+
+  void SetOtlpGrpcPushMetricExporterBuilder(
+      std::unique_ptr<OtlpGrpcPushMetricExporterBuilder> &&builder)
+  {
+    otlp_grpc_push_metric_builder_ = std::move(builder);
+  }
+
+  const OtlpFilePushMetricExporterBuilder *GetOtlpFilePushMetricExporterBuilder() const
+  {
+    return otlp_file_push_metric_builder_.get();
+  }
+
+  void SetOtlpFilePushMetricExporterBuilder(
+      std::unique_ptr<OtlpFilePushMetricExporterBuilder> &&builder)
+  {
+    otlp_file_push_metric_builder_ = std::move(builder);
+  }
+
+  const ConsolePushMetricExporterBuilder *GetConsolePushMetricExporterBuilder() const
+  {
+    return console_metric_builder_.get();
+  }
+
+  void SetConsolePushMetricExporterBuilder(
+      std::unique_ptr<ConsolePushMetricExporterBuilder> &&builder)
+  {
+    console_metric_builder_ = std::move(builder);
+  }
+
+  const PrometheusPullMetricExporterBuilder *GetPrometheusPullMetricExporterBuilder() const
+  {
+    return prometheus_metric_builder_.get();
+  }
+
+  void SetPrometheusPullMetricExporterBuilder(
+      std::unique_ptr<PrometheusPullMetricExporterBuilder> &&builder)
+  {
+    prometheus_metric_builder_ = std::move(builder);
+  }
+
+  const OtlpHttpLogRecordExporterBuilder *GetOtlpHttpLogRecordBuilder() const
+  {
+    return otlp_http_log_record_builder_.get();
+  }
+
+  void SetOtlpHttpLogRecordBuilder(std::unique_ptr<OtlpHttpLogRecordExporterBuilder> &&builder)
+  {
+    otlp_http_log_record_builder_ = std::move(builder);
+  }
+
+  const OtlpGrpcLogRecordExporterBuilder *GetOtlpGrpcLogRecordBuilder() const
+  {
+    return otlp_grpc_log_record_builder_.get();
+  }
+
+  void SetOtlpGrpcLogRecordBuilder(std::unique_ptr<OtlpGrpcLogRecordExporterBuilder> &&builder)
+  {
+    otlp_grpc_log_record_builder_ = std::move(builder);
+  }
+
+  const OtlpFileLogRecordExporterBuilder *GetOtlpFileLogRecordBuilder() const
+  {
+    return otlp_file_log_record_builder_.get();
+  }
+
+  void SetOtlpFileLogRecordBuilder(std::unique_ptr<OtlpFileLogRecordExporterBuilder> &&builder)
+  {
+    otlp_file_log_record_builder_ = std::move(builder);
+  }
+
+  const ConsoleLogRecordExporterBuilder *GetConsoleLogRecordBuilder() const
+  {
+    return console_log_record_builder_.get();
+  }
+
+  void SetConsoleLogRecordBuilder(std::unique_ptr<ConsoleLogRecordExporterBuilder> &&builder)
+  {
+    console_log_record_builder_ = std::move(builder);
+  }
+
+  /* Extension points */
+
+  const TextMapPropagatorBuilder *GetTextMapPropagatorBuilder(const std::string &name) const;
+
+  void SetTextMapPropagatorBuilder(const std::string &name,
+                                   std::unique_ptr<TextMapPropagatorBuilder> &&builder);
+
+  const ExtensionSamplerBuilder *GetExtensionSamplerBuilder(const std::string &name) const;
+
+  void SetExtensionSamplerBuilder(const std::string &name,
+                                  std::unique_ptr<ExtensionSamplerBuilder> &&builder);
+
+  const ExtensionSpanExporterBuilder *GetExtensionSpanExporterBuilder(
+      const std::string &name) const;
+
+  void SetExtensionSpanExporterBuilder(const std::string &name,
+                                       std::unique_ptr<ExtensionSpanExporterBuilder> &&builder);
+
+  const ExtensionSpanProcessorBuilder *GetExtensionSpanProcessorBuilder(
+      const std::string &name) const;
+
+  void SetExtensionSpanProcessorBuilder(const std::string &name,
+                                        std::unique_ptr<ExtensionSpanProcessorBuilder> &&builder);
+
+  const ExtensionPushMetricExporterBuilder *GetExtensionPushMetricExporterBuilder(
+      const std::string &name) const;
+
+  void SetExtensionPushMetricExporterBuilder(
+      const std::string &name,
+      std::unique_ptr<ExtensionPushMetricExporterBuilder> &&builder);
+
+  const ExtensionPullMetricExporterBuilder *GetExtensionPullMetricExporterBuilder(
+      const std::string &name) const;
+
+  void SetExtensionPullMetricExporterBuilder(
+      const std::string &name,
+      std::unique_ptr<ExtensionPullMetricExporterBuilder> &&builder);
+
+  const ExtensionLogRecordExporterBuilder *GetExtensionLogRecordExporterBuilder(
+      const std::string &name) const;
+
+  void SetExtensionLogRecordExporterBuilder(
+      const std::string &name,
+      std::unique_ptr<ExtensionLogRecordExporterBuilder> &&builder);
+
+  const ExtensionLogRecordProcessorBuilder *GetExtensionLogRecordProcessorBuilder(
+      const std::string &name) const;
+
+  void SetExtensionLogRecordProcessorBuilder(
+      const std::string &name,
+      std::unique_ptr<ExtensionLogRecordProcessorBuilder> &&builder);
+
+private:
+  std::unique_ptr<OtlpHttpSpanExporterBuilder> otlp_http_span_builder_;
+  std::unique_ptr<OtlpGrpcSpanExporterBuilder> otlp_grpc_span_builder_;
+  std::unique_ptr<OtlpFileSpanExporterBuilder> otlp_file_span_builder_;
+  std::unique_ptr<ConsoleSpanExporterBuilder> console_span_builder_;
+  std::unique_ptr<ZipkinSpanExporterBuilder> zipkin_span_builder_;
+
+  std::unique_ptr<OtlpHttpPushMetricExporterBuilder> otlp_http_push_metric_builder_;
+  std::unique_ptr<OtlpGrpcPushMetricExporterBuilder> otlp_grpc_push_metric_builder_;
+  std::unique_ptr<OtlpFilePushMetricExporterBuilder> otlp_file_push_metric_builder_;
+  std::unique_ptr<ConsolePushMetricExporterBuilder> console_metric_builder_;
+  std::unique_ptr<PrometheusPullMetricExporterBuilder> prometheus_metric_builder_;
+
+  std::unique_ptr<OtlpHttpLogRecordExporterBuilder> otlp_http_log_record_builder_;
+  std::unique_ptr<OtlpGrpcLogRecordExporterBuilder> otlp_grpc_log_record_builder_;
+  std::unique_ptr<OtlpFileLogRecordExporterBuilder> otlp_file_log_record_builder_;
+  std::unique_ptr<ConsoleLogRecordExporterBuilder> console_log_record_builder_;
+
+  std::map<std::string, std::unique_ptr<TextMapPropagatorBuilder>> propagator_builders_;
+  std::map<std::string, std::unique_ptr<ExtensionSamplerBuilder>> sampler_builders_;
+  std::map<std::string, std::unique_ptr<ExtensionSpanExporterBuilder>> span_exporter_builders_;
+  std::map<std::string, std::unique_ptr<ExtensionSpanProcessorBuilder>> span_processor_builders_;
+  std::map<std::string, std::unique_ptr<ExtensionPushMetricExporterBuilder>>
+      push_metric_exporter_builders_;
+  std::map<std::string, std::unique_ptr<ExtensionPullMetricExporterBuilder>>
+      pull_metric_exporter_builders_;
+  std::map<std::string, std::unique_ptr<ExtensionLogRecordExporterBuilder>>
+      log_record_exporter_builders_;
+  std::map<std::string, std::unique_ptr<ExtensionLogRecordProcessorBuilder>>
+      log_record_processor_builders_;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/text_map_propagator_builder.h b/sdk/include/opentelemetry/sdk/configuration/text_map_propagator_builder.h
new file mode 100644
index 0000000000..76ec51ed4d
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/text_map_propagator_builder.h
@@ -0,0 +1,32 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/context/propagation/text_map_propagator.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class TextMapPropagatorBuilder
+{
+public:
+  TextMapPropagatorBuilder()                                                 = default;
+  TextMapPropagatorBuilder(TextMapPropagatorBuilder &&)                      = default;
+  TextMapPropagatorBuilder(const TextMapPropagatorBuilder &)                 = default;
+  TextMapPropagatorBuilder &operator=(TextMapPropagatorBuilder &&)           = default;
+  TextMapPropagatorBuilder &operator=(const TextMapPropagatorBuilder &other) = default;
+  virtual ~TextMapPropagatorBuilder()                                        = default;
+
+  virtual std::unique_ptr<opentelemetry::context::propagation::TextMapPropagator> Build() const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/include/opentelemetry/sdk/configuration/zipkin_span_exporter_builder.h b/sdk/include/opentelemetry/sdk/configuration/zipkin_span_exporter_builder.h
new file mode 100644
index 0000000000..2b140e4c48
--- /dev/null
+++ b/sdk/include/opentelemetry/sdk/configuration/zipkin_span_exporter_builder.h
@@ -0,0 +1,34 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "opentelemetry/sdk/configuration/zipkin_span_exporter_configuration.h"
+#include "opentelemetry/sdk/trace/exporter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class ZipkinSpanExporterBuilder
+{
+public:
+  ZipkinSpanExporterBuilder()                                                  = default;
+  ZipkinSpanExporterBuilder(ZipkinSpanExporterBuilder &&)                      = default;
+  ZipkinSpanExporterBuilder(const ZipkinSpanExporterBuilder &)                 = default;
+  ZipkinSpanExporterBuilder &operator=(ZipkinSpanExporterBuilder &&)           = default;
+  ZipkinSpanExporterBuilder &operator=(const ZipkinSpanExporterBuilder &other) = default;
+  virtual ~ZipkinSpanExporterBuilder()                                         = default;
+
+  virtual std::unique_ptr<opentelemetry::sdk::trace::SpanExporter> Build(
+      const opentelemetry::sdk::configuration::ZipkinSpanExporterConfiguration *model) const = 0;
+};
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/src/configuration/registry.cc b/sdk/src/configuration/registry.cc
new file mode 100644
index 0000000000..804faf38fa
--- /dev/null
+++ b/sdk/src/configuration/registry.cc
@@ -0,0 +1,248 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "opentelemetry/baggage/propagation/baggage_propagator.h"
+#include "opentelemetry/context/propagation/text_map_propagator.h"
+#include "opentelemetry/sdk/configuration/extension_log_record_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/extension_log_record_processor_builder.h"
+#include "opentelemetry/sdk/configuration/extension_pull_metric_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/extension_push_metric_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/extension_sampler_builder.h"
+#include "opentelemetry/sdk/configuration/extension_span_exporter_builder.h"
+#include "opentelemetry/sdk/configuration/extension_span_processor_builder.h"
+#include "opentelemetry/sdk/configuration/registry.h"
+#include "opentelemetry/sdk/configuration/text_map_propagator_builder.h"
+#include "opentelemetry/trace/propagation/b3_propagator.h"
+#include "opentelemetry/trace/propagation/http_trace_context.h"
+#include "opentelemetry/trace/propagation/jaeger.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace configuration
+{
+
+class TraceContextBuilder : public TextMapPropagatorBuilder
+{
+public:
+  std::unique_ptr<opentelemetry::context::propagation::TextMapPropagator> Build() const override
+  {
+    auto result = std::make_unique<opentelemetry::trace::propagation::HttpTraceContext>();
+    return result;
+  }
+};
+
+class BaggageBuilder : public TextMapPropagatorBuilder
+{
+public:
+  std::unique_ptr<opentelemetry::context::propagation::TextMapPropagator> Build() const override
+  {
+    auto result = std::make_unique<opentelemetry::baggage::propagation::BaggagePropagator>();
+    return result;
+  }
+};
+
+class B3Builder : public TextMapPropagatorBuilder
+{
+public:
+  std::unique_ptr<opentelemetry::context::propagation::TextMapPropagator> Build() const override
+  {
+    auto result = std::make_unique<opentelemetry::trace::propagation::B3Propagator>();
+    return result;
+  }
+};
+
+class B3MultiBuilder : public TextMapPropagatorBuilder
+{
+public:
+  std::unique_ptr<opentelemetry::context::propagation::TextMapPropagator> Build() const override
+  {
+    auto result = std::make_unique<opentelemetry::trace::propagation::B3PropagatorMultiHeader>();
+    return result;
+  }
+};
+
+class JaegerBuilder : public TextMapPropagatorBuilder
+{
+public:
+  std::unique_ptr<opentelemetry::context::propagation::TextMapPropagator> Build() const override
+  {
+    auto result = std::make_unique<opentelemetry::trace::propagation::JaegerPropagator>();
+    return result;
+  }
+};
+
+Registry::Registry()
+{
+  SetTextMapPropagatorBuilder("tracecontext", std::make_unique<TraceContextBuilder>());
+  SetTextMapPropagatorBuilder("baggage", std::make_unique<BaggageBuilder>());
+  SetTextMapPropagatorBuilder("b3", std::make_unique<B3Builder>());
+  SetTextMapPropagatorBuilder("b3multi", std::make_unique<B3MultiBuilder>());
+  SetTextMapPropagatorBuilder("jaeger", std::make_unique<JaegerBuilder>());
+}
+
+const TextMapPropagatorBuilder *Registry::GetTextMapPropagatorBuilder(const std::string &name) const
+{
+  TextMapPropagatorBuilder *builder = nullptr;
+  auto search                       = propagator_builders_.find(name);
+  if (search != propagator_builders_.end())
+  {
+    builder = search->second.get();
+  }
+  return builder;
+}
+
+void Registry::SetTextMapPropagatorBuilder(const std::string &name,
+                                           std::unique_ptr<TextMapPropagatorBuilder> &&builder)
+{
+  propagator_builders_.erase(name);
+  propagator_builders_.insert({name, std::move(builder)});
+}
+
+const ExtensionSamplerBuilder *Registry::GetExtensionSamplerBuilder(const std::string &name) const
+{
+  ExtensionSamplerBuilder *builder = nullptr;
+  auto search                      = sampler_builders_.find(name);
+  if (search != sampler_builders_.end())
+  {
+    builder = search->second.get();
+  }
+  return builder;
+}
+
+void Registry::SetExtensionSamplerBuilder(const std::string &name,
+                                          std::unique_ptr<ExtensionSamplerBuilder> &&builder)
+{
+  sampler_builders_.erase(name);
+  sampler_builders_.insert({name, std::move(builder)});
+}
+
+const ExtensionSpanExporterBuilder *Registry::GetExtensionSpanExporterBuilder(
+    const std::string &name) const
+{
+  ExtensionSpanExporterBuilder *builder = nullptr;
+  auto search                           = span_exporter_builders_.find(name);
+  if (search != span_exporter_builders_.end())
+  {
+    builder = search->second.get();
+  }
+  return builder;
+}
+
+void Registry::SetExtensionSpanExporterBuilder(
+    const std::string &name,
+    std::unique_ptr<ExtensionSpanExporterBuilder> &&builder)
+{
+  span_exporter_builders_.erase(name);
+  span_exporter_builders_.insert({name, std::move(builder)});
+}
+
+const ExtensionSpanProcessorBuilder *Registry::GetExtensionSpanProcessorBuilder(
+    const std::string &name) const
+{
+  ExtensionSpanProcessorBuilder *builder = nullptr;
+  auto search                            = span_processor_builders_.find(name);
+  if (search != span_processor_builders_.end())
+  {
+    builder = search->second.get();
+  }
+  return builder;
+}
+
+void Registry::SetExtensionSpanProcessorBuilder(
+    const std::string &name,
+    std::unique_ptr<ExtensionSpanProcessorBuilder> &&builder)
+{
+  span_processor_builders_.erase(name);
+  span_processor_builders_.insert({name, std::move(builder)});
+}
+
+const ExtensionPushMetricExporterBuilder *Registry::GetExtensionPushMetricExporterBuilder(
+    const std::string &name) const
+{
+  ExtensionPushMetricExporterBuilder *builder = nullptr;
+  auto search                                 = push_metric_exporter_builders_.find(name);
+  if (search != push_metric_exporter_builders_.end())
+  {
+    builder = search->second.get();
+  }
+  return builder;
+}
+
+void Registry::SetExtensionPushMetricExporterBuilder(
+    const std::string &name,
+    std::unique_ptr<ExtensionPushMetricExporterBuilder> &&builder)
+{
+  push_metric_exporter_builders_.erase(name);
+  push_metric_exporter_builders_.insert({name, std::move(builder)});
+}
+
+const ExtensionPullMetricExporterBuilder *Registry::GetExtensionPullMetricExporterBuilder(
+    const std::string &name) const
+{
+  ExtensionPullMetricExporterBuilder *builder = nullptr;
+  auto search                                 = pull_metric_exporter_builders_.find(name);
+  if (search != pull_metric_exporter_builders_.end())
+  {
+    builder = search->second.get();
+  }
+  return builder;
+}
+
+void Registry::SetExtensionPullMetricExporterBuilder(
+    const std::string &name,
+    std::unique_ptr<ExtensionPullMetricExporterBuilder> &&builder)
+{
+  pull_metric_exporter_builders_.erase(name);
+  pull_metric_exporter_builders_.insert({name, std::move(builder)});
+}
+
+const ExtensionLogRecordExporterBuilder *Registry::GetExtensionLogRecordExporterBuilder(
+    const std::string &name) const
+{
+  ExtensionLogRecordExporterBuilder *builder = nullptr;
+  auto search                                = log_record_exporter_builders_.find(name);
+  if (search != log_record_exporter_builders_.end())
+  {
+    builder = search->second.get();
+  }
+  return builder;
+}
+
+void Registry::SetExtensionLogRecordExporterBuilder(
+    const std::string &name,
+    std::unique_ptr<ExtensionLogRecordExporterBuilder> &&builder)
+{
+  log_record_exporter_builders_.erase(name);
+  log_record_exporter_builders_.insert({name, std::move(builder)});
+}
+
+const ExtensionLogRecordProcessorBuilder *Registry::GetExtensionLogRecordProcessorBuilder(
+    const std::string &name) const
+{
+  ExtensionLogRecordProcessorBuilder *builder = nullptr;
+  auto search                                 = log_record_processor_builders_.find(name);
+  if (search != log_record_processor_builders_.end())
+  {
+    builder = search->second.get();
+  }
+  return builder;
+}
+
+void Registry::SetExtensionLogRecordProcessorBuilder(
+    const std::string &name,
+    std::unique_ptr<ExtensionLogRecordProcessorBuilder> &&builder)
+{
+  log_record_processor_builders_.erase(name);
+  log_record_processor_builders_.insert({name, std::move(builder)});
+}
+
+}  // namespace configuration
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE