diff --git a/.ci/bwcVersions b/.ci/bwcVersions
index 78d8796c624d7..f3a9aa2787a80 100644
--- a/.ci/bwcVersions
+++ b/.ci/bwcVersions
@@ -30,4 +30,5 @@ BWC_VERSION:
   - "2.12.0"
   - "2.12.1"
   - "2.13.0"
+  - "2.13.1"
   - "2.14.0"
diff --git a/.github/workflows/detect-breaking-change.yml b/.github/workflows/detect-breaking-change.yml
new file mode 100644
index 0000000000000..1913d070e8c24
--- /dev/null
+++ b/.github/workflows/detect-breaking-change.yml
@@ -0,0 +1,27 @@
+name: "Detect Breaking Changes"
+on:
+  pull_request
+
+jobs:
+  detect-breaking-change:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-java@v4
+      with:
+        distribution: temurin # Temurin is a distribution of adoptium
+        java-version: 21
+    - uses: gradle/gradle-build-action@v3
+      with:
+        cache-disabled: true
+        arguments: japicmp
+        gradle-version: 8.7
+        build-root-directory: server
+    - if: failure()
+      run: cat server/build/reports/java-compatibility/report.txt
+    - if: failure()
+      uses: actions/upload-artifact@v4
+      with:
+        name: java-compatibility-report.html
+        path: ${{ github.workspace }}/server/build/reports/java-compatibility/report.html
+  
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 00d1794be657d..1c72910b96219 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -103,29 +103,46 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased 2.x]
 ### Added
+- Constant Keyword Field ([#12285](https://github.com/opensearch-project/OpenSearch/pull/12285))
 - Convert ingest processor supports ip type ([#12818](https://github.com/opensearch-project/OpenSearch/pull/12818))
 - Add a counter to node stat api to track shard going from idle to non-idle ([#12768](https://github.com/opensearch-project/OpenSearch/pull/12768))
 - Allow setting KEYSTORE_PASSWORD through env variable ([#12865](https://github.com/opensearch-project/OpenSearch/pull/12865))
 - [Concurrent Segment Search] Perform buildAggregation concurrently and support Composite Aggregations ([#12697](https://github.com/opensearch-project/OpenSearch/pull/12697))
 - [Concurrent Segment Search] Disable concurrent segment search for system indices and throttled requests ([#12954](https://github.com/opensearch-project/OpenSearch/pull/12954))
 - Rename ingest processor supports overriding target field if exists ([#12990](https://github.com/opensearch-project/OpenSearch/pull/12990))
+- Derived fields support to derive field values at query time without indexing ([#12569](https://github.com/opensearch-project/OpenSearch/pull/12569))
+- Detect breaking changes on pull requests ([#9044](https://github.com/opensearch-project/OpenSearch/pull/9044))
+- Add cluster primary balance contraint for rebalancing with buffer ([#12656](https://github.com/opensearch-project/OpenSearch/pull/12656))
+- [Remote Store] Make translog transfer timeout configurable ([#12704](https://github.com/opensearch-project/OpenSearch/pull/12704))
+- Reject Resize index requests (i.e, split, shrink and clone), While DocRep to SegRep migration is in progress.([#12686](https://github.com/opensearch-project/OpenSearch/pull/12686))
+- Add support for more than one protocol for transport ([#12967](https://github.com/opensearch-project/OpenSearch/pull/12967))
 
 ### Dependencies
 - Bump `org.apache.commons:commons-configuration2` from 2.10.0 to 2.10.1 ([#12896](https://github.com/opensearch-project/OpenSearch/pull/12896))
 - Bump `asm` from 9.6 to 9.7 ([#12908](https://github.com/opensearch-project/OpenSearch/pull/12908))
 - Bump `net.minidev:json-smart` from 2.5.0 to 2.5.1 ([#12893](https://github.com/opensearch-project/OpenSearch/pull/12893))
 - Bump `netty` from 4.1.107.Final to 4.1.108.Final ([#12924](https://github.com/opensearch-project/OpenSearch/pull/12924))
+- Bump `commons-io:commons-io` from 2.15.1 to 2.16.0 ([#12996](https://github.com/opensearch-project/OpenSearch/pull/12996), [#12998](https://github.com/opensearch-project/OpenSearch/pull/12998), [#12999](https://github.com/opensearch-project/OpenSearch/pull/12999))
+- Bump `org.apache.commons:commons-compress` from 1.24.0 to 1.26.1 ([#12627](https://github.com/opensearch-project/OpenSearch/pull/12627))
+- Bump `org.apache.commons:commonscodec` from 1.15 to 1.16.1 ([#12627](https://github.com/opensearch-project/OpenSearch/pull/12627))
+- Bump `org.apache.commons:commonslang` from 3.13.0 to 3.14.0 ([#12627](https://github.com/opensearch-project/OpenSearch/pull/12627))
+- Bump Apache Tika from 2.6.0 to 2.9.2 ([#12627](https://github.com/opensearch-project/OpenSearch/pull/12627))
 
 ### Changed
 - [BWC and API enforcement] Enforcing the presence of API annotations at build time ([#12872](https://github.com/opensearch-project/OpenSearch/pull/12872))
 - Improve built-in secure transports support ([#12907](https://github.com/opensearch-project/OpenSearch/pull/12907))
+- Update links to documentation in rest-api-spec ([#13043](https://github.com/opensearch-project/OpenSearch/pull/13043))
 
 ### Deprecated
 
 ### Removed
+- Remove handling of index.mapper.dynamic in AutoCreateIndex([#13067](https://github.com/opensearch-project/OpenSearch/pull/13067))
 
 ### Fixed
+- Fix bulk API ignores ingest pipeline for upsert ([#12883](https://github.com/opensearch-project/OpenSearch/pull/12883))
 - Fix issue with feature flags where default value may not be honored ([#12849](https://github.com/opensearch-project/OpenSearch/pull/12849))
+- Fix UOE While building Exists query for nested search_as_you_type field ([#12048](https://github.com/opensearch-project/OpenSearch/pull/12048))
+- Client with Java 8 runtime and Apache HttpClient 5 Transport fails with java.lang.NoSuchMethodError: java.nio.ByteBuffer.flip()Ljava/nio/ByteBuffer ([#13100](https://github.com/opensearch-project/opensearch-java/pull/13100)) 
 
 ### Security
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 4a1162cf2558b..f5494925dcf50 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,18 +1,18 @@
 - [Contributing to OpenSearch](#contributing-to-opensearch)
-  - [First Things First](#first-things-first)
-  - [Ways to Contribute](#ways-to-contribute)
+- [First Things First](#first-things-first)
+- [Ways to Contribute](#ways-to-contribute)
     - [Bug Reports](#bug-reports)
     - [Feature Requests](#feature-requests)
     - [Documentation Changes](#documentation-changes)
     - [Contributing Code](#contributing-code)
-  - [Developer Certificate of Origin](#developer-certificate-of-origin)
-  - [Changelog](#changelog)
-  - [Review Process](#review-process)
-  - [Troubleshooting Failing Builds](#troubleshooting-failing-builds)
+- [Developer Certificate of Origin](#developer-certificate-of-origin)
+- [Changelog](#changelog)
+- [Review Process](#review-process)
+    - [Tips for Success](#tips)
 
 # Contributing to OpenSearch
 
-OpenSearch is a community project that is built and maintained by people just like **you**. We're glad you're interested in helping out. There are several different ways you can do it, but before we talk about that, let's talk about how to get started.
+OpenSearch is a community project built and maintained by people just like **you**. We're glad you're interested in helping out. There are several different ways you can do it, but before we talk about that, let's talk about how to get started.
 
 ## First Things First
 
@@ -30,9 +30,9 @@ Ugh! Bugs!
 
 A bug is when software behaves in a way that you didn't expect and the developer didn't intend. To help us understand what's going on, we first want to make sure you're working from the latest version. Please make sure you're testing against the [latest version](https://github.com/opensearch-project/OpenSearch).
 
-Once you've confirmed that the bug still exists in the latest version, you'll want to check to make sure it's not something we already know about on the [open issues GitHub page](https://github.com/opensearch-project/OpenSearch/issues).
+Once you've confirmed that the bug still exists in the latest version, you'll want to check the bug is not something we already know about. A good way to figure this out is to search for your bug on the [open issues GitHub page](https://github.com/opensearch-project/OpenSearch/issues).
 
-If you've upgraded to the latest version and you can't find it in our open issues list, then you'll need to tell us how to reproduce it. To make the behavior as clear as possible, please provided your steps as `curl` commands which we can copy and paste into a terminal to run it locally, for example:
+If you've upgraded to the latest version and you can't find it in our open issues list, then you'll need to tell us how to reproduce it. To make the behavior as clear as possible, please provide your steps as `curl` commands which we can copy and paste into a terminal to run it locally, for example:
 
 ```sh
 # delete the index
@@ -47,11 +47,11 @@ curl -x PUT localhost:9200/test/test/1 -d '{
 curl ....
 ```
 
-Provide as much information as you can. You may think that the problem lies with your query, when actually it depends on how your data is indexed. The easier it is for us to recreate your problem, the faster it is likely to be fixed.
+Provide as much information as you can. You may think that the problem lies with your query, when actually it depends on how your data is indexed. The easier it is for us to recreate your problem, the faster it is likely to be fixed. It is generally always helpful to provide the basic details of your cluster configuration alongside your reproduction steps.
 
 ### Feature Requests
 
-If you've thought of a way that OpenSearch could be better, we want to hear about it. We track feature requests using GitHub, so please feel free to open an issue which describes the feature you would like to see, why you need it, and how it should work.
+If you've thought of a way that OpenSearch could be better, we want to hear about it. We track feature requests using GitHub, so please feel free to open an issue which describes the feature you would like to see, why you need it, and how it should work. After opening an issue, the fastest way to see your change made is to open a pull request following the requested changes you detailed in your issue. You can learn more about opening a pull request in the [contributing code section](#contributing-code).
 
 ### Documentation Changes
 
@@ -164,13 +164,19 @@ If we accept the PR, a [maintainer](MAINTAINERS.md) will merge your change and u
 
 If we reject the PR, we will close the pull request with a comment explaining why. This decision isn't always final: if you feel we have misunderstood your intended change or otherwise think that we should reconsider then please continue the conversation with a comment on the PR and we'll do our best to address any further points you raise.
 
-## Troubleshooting Failing Builds
+### Tips for Success (#tips)
 
-The OpenSearch testing framework offers many capabilities but exhibits significant complexity (it does lot of randomization internally to cover as many edge cases and variations as possible). Unfortunately, this posses a challenge by making it harder to discover important issues/bugs in straightforward way and may lead to so called flaky tests - the tests which flip randomly from success to failure without any code changes. 
+We have a lot of mechanisms to help expedite towards an accepted PR. Here are some tips for success:
+1. *Minimize BWC guarantees*: The first PR review cycle heavily focuses on the public facing APIs. This is what we have to "guarantee" as non-breaking for [bwc across major versions](./DEVELOPER_GUIDE.md#backwards-compatibility).
+2. *Do not copy non-compliant code*: Ensure that code is APLv2 compatible. This means that you have not copied any code from other sources unless that code is also APLv2 compatible.
+3. *Utilize feature flags*: Features that are safeguarded behind feature flags are more likely to be merged and backported, as they come with an additional layer of protection. Refer to this [example PR](https://github.com/opensearch-project/OpenSearch/pull/4959) for implementation details.
+4. *Use appropriate Java tags*:
+    - `@opensearch.internal`: Marks internal classes subject to rapid changes.
+    - `@opensearch.api`: Marks public-facing API classes with backward compatibility guarantees.
+    - `@opensearch.experimental`: Indicates rapidly changing [experimental code](./DEVELOPER_GUIDE.md#experimental-development).
+5. *Employ sandbox for significant core changes*: Any new features or enhancements that make changes to core classes (e.g., search phases, codecs, or specialized lucene APIs) are more likely to. be merged if they are sandboxed. This can only be enabled on the java CLI (`-Dsandbox.enabled=true`).
+6. *Micro-benchmark critical path*: This is a lesser known mechanism, but if you have critical path changes you're afraid will impact performance (the changes touch the garbage collector, heap, direct memory, or CPU) then including a [microbenchmark](https://github.com/opensearch-project/OpenSearch/tree/main/benchmarks) with your PR (and jfr or flamegraph results in the description) is a *GREAT IDEA* and will help expedite the review process.
+7. *Test rigorously*: Ensure thorough testing ([OpenSearchTestCase](./test/framework/src/main/java/org/opensearch/test/OpenSearchTestCase.java) for unit tests, [OpenSearchIntegTestCase](./test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java) for integration & cluster tests, [OpenSearchRestTestCase](./test/framework/src/main/java/org/opensearch/test/rest/OpenSearchRestTestCase.java) for testing REST endpoint interfaces, and yaml tests with [ClientYamlTestSuiteIT](./rest-api-spec/src/yamlRestTest/java/org/opensearch/test/rest/ClientYamlTestSuiteIT.java) for REST integration tests)
+
+In general, adding more guardrails to your changes increases the likelihood of swift PR acceptance. We can always relax these guard rails in smaller followup PRs. Reverting a GA feature is much more difficult. Check out the [DEVELOPER_GUIDE](./DEVELOPER_GUIDE.md#submitting-changes) for more useful tips.
 
-If your pull request reports a failing test(s) on one of the checks, please:
- - look if there is an existing [issue](https://github.com/opensearch-project/OpenSearch/issues) reported for the test in question 
- - if not, please make sure this is not caused by your changes, run the failing test(s) locally for some time
- - if you are sure the failure is not related, please open a new [bug](https://github.com/opensearch-project/OpenSearch/issues/new?assignees=&labels=bug%2C+untriaged&projects=&template=bug_template.md&title=%5BBUG%5D) with `flaky-test` label
- - add a comment referencing the issue(s) or bug report(s) to your pull request explaining the failing build(s)
- - as a bonus point, try to contribute by fixing the flaky test(s)
diff --git a/buildSrc/build.gradle b/buildSrc/build.gradle
index 0562ecc6ee61b..c68cc0406d3a6 100644
--- a/buildSrc/build.gradle
+++ b/buildSrc/build.gradle
@@ -102,14 +102,14 @@ dependencies {
 
   api localGroovy()
 
-  api 'commons-codec:commons-codec:1.16.0'
-  api 'org.apache.commons:commons-compress:1.25.0'
+  api "commons-codec:commons-codec:${props.getProperty('commonscodec')}"
+  api "org.apache.commons:commons-compress:${props.getProperty('commonscompress')}"
   api 'org.apache.ant:ant:1.10.14'
   api 'com.netflix.nebula:gradle-extra-configurations-plugin:10.0.0'
   api 'com.netflix.nebula:nebula-publishing-plugin:21.0.0'
   api 'com.netflix.nebula:gradle-info-plugin:12.1.6'
   api 'org.apache.rat:apache-rat:0.15'
-  api 'commons-io:commons-io:2.15.1'
+  api "commons-io:commons-io:${props.getProperty('commonsio')}"
   api "net.java.dev.jna:jna:5.14.0"
   api 'com.github.johnrengelman:shadow:8.1.1'
   api 'org.jdom:jdom2:2.0.6.1'
diff --git a/buildSrc/version.properties b/buildSrc/version.properties
index 5c9cd25bb79ad..c60f42dc1bb89 100644
--- a/buildSrc/version.properties
+++ b/buildSrc/version.properties
@@ -40,9 +40,10 @@ httpclient        = 4.5.14
 httpcore          = 4.4.16
 httpasyncclient   = 4.1.5
 commonslogging    = 1.2
-commonscodec      = 1.15
-commonslang       = 3.13.0
-commonscompress   = 1.24.0
+commonscodec      = 1.16.1
+commonslang       = 3.14.0
+commonscompress   = 1.26.1
+commonsio         = 2.16.0
 # plugin dependencies
 aws               = 2.20.86
 reactivestreams   = 1.0.4
diff --git a/client/rest/licenses/commons-codec-1.15.jar.sha1 b/client/rest/licenses/commons-codec-1.15.jar.sha1
deleted file mode 100644
index 62d99837b87e1..0000000000000
--- a/client/rest/licenses/commons-codec-1.15.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-49d94806b6e3dc933dacbd8acb0fdbab8ebd1e5d
\ No newline at end of file
diff --git a/client/rest/licenses/commons-codec-1.16.1.jar.sha1 b/client/rest/licenses/commons-codec-1.16.1.jar.sha1
new file mode 100644
index 0000000000000..6b8803089c6d7
--- /dev/null
+++ b/client/rest/licenses/commons-codec-1.16.1.jar.sha1
@@ -0,0 +1 @@
+47bd4d333fba53406f6c6c51884ddbca435c8862
\ No newline at end of file
diff --git a/client/rest/src/main/java/org/opensearch/client/nio/HttpEntityAsyncEntityProducer.java b/client/rest/src/main/java/org/opensearch/client/nio/HttpEntityAsyncEntityProducer.java
index 81fe77ddcfbed..4e6fd6f3d6f9d 100644
--- a/client/rest/src/main/java/org/opensearch/client/nio/HttpEntityAsyncEntityProducer.java
+++ b/client/rest/src/main/java/org/opensearch/client/nio/HttpEntityAsyncEntityProducer.java
@@ -16,6 +16,7 @@
 import org.apache.hc.core5.util.Asserts;
 
 import java.io.IOException;
+import java.nio.Buffer;
 import java.nio.ByteBuffer;
 import java.nio.channels.Channels;
 import java.nio.channels.ReadableByteChannel;
@@ -141,7 +142,7 @@ public void produce(final DataStreamChannel channel) throws IOException {
             }
         }
         if (byteBuffer.position() > 0) {
-            byteBuffer.flip();
+            ((Buffer) byteBuffer).flip();
             channel.write(byteBuffer);
             byteBuffer.compact();
         }
diff --git a/client/sniffer/licenses/commons-codec-1.15.jar.sha1 b/client/sniffer/licenses/commons-codec-1.15.jar.sha1
deleted file mode 100644
index 62d99837b87e1..0000000000000
--- a/client/sniffer/licenses/commons-codec-1.15.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-49d94806b6e3dc933dacbd8acb0fdbab8ebd1e5d
\ No newline at end of file
diff --git a/client/sniffer/licenses/commons-codec-1.16.1.jar.sha1 b/client/sniffer/licenses/commons-codec-1.16.1.jar.sha1
new file mode 100644
index 0000000000000..6b8803089c6d7
--- /dev/null
+++ b/client/sniffer/licenses/commons-codec-1.16.1.jar.sha1
@@ -0,0 +1 @@
+47bd4d333fba53406f6c6c51884ddbca435c8862
\ No newline at end of file
diff --git a/distribution/tools/plugin-cli/build.gradle b/distribution/tools/plugin-cli/build.gradle
index f40fb1c4b0a9f..446dbaad8466e 100644
--- a/distribution/tools/plugin-cli/build.gradle
+++ b/distribution/tools/plugin-cli/build.gradle
@@ -44,7 +44,7 @@ dependencies {
   testRuntimeOnly("com.google.guava:guava:${versions.guava}") {
     transitive = false
   }
-
+  api "commons-io:commons-io:${versions.commonsio}"
   implementation "org.apache.commons:commons-compress:${versions.commonscompress}"
 }
 
@@ -104,5 +104,8 @@ thirdPartyAudit.ignoreMissingClasses(
   'org.tukaani.xz.MemoryLimitException',
   'org.tukaani.xz.UnsupportedOptionsException',
   'org.tukaani.xz.XZ',
-  'org.tukaani.xz.XZOutputStream'
+  'org.tukaani.xz.XZOutputStream',
+  'org.apache.commons.codec.digest.PureJavaCrc32C',
+  'org.apache.commons.codec.digest.XXHash32',
+  'org.apache.commons.lang3.reflect.FieldUtils'
 )
diff --git a/distribution/tools/plugin-cli/licenses/commons-compress-1.24.0.jar.sha1 b/distribution/tools/plugin-cli/licenses/commons-compress-1.24.0.jar.sha1
deleted file mode 100644
index 23999d1bfbde4..0000000000000
--- a/distribution/tools/plugin-cli/licenses/commons-compress-1.24.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b4b1b5a3d9573b2970fddab236102c0a4d27d35e
\ No newline at end of file
diff --git a/distribution/tools/plugin-cli/licenses/commons-compress-1.26.1.jar.sha1 b/distribution/tools/plugin-cli/licenses/commons-compress-1.26.1.jar.sha1
new file mode 100644
index 0000000000000..912bda85de18a
--- /dev/null
+++ b/distribution/tools/plugin-cli/licenses/commons-compress-1.26.1.jar.sha1
@@ -0,0 +1 @@
+44331c1130c370e726a2e1a3e6fba6d2558ef04a
\ No newline at end of file
diff --git a/distribution/tools/plugin-cli/licenses/commons-io-2.16.0.jar.sha1 b/distribution/tools/plugin-cli/licenses/commons-io-2.16.0.jar.sha1
new file mode 100644
index 0000000000000..6a7b638719fa3
--- /dev/null
+++ b/distribution/tools/plugin-cli/licenses/commons-io-2.16.0.jar.sha1
@@ -0,0 +1 @@
+27875a7935f1ddcc13267eb6fae1f719e0409572
\ No newline at end of file
diff --git a/distribution/tools/plugin-cli/licenses/commons-io-LICENSE.txt b/distribution/tools/plugin-cli/licenses/commons-io-LICENSE.txt
new file mode 100644
index 0000000000000..d645695673349
--- /dev/null
+++ b/distribution/tools/plugin-cli/licenses/commons-io-LICENSE.txt
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/distribution/tools/plugin-cli/licenses/commons-io-NOTICE.txt b/distribution/tools/plugin-cli/licenses/commons-io-NOTICE.txt
new file mode 100644
index 0000000000000..a6b77d1eb6089
--- /dev/null
+++ b/distribution/tools/plugin-cli/licenses/commons-io-NOTICE.txt
@@ -0,0 +1,5 @@
+Apache Commons IO
+Copyright 2002-2014 The Apache Software Foundation
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).
diff --git a/libs/core/src/main/java/org/opensearch/Version.java b/libs/core/src/main/java/org/opensearch/Version.java
index 56df46ae94d44..f312c484a4842 100644
--- a/libs/core/src/main/java/org/opensearch/Version.java
+++ b/libs/core/src/main/java/org/opensearch/Version.java
@@ -101,6 +101,7 @@ public class Version implements Comparable<Version>, ToXContentFragment {
     public static final Version V_2_12_0 = new Version(2120099, org.apache.lucene.util.Version.LUCENE_9_9_2);
     public static final Version V_2_12_1 = new Version(2120199, org.apache.lucene.util.Version.LUCENE_9_9_2);
     public static final Version V_2_13_0 = new Version(2130099, org.apache.lucene.util.Version.LUCENE_9_10_0);
+    public static final Version V_2_13_1 = new Version(2130199, org.apache.lucene.util.Version.LUCENE_9_10_0);
     public static final Version V_2_14_0 = new Version(2140099, org.apache.lucene.util.Version.LUCENE_9_10_0);
     public static final Version V_3_0_0 = new Version(3000099, org.apache.lucene.util.Version.LUCENE_9_11_0);
     public static final Version CURRENT = V_3_0_0;
diff --git a/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/70_bulk.yml b/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/70_bulk.yml
index 2dfa17174b139..d7be48a92908c 100644
--- a/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/70_bulk.yml
+++ b/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/70_bulk.yml
@@ -144,3 +144,26 @@ teardown:
 
   - is_false: _source.field1
   - match: {_source.field2: value2}
+
+# related issue: https://github.com/opensearch-project/OpenSearch/issues/12854
+---
+"Test bulk honors pipeline in update action with upsert":
+  - skip:
+      version: " - 2.13.99"
+      reason: "fixed in 2.14.0"
+
+  - do:
+      bulk:
+        refresh: true
+        body:
+          - '{"update": {"_index": "test_index", "_id": "test_id3", "pipeline": "pipeline1"}}'
+          - '{"upsert": {"f1": "v2", "f2": 47}, "doc": {"x": 1}}'
+
+  - match: { errors: false }
+  - match: { items.0.update.result: created }
+
+  - do:
+      get:
+        index: test_index
+        id: test_id3
+  - match: { _source: {"f1": "v2", "f2": 47, "field1": "value1"}}
diff --git a/modules/lang-painless/src/main/java/org/opensearch/painless/PainlessModulePlugin.java b/modules/lang-painless/src/main/java/org/opensearch/painless/PainlessModulePlugin.java
index c7638b3c41c63..55dc23f665d2e 100644
--- a/modules/lang-painless/src/main/java/org/opensearch/painless/PainlessModulePlugin.java
+++ b/modules/lang-painless/src/main/java/org/opensearch/painless/PainlessModulePlugin.java
@@ -60,6 +60,7 @@
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.rest.RestController;
 import org.opensearch.rest.RestHandler;
+import org.opensearch.script.DerivedFieldScript;
 import org.opensearch.script.IngestScript;
 import org.opensearch.script.ScoreScript;
 import org.opensearch.script.ScriptContext;
@@ -108,6 +109,11 @@ public final class PainlessModulePlugin extends Plugin implements ScriptPlugin,
         ingest.add(AllowlistLoader.loadFromResourceFiles(Allowlist.class, "org.opensearch.ingest.txt"));
         map.put(IngestScript.CONTEXT, ingest);
 
+        // Functions available to derived fields
+        List<Allowlist> derived = new ArrayList<>(Allowlist.BASE_ALLOWLISTS);
+        derived.add(AllowlistLoader.loadFromResourceFiles(Allowlist.class, "org.opensearch.derived.txt"));
+        map.put(DerivedFieldScript.CONTEXT, derived);
+
         allowlists = map;
     }
 
diff --git a/modules/lang-painless/src/main/resources/org/opensearch/painless/spi/org.opensearch.derived.txt b/modules/lang-painless/src/main/resources/org/opensearch/painless/spi/org.opensearch.derived.txt
new file mode 100644
index 0000000000000..9a3dd4894b286
--- /dev/null
+++ b/modules/lang-painless/src/main/resources/org/opensearch/painless/spi/org.opensearch.derived.txt
@@ -0,0 +1,17 @@
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+#
+
+# This file contains an allowlist for functions to be used in derived field context
+
+class org.opensearch.script.DerivedFieldScript @no_import {
+}
+
+static_import {
+    void emit(org.opensearch.script.DerivedFieldScript, Object) bound_to org.opensearch.script.ScriptEmitValues$EmitSingle
+    void emit(org.opensearch.script.DerivedFieldScript, double, double) bound_to org.opensearch.script.ScriptEmitValues$GeoPoint
+}
diff --git a/modules/lang-painless/src/test/java/org/opensearch/painless/DerivedFieldScriptTests.java b/modules/lang-painless/src/test/java/org/opensearch/painless/DerivedFieldScriptTests.java
new file mode 100644
index 0000000000000..2340e5b238ebb
--- /dev/null
+++ b/modules/lang-painless/src/test/java/org/opensearch/painless/DerivedFieldScriptTests.java
@@ -0,0 +1,227 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.painless;
+
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.memory.MemoryIndex;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.geo.GeoPoint;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.index.fielddata.IndexGeoPointFieldData;
+import org.opensearch.index.fielddata.IndexNumericFieldData;
+import org.opensearch.index.fielddata.LeafGeoPointFieldData;
+import org.opensearch.index.fielddata.LeafNumericFieldData;
+import org.opensearch.index.fielddata.MultiGeoPointValues;
+import org.opensearch.index.fielddata.SortedNumericDoubleValues;
+import org.opensearch.index.fielddata.plain.AbstractLeafGeoPointFieldData;
+import org.opensearch.index.fielddata.plain.LeafDoubleFieldData;
+import org.opensearch.index.mapper.GeoPointFieldMapper.GeoPointFieldType;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.mapper.NumberFieldMapper.NumberFieldType;
+import org.opensearch.index.mapper.NumberFieldMapper.NumberType;
+import org.opensearch.painless.spi.Allowlist;
+import org.opensearch.painless.spi.AllowlistLoader;
+import org.opensearch.script.DerivedFieldScript;
+import org.opensearch.script.ScriptContext;
+import org.opensearch.script.ScriptException;
+import org.opensearch.search.lookup.LeafSearchLookup;
+import org.opensearch.search.lookup.SearchLookup;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class DerivedFieldScriptTests extends ScriptTestCase {
+
+    private static PainlessScriptEngine SCRIPT_ENGINE;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+
+        // Adding derived field script to the contexts for the script engine
+        Map<ScriptContext<?>, List<Allowlist>> contexts = newDefaultContexts();
+        List<Allowlist> allowlists = new ArrayList<>(Allowlist.BASE_ALLOWLISTS);
+        allowlists.add(AllowlistLoader.loadFromResourceFiles(Allowlist.class, "org.opensearch.derived.txt"));
+        contexts.put(DerivedFieldScript.CONTEXT, allowlists);
+
+        SCRIPT_ENGINE = new PainlessScriptEngine(Settings.EMPTY, contexts);
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        SCRIPT_ENGINE = null;
+    }
+
+    @Override
+    protected PainlessScriptEngine getEngine() {
+        return SCRIPT_ENGINE;
+    }
+
+    private DerivedFieldScript.LeafFactory compile(String expression, SearchLookup lookup) {
+        DerivedFieldScript.Factory factory = SCRIPT_ENGINE.compile(
+            "derived_script_test",
+            expression,
+            DerivedFieldScript.CONTEXT,
+            Collections.emptyMap()
+        );
+        return factory.newFactory(Collections.emptyMap(), lookup);
+    }
+
+    public void testEmittingDoubleField() throws IOException {
+        // Mocking field value to be returned
+        NumberFieldType fieldType = new NumberFieldType("test_double_field", NumberType.DOUBLE);
+        MapperService mapperService = mock(MapperService.class);
+        when(mapperService.fieldType("test_double_field")).thenReturn(fieldType);
+
+        SortedNumericDoubleValues doubleValues = mock(SortedNumericDoubleValues.class);
+        when(doubleValues.docValueCount()).thenReturn(1);
+        when(doubleValues.advanceExact(anyInt())).thenReturn(true);
+        when(doubleValues.nextValue()).thenReturn(2.718);
+
+        LeafNumericFieldData atomicFieldData = mock(LeafDoubleFieldData.class); // SortedNumericDoubleFieldData
+        when(atomicFieldData.getDoubleValues()).thenReturn(doubleValues);
+
+        IndexNumericFieldData fieldData = mock(IndexNumericFieldData.class); // SortedNumericIndexFieldData
+        when(fieldData.getFieldName()).thenReturn("test_double_field");
+        when(fieldData.load(any())).thenReturn(atomicFieldData);
+
+        SearchLookup lookup = new SearchLookup(mapperService, (ignored, searchLookup) -> fieldData);
+
+        // We don't need a real index, just need to construct a LeafReaderContext which cannot be mocked
+        MemoryIndex index = new MemoryIndex();
+        LeafReaderContext leafReaderContext = index.createSearcher().getIndexReader().leaves().get(0);
+
+        // Execute the script
+        DerivedFieldScript script = compile("emit(doc['test_double_field'].value)", lookup).newInstance(leafReaderContext);
+        script.setDocument(1);
+        script.execute();
+
+        List<Object> result = script.getEmittedValues();
+        assertEquals(List.of(2.718), result);
+    }
+
+    public void testEmittingGeoPoint() throws IOException {
+        // Mocking field value to be returned
+        GeoPointFieldType fieldType = new GeoPointFieldType("test_geo_field");
+        MapperService mapperService = mock(MapperService.class);
+        when(mapperService.fieldType("test_geo_field")).thenReturn(fieldType);
+
+        MultiGeoPointValues geoPointValues = mock(MultiGeoPointValues.class);
+        when(geoPointValues.docValueCount()).thenReturn(1);
+        when(geoPointValues.advanceExact(anyInt())).thenReturn(true);
+        when(geoPointValues.nextValue()).thenReturn(new GeoPoint(5, 8));
+
+        LeafGeoPointFieldData atomicFieldData = mock(AbstractLeafGeoPointFieldData.class); // LatLonPointDVLeafFieldData
+        when(atomicFieldData.getGeoPointValues()).thenReturn(geoPointValues);
+
+        IndexGeoPointFieldData fieldData = mock(IndexGeoPointFieldData.class);
+        when(fieldData.getFieldName()).thenReturn("test_geo_field");
+        when(fieldData.load(any())).thenReturn(atomicFieldData);
+
+        SearchLookup lookup = new SearchLookup(mapperService, (ignored, searchLookup) -> fieldData);
+
+        // We don't need a real index, just need to construct a LeafReaderContext which cannot be mocked
+        MemoryIndex index = new MemoryIndex();
+        LeafReaderContext leafReaderContext = index.createSearcher().getIndexReader().leaves().get(0);
+
+        // Execute the script
+        DerivedFieldScript script = compile("emit(doc['test_geo_field'].value.getLat(), doc['test_geo_field'].value.getLon())", lookup)
+            .newInstance(leafReaderContext);
+        script.setDocument(1);
+        script.execute();
+
+        List<Object> result = script.getEmittedValues();
+        assertEquals(List.of(new Tuple<>(5.0, 8.0)), result);
+    }
+
+    public void testEmittingMultipleValues() throws IOException {
+        SearchLookup lookup = mock(SearchLookup.class);
+
+        // We don't need a real index, just need to construct a LeafReaderContext which cannot be mocked
+        MemoryIndex index = new MemoryIndex();
+        LeafReaderContext leafReaderContext = index.createSearcher().getIndexReader().leaves().get(0);
+
+        LeafSearchLookup leafSearchLookup = mock(LeafSearchLookup.class);
+        when(lookup.getLeafSearchLookup(leafReaderContext)).thenReturn(leafSearchLookup);
+
+        // Execute the script
+        DerivedFieldScript script = compile(
+            "def l = new ArrayList(); l.add('test'); l.add('multiple'); l.add('values'); for (String x : l) emit(x)",
+            lookup
+        ).newInstance(leafReaderContext);
+        script.setDocument(1);
+        script.execute();
+
+        List<Object> result = script.getEmittedValues();
+        assertEquals(List.of("test", "multiple", "values"), result);
+    }
+
+    public void testExceedingByteSizeLimit() throws IOException {
+        SearchLookup lookup = mock(SearchLookup.class);
+
+        // We don't need a real index, just need to construct a LeafReaderContext which cannot be mocked
+        MemoryIndex index = new MemoryIndex();
+        LeafReaderContext leafReaderContext = index.createSearcher().getIndexReader().leaves().get(0);
+
+        LeafSearchLookup leafSearchLookup = mock(LeafSearchLookup.class);
+        when(lookup.getLeafSearchLookup(leafReaderContext)).thenReturn(leafSearchLookup);
+
+        // Emitting a large string to exceed the byte size limit
+        DerivedFieldScript stringScript = compile("for (int i = 0; i < 1024 * 1024; i++) emit('a' + i);", lookup).newInstance(
+            leafReaderContext
+        );
+        expectThrows(ScriptException.class, () -> {
+            stringScript.setDocument(1);
+            stringScript.execute();
+        });
+
+        // Emitting an integer to check byte size limit
+        DerivedFieldScript intScript = compile("for (int i = 0; i < 1024 * 1024; i++) emit(42)", lookup).newInstance(leafReaderContext);
+        expectThrows(ScriptException.class, "Expected IllegalStateException for exceeding byte size limit", () -> {
+            intScript.setDocument(1);
+            intScript.execute();
+        });
+
+        // Emitting a long to check byte size limit
+        DerivedFieldScript longScript = compile("for (int i = 0; i < 1024 * 1024; i++) emit(1234567890123456789L)", lookup).newInstance(
+            leafReaderContext
+        );
+        expectThrows(ScriptException.class, "Expected IllegalStateException for exceeding byte size limit", () -> {
+            longScript.setDocument(1);
+            longScript.execute();
+        });
+
+        // Emitting a double to check byte size limit
+        DerivedFieldScript doubleScript = compile("for (int i = 0; i < 1024 * 1024; i++) emit(3.14159)", lookup).newInstance(
+            leafReaderContext
+        );
+        expectThrows(ScriptException.class, "Expected IllegalStateException for exceeding byte size limit", () -> {
+            doubleScript.setDocument(1);
+            doubleScript.execute();
+        });
+
+        // Emitting a GeoPoint to check byte size limit
+        DerivedFieldScript geoPointScript = compile("for (int i = 0; i < 1024 * 1024; i++) emit(1.23, 4.56);", lookup).newInstance(
+            leafReaderContext
+        );
+        expectThrows(ScriptException.class, "Expected IllegalStateException for exceeding byte size limit", () -> {
+            geoPointScript.setDocument(1);
+            geoPointScript.execute();
+        });
+    }
+}
diff --git a/modules/mapper-extras/src/test/java/org/opensearch/index/mapper/SearchAsYouTypeFieldMapperTests.java b/modules/mapper-extras/src/test/java/org/opensearch/index/mapper/SearchAsYouTypeFieldMapperTests.java
index b5f687ce34d4b..f55ad2e9d659c 100644
--- a/modules/mapper-extras/src/test/java/org/opensearch/index/mapper/SearchAsYouTypeFieldMapperTests.java
+++ b/modules/mapper-extras/src/test/java/org/opensearch/index/mapper/SearchAsYouTypeFieldMapperTests.java
@@ -47,6 +47,7 @@
 import org.apache.lucene.search.DisjunctionMaxQuery;
 import org.apache.lucene.search.MatchNoDocsQuery;
 import org.apache.lucene.search.MultiPhraseQuery;
+import org.apache.lucene.search.NormsFieldExistsQuery;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.SynonymQuery;
 import org.apache.lucene.search.TermQuery;
@@ -68,6 +69,7 @@
 import org.opensearch.index.query.MatchPhraseQueryBuilder;
 import org.opensearch.index.query.MultiMatchQueryBuilder;
 import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.index.query.QueryStringQueryBuilder;
 import org.opensearch.plugins.Plugin;
 
 import java.io.IOException;
@@ -541,6 +543,31 @@ public void testMatchPhrase() throws IOException {
         }
     }
 
+    public void testNestedExistsQuery() throws IOException {
+        MapperService mapperService = createMapperService(mapping(b -> {
+            b.startObject("field");
+            {
+                b.field("type", "object");
+                b.startObject("properties");
+                {
+                    b.startObject("nested_field");
+                    {
+                        b.field("type", "search_as_you_type");
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            b.endObject();
+        }));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        Query actual = new QueryStringQueryBuilder("field:*").toQuery(queryShardContext);
+        Query expected = new ConstantScoreQuery(
+            new BooleanQuery.Builder().add(new NormsFieldExistsQuery("field.nested_field"), BooleanClause.Occur.SHOULD).build()
+        );
+        assertEquals(expected, actual);
+    }
+
     private static BooleanQuery buildBoolPrefixQuery(String shingleFieldName, String prefixFieldName, List<String> terms) {
         final BooleanQuery.Builder builder = new BooleanQuery.Builder();
         for (int i = 0; i < terms.size() - 1; i++) {
diff --git a/plugins/analysis-phonetic/licenses/commons-codec-1.15.jar.sha1 b/plugins/analysis-phonetic/licenses/commons-codec-1.15.jar.sha1
deleted file mode 100644
index 62d99837b87e1..0000000000000
--- a/plugins/analysis-phonetic/licenses/commons-codec-1.15.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-49d94806b6e3dc933dacbd8acb0fdbab8ebd1e5d
\ No newline at end of file
diff --git a/plugins/analysis-phonetic/licenses/commons-codec-1.16.1.jar.sha1 b/plugins/analysis-phonetic/licenses/commons-codec-1.16.1.jar.sha1
new file mode 100644
index 0000000000000..6b8803089c6d7
--- /dev/null
+++ b/plugins/analysis-phonetic/licenses/commons-codec-1.16.1.jar.sha1
@@ -0,0 +1 @@
+47bd4d333fba53406f6c6c51884ddbca435c8862
\ No newline at end of file
diff --git a/plugins/crypto-kms/licenses/commons-codec-1.15.jar.sha1 b/plugins/crypto-kms/licenses/commons-codec-1.15.jar.sha1
deleted file mode 100644
index 62d99837b87e1..0000000000000
--- a/plugins/crypto-kms/licenses/commons-codec-1.15.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-49d94806b6e3dc933dacbd8acb0fdbab8ebd1e5d
\ No newline at end of file
diff --git a/plugins/crypto-kms/licenses/commons-codec-1.16.1.jar.sha1 b/plugins/crypto-kms/licenses/commons-codec-1.16.1.jar.sha1
new file mode 100644
index 0000000000000..6b8803089c6d7
--- /dev/null
+++ b/plugins/crypto-kms/licenses/commons-codec-1.16.1.jar.sha1
@@ -0,0 +1 @@
+47bd4d333fba53406f6c6c51884ddbca435c8862
\ No newline at end of file
diff --git a/plugins/discovery-azure-classic/build.gradle b/plugins/discovery-azure-classic/build.gradle
index c3d70e9c64968..7f34cec94499c 100644
--- a/plugins/discovery-azure-classic/build.gradle
+++ b/plugins/discovery-azure-classic/build.gradle
@@ -53,7 +53,7 @@ dependencies {
   api "org.apache.logging.log4j:log4j-1.2-api:${versions.log4j}"
   api "commons-codec:commons-codec:${versions.commonscodec}"
   api "commons-lang:commons-lang:2.6"
-  api "commons-io:commons-io:2.15.1"
+  api "commons-io:commons-io:${versions.commonsio}"
   api 'javax.mail:mail:1.4.7'
   api 'javax.inject:javax.inject:1'
   api "com.sun.jersey:jersey-client:${versions.jersey}"
diff --git a/plugins/discovery-azure-classic/licenses/commons-codec-1.15.jar.sha1 b/plugins/discovery-azure-classic/licenses/commons-codec-1.15.jar.sha1
deleted file mode 100644
index 62d99837b87e1..0000000000000
--- a/plugins/discovery-azure-classic/licenses/commons-codec-1.15.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-49d94806b6e3dc933dacbd8acb0fdbab8ebd1e5d
\ No newline at end of file
diff --git a/plugins/discovery-azure-classic/licenses/commons-codec-1.16.1.jar.sha1 b/plugins/discovery-azure-classic/licenses/commons-codec-1.16.1.jar.sha1
new file mode 100644
index 0000000000000..6b8803089c6d7
--- /dev/null
+++ b/plugins/discovery-azure-classic/licenses/commons-codec-1.16.1.jar.sha1
@@ -0,0 +1 @@
+47bd4d333fba53406f6c6c51884ddbca435c8862
\ No newline at end of file
diff --git a/plugins/discovery-azure-classic/licenses/commons-io-2.15.1.jar.sha1 b/plugins/discovery-azure-classic/licenses/commons-io-2.15.1.jar.sha1
deleted file mode 100644
index 47c5d13812a36..0000000000000
--- a/plugins/discovery-azure-classic/licenses/commons-io-2.15.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-f11560da189ab563a5c8e351941415430e9304ea
\ No newline at end of file
diff --git a/plugins/discovery-azure-classic/licenses/commons-io-2.16.0.jar.sha1 b/plugins/discovery-azure-classic/licenses/commons-io-2.16.0.jar.sha1
new file mode 100644
index 0000000000000..6a7b638719fa3
--- /dev/null
+++ b/plugins/discovery-azure-classic/licenses/commons-io-2.16.0.jar.sha1
@@ -0,0 +1 @@
+27875a7935f1ddcc13267eb6fae1f719e0409572
\ No newline at end of file
diff --git a/plugins/discovery-ec2/licenses/commons-codec-1.15.jar.sha1 b/plugins/discovery-ec2/licenses/commons-codec-1.15.jar.sha1
deleted file mode 100644
index 62d99837b87e1..0000000000000
--- a/plugins/discovery-ec2/licenses/commons-codec-1.15.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-49d94806b6e3dc933dacbd8acb0fdbab8ebd1e5d
\ No newline at end of file
diff --git a/plugins/discovery-ec2/licenses/commons-codec-1.16.1.jar.sha1 b/plugins/discovery-ec2/licenses/commons-codec-1.16.1.jar.sha1
new file mode 100644
index 0000000000000..6b8803089c6d7
--- /dev/null
+++ b/plugins/discovery-ec2/licenses/commons-codec-1.16.1.jar.sha1
@@ -0,0 +1 @@
+47bd4d333fba53406f6c6c51884ddbca435c8862
\ No newline at end of file
diff --git a/plugins/discovery-gce/licenses/commons-codec-1.15.jar.sha1 b/plugins/discovery-gce/licenses/commons-codec-1.15.jar.sha1
deleted file mode 100644
index 62d99837b87e1..0000000000000
--- a/plugins/discovery-gce/licenses/commons-codec-1.15.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-49d94806b6e3dc933dacbd8acb0fdbab8ebd1e5d
\ No newline at end of file
diff --git a/plugins/discovery-gce/licenses/commons-codec-1.16.1.jar.sha1 b/plugins/discovery-gce/licenses/commons-codec-1.16.1.jar.sha1
new file mode 100644
index 0000000000000..6b8803089c6d7
--- /dev/null
+++ b/plugins/discovery-gce/licenses/commons-codec-1.16.1.jar.sha1
@@ -0,0 +1 @@
+47bd4d333fba53406f6c6c51884ddbca435c8862
\ No newline at end of file
diff --git a/plugins/ingest-attachment/build.gradle b/plugins/ingest-attachment/build.gradle
index 6da34c4c9caf2..4749aa911886d 100644
--- a/plugins/ingest-attachment/build.gradle
+++ b/plugins/ingest-attachment/build.gradle
@@ -38,10 +38,10 @@ opensearchplugin {
 }
 
 versions << [
-  'tika'  : '2.6.0',
-  'pdfbox': '2.0.27',
-  'poi'   : '5.2.3',
-  'mime4j': '0.8.8'
+  'tika'  : '2.9.2',
+  'pdfbox': '2.0.31',
+  'poi'   : '5.2.5',
+  'mime4j': '0.8.11'
 ]
 
 dependencies {
@@ -50,6 +50,16 @@ dependencies {
   api "org.apache.tika:tika-parsers:${versions.tika}"
   // Required for the various document parsers
   api "org.apache.tika:tika-parsers-standard-package:${versions.tika}"
+  api "org.apache.tika:tika-parser-apple-module:${versions.tika}"
+  api "org.apache.tika:tika-parser-html-module:${versions.tika}"
+  api "org.apache.tika:tika-parser-microsoft-module:${versions.tika}"
+  api "org.apache.tika:tika-parser-miscoffice-module:${versions.tika}"
+  api "org.apache.tika:tika-parser-pdf-module:${versions.tika}"
+  api "org.apache.tika:tika-parser-text-module:${versions.tika}"
+  api "org.apache.tika:tika-parser-xml-module:${versions.tika}"
+  // Utilities consumed by document parsers
+  api "org.apache.tika:tika-parser-xmp-commons:${versions.tika}"
+  api "org.apache.tika:tika-parser-zip-commons:${versions.tika}"
   // Required for language detection
   api "org.apache.tika:tika-langdetect-optimaize:${versions.tika}"
   // Optimaize libraries/dependencies
@@ -57,7 +67,7 @@ dependencies {
   runtimeOnly "com.google.guava:guava:${versions.guava}"
   // Other dependencies
   api 'org.tukaani:xz:1.9'
-  api 'commons-io:commons-io:2.15.1'
+  api "commons-io:commons-io:${versions.commonsio}"
   api "org.slf4j:slf4j-api:${versions.slf4j}"
 
   // character set detection
diff --git a/plugins/ingest-attachment/licenses/apache-mime4j-core-0.8.11.jar.sha1 b/plugins/ingest-attachment/licenses/apache-mime4j-core-0.8.11.jar.sha1
new file mode 100644
index 0000000000000..82d9bf2617ce6
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/apache-mime4j-core-0.8.11.jar.sha1
@@ -0,0 +1 @@
+6d1eb5f7b84eaa9d38fca13b761f01c693aef3da
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/apache-mime4j-core-0.8.8.jar.sha1 b/plugins/ingest-attachment/licenses/apache-mime4j-core-0.8.8.jar.sha1
deleted file mode 100644
index 77c36691d36b5..0000000000000
--- a/plugins/ingest-attachment/licenses/apache-mime4j-core-0.8.8.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-7330de23c52f71617cbec7f1d2760dae32e687cd
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/apache-mime4j-dom-0.8.11.jar.sha1 b/plugins/ingest-attachment/licenses/apache-mime4j-dom-0.8.11.jar.sha1
new file mode 100644
index 0000000000000..7a494aba6a231
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/apache-mime4j-dom-0.8.11.jar.sha1
@@ -0,0 +1 @@
+f0d42ab9a5832b5f5d05afc004b31245b838e0fc
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/apache-mime4j-dom-0.8.8.jar.sha1 b/plugins/ingest-attachment/licenses/apache-mime4j-dom-0.8.8.jar.sha1
deleted file mode 100644
index fb9c5fed27162..0000000000000
--- a/plugins/ingest-attachment/licenses/apache-mime4j-dom-0.8.8.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-e76715563a6bd150f84ccb0adb920aec8faf4779
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/commons-codec-1.15.jar.sha1 b/plugins/ingest-attachment/licenses/commons-codec-1.15.jar.sha1
deleted file mode 100644
index 62d99837b87e1..0000000000000
--- a/plugins/ingest-attachment/licenses/commons-codec-1.15.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-49d94806b6e3dc933dacbd8acb0fdbab8ebd1e5d
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/commons-codec-1.16.1.jar.sha1 b/plugins/ingest-attachment/licenses/commons-codec-1.16.1.jar.sha1
new file mode 100644
index 0000000000000..6b8803089c6d7
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/commons-codec-1.16.1.jar.sha1
@@ -0,0 +1 @@
+47bd4d333fba53406f6c6c51884ddbca435c8862
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/commons-compress-1.24.0.jar.sha1 b/plugins/ingest-attachment/licenses/commons-compress-1.24.0.jar.sha1
deleted file mode 100644
index 23999d1bfbde4..0000000000000
--- a/plugins/ingest-attachment/licenses/commons-compress-1.24.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b4b1b5a3d9573b2970fddab236102c0a4d27d35e
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/commons-compress-1.26.1.jar.sha1 b/plugins/ingest-attachment/licenses/commons-compress-1.26.1.jar.sha1
new file mode 100644
index 0000000000000..912bda85de18a
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/commons-compress-1.26.1.jar.sha1
@@ -0,0 +1 @@
+44331c1130c370e726a2e1a3e6fba6d2558ef04a
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/commons-io-2.15.1.jar.sha1 b/plugins/ingest-attachment/licenses/commons-io-2.15.1.jar.sha1
deleted file mode 100644
index 47c5d13812a36..0000000000000
--- a/plugins/ingest-attachment/licenses/commons-io-2.15.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-f11560da189ab563a5c8e351941415430e9304ea
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/commons-io-2.16.0.jar.sha1 b/plugins/ingest-attachment/licenses/commons-io-2.16.0.jar.sha1
new file mode 100644
index 0000000000000..6a7b638719fa3
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/commons-io-2.16.0.jar.sha1
@@ -0,0 +1 @@
+27875a7935f1ddcc13267eb6fae1f719e0409572
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/commons-lang3-3.13.0.jar.sha1 b/plugins/ingest-attachment/licenses/commons-lang3-3.13.0.jar.sha1
deleted file mode 100644
index d0c2f2486ee1f..0000000000000
--- a/plugins/ingest-attachment/licenses/commons-lang3-3.13.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b7263237aa89c1f99b327197c41d0669707a462e
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/commons-lang3-3.14.0.jar.sha1 b/plugins/ingest-attachment/licenses/commons-lang3-3.14.0.jar.sha1
new file mode 100644
index 0000000000000..d783e07e40902
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/commons-lang3-3.14.0.jar.sha1
@@ -0,0 +1 @@
+1ed471194b02f2c6cb734a0cd6f6f107c673afae
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/fontbox-2.0.27.jar.sha1 b/plugins/ingest-attachment/licenses/fontbox-2.0.27.jar.sha1
deleted file mode 100644
index d578dffbfa3f6..0000000000000
--- a/plugins/ingest-attachment/licenses/fontbox-2.0.27.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-d08c064d18b2b149da937d15c0d1708cba03f29d
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/fontbox-2.0.31.jar.sha1 b/plugins/ingest-attachment/licenses/fontbox-2.0.31.jar.sha1
new file mode 100644
index 0000000000000..d45d45a66e072
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/fontbox-2.0.31.jar.sha1
@@ -0,0 +1 @@
+96999ecdb7324bf718b88724818fa62f81286c36
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/pdfbox-2.0.27.jar.sha1 b/plugins/ingest-attachment/licenses/pdfbox-2.0.27.jar.sha1
deleted file mode 100644
index 4f670b7f95e8c..0000000000000
--- a/plugins/ingest-attachment/licenses/pdfbox-2.0.27.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-416a9dfce3714116bfdf793b15368df04266845f
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/pdfbox-2.0.31.jar.sha1 b/plugins/ingest-attachment/licenses/pdfbox-2.0.31.jar.sha1
new file mode 100644
index 0000000000000..fa256ed9a65d2
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/pdfbox-2.0.31.jar.sha1
@@ -0,0 +1 @@
+29b25053099bc30784a766ccb821417e06f4b8a1
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/poi-5.2.3.jar.sha1 b/plugins/ingest-attachment/licenses/poi-5.2.3.jar.sha1
deleted file mode 100644
index 3d8b3daf606ad..0000000000000
--- a/plugins/ingest-attachment/licenses/poi-5.2.3.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-2fb22ae74ad5aea6af1a9c64b9542f2ccf348604
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/poi-5.2.5.jar.sha1 b/plugins/ingest-attachment/licenses/poi-5.2.5.jar.sha1
new file mode 100644
index 0000000000000..0eca17726eb0b
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/poi-5.2.5.jar.sha1
@@ -0,0 +1 @@
+7e00f6b2f76375fe89022d5a7db8acb71cbd55f5
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/poi-ooxml-5.2.3.jar.sha1 b/plugins/ingest-attachment/licenses/poi-ooxml-5.2.3.jar.sha1
deleted file mode 100644
index 8371593cf0841..0000000000000
--- a/plugins/ingest-attachment/licenses/poi-ooxml-5.2.3.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-02efd11c940adb18c03eb9ce7ad88fc40ee6a196
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/poi-ooxml-5.2.5.jar.sha1 b/plugins/ingest-attachment/licenses/poi-ooxml-5.2.5.jar.sha1
new file mode 100644
index 0000000000000..6b14be4461425
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/poi-ooxml-5.2.5.jar.sha1
@@ -0,0 +1 @@
+df9f2c52371eeba24db8ea8cafa77285c3cc0742
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/poi-ooxml-lite-5.2.3.jar.sha1 b/plugins/ingest-attachment/licenses/poi-ooxml-lite-5.2.3.jar.sha1
deleted file mode 100644
index 5c6365876b7be..0000000000000
--- a/plugins/ingest-attachment/licenses/poi-ooxml-lite-5.2.3.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-db113c8e9051b0ff967f4911fa20336c8325a7c5
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/poi-ooxml-lite-5.2.5.jar.sha1 b/plugins/ingest-attachment/licenses/poi-ooxml-lite-5.2.5.jar.sha1
new file mode 100644
index 0000000000000..f9a473173a297
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/poi-ooxml-lite-5.2.5.jar.sha1
@@ -0,0 +1 @@
+eaa61452d8f0d13080fbb4757a392f09f90e4c49
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/poi-scratchpad-5.2.3.jar.sha1 b/plugins/ingest-attachment/licenses/poi-scratchpad-5.2.3.jar.sha1
deleted file mode 100644
index 3c8f92498f1a4..0000000000000
--- a/plugins/ingest-attachment/licenses/poi-scratchpad-5.2.3.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-2a7fce47e22b7fedb1b277347ff4fe36d6eda50d
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/poi-scratchpad-5.2.5.jar.sha1 b/plugins/ingest-attachment/licenses/poi-scratchpad-5.2.5.jar.sha1
new file mode 100644
index 0000000000000..68665ddafd7d8
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/poi-scratchpad-5.2.5.jar.sha1
@@ -0,0 +1 @@
+fc600cf765a49d73935a6e48a5b84f4abcdd0518
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-core-2.6.0.jar.sha1 b/plugins/ingest-attachment/licenses/tika-core-2.6.0.jar.sha1
deleted file mode 100644
index c66c2f3f39401..0000000000000
--- a/plugins/ingest-attachment/licenses/tika-core-2.6.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-f6ed6356dd4a9bd269d873f65494376685e6192e
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-core-2.9.2.jar.sha1 b/plugins/ingest-attachment/licenses/tika-core-2.9.2.jar.sha1
new file mode 100644
index 0000000000000..80635a63d29fe
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/tika-core-2.9.2.jar.sha1
@@ -0,0 +1 @@
+796a21391780339e3d4862626339b49df170024e
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-langdetect-optimaize-2.6.0.jar.sha1 b/plugins/ingest-attachment/licenses/tika-langdetect-optimaize-2.6.0.jar.sha1
deleted file mode 100644
index e7bc59bb5ae49..0000000000000
--- a/plugins/ingest-attachment/licenses/tika-langdetect-optimaize-2.6.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-72b784a7bdab0ffde005fa64d15e3f077331d6fc
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-langdetect-optimaize-2.9.2.jar.sha1 b/plugins/ingest-attachment/licenses/tika-langdetect-optimaize-2.9.2.jar.sha1
new file mode 100644
index 0000000000000..a4bb6d48c6a08
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/tika-langdetect-optimaize-2.9.2.jar.sha1
@@ -0,0 +1 @@
+7a48a287e464b456a85c79f318d7bad7db201518
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-parser-apple-module-2.9.2.jar.sha1 b/plugins/ingest-attachment/licenses/tika-parser-apple-module-2.9.2.jar.sha1
new file mode 100644
index 0000000000000..dbaee880d1251
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/tika-parser-apple-module-2.9.2.jar.sha1
@@ -0,0 +1 @@
+758dac27c246c51b019562bab7e266d2da6a6e01
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-parser-html-module-2.9.2.jar.sha1 b/plugins/ingest-attachment/licenses/tika-parser-html-module-2.9.2.jar.sha1
new file mode 100644
index 0000000000000..b4806746301ef
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/tika-parser-html-module-2.9.2.jar.sha1
@@ -0,0 +1 @@
+47f6a4c46b92616d14e82cd7ad4d05cb43077b83
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-parser-microsoft-module-2.9.2.jar.sha1 b/plugins/ingest-attachment/licenses/tika-parser-microsoft-module-2.9.2.jar.sha1
new file mode 100644
index 0000000000000..da1ae42bac652
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/tika-parser-microsoft-module-2.9.2.jar.sha1
@@ -0,0 +1 @@
+235a20823c02c699ce3d57f3d6b9550db05d91a9
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-parser-miscoffice-module-2.9.2.jar.sha1 b/plugins/ingest-attachment/licenses/tika-parser-miscoffice-module-2.9.2.jar.sha1
new file mode 100644
index 0000000000000..7ceed9e1643b8
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/tika-parser-miscoffice-module-2.9.2.jar.sha1
@@ -0,0 +1 @@
+7688a4220d07c32b505230479f957cd495c0bef2
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-parser-pdf-module-2.9.2.jar.sha1 b/plugins/ingest-attachment/licenses/tika-parser-pdf-module-2.9.2.jar.sha1
new file mode 100644
index 0000000000000..e780c1b92d525
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/tika-parser-pdf-module-2.9.2.jar.sha1
@@ -0,0 +1 @@
+4d0f0e3f6eff184040402094f4fabbb3c5c7d09f
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-parser-text-module-2.9.2.jar.sha1 b/plugins/ingest-attachment/licenses/tika-parser-text-module-2.9.2.jar.sha1
new file mode 100644
index 0000000000000..6e56fcffc5f88
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/tika-parser-text-module-2.9.2.jar.sha1
@@ -0,0 +1 @@
+b3a93e538ba6cb4066aba96d629febf181ec9f92
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-parser-xml-module-2.9.2.jar.sha1 b/plugins/ingest-attachment/licenses/tika-parser-xml-module-2.9.2.jar.sha1
new file mode 100644
index 0000000000000..27062077b92bf
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/tika-parser-xml-module-2.9.2.jar.sha1
@@ -0,0 +1 @@
+ff707716c0c4748ffeb21996aefa8d269b3eab5b
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-parser-xmp-commons-2.9.2.jar.sha1 b/plugins/ingest-attachment/licenses/tika-parser-xmp-commons-2.9.2.jar.sha1
new file mode 100644
index 0000000000000..396e2655b14db
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/tika-parser-xmp-commons-2.9.2.jar.sha1
@@ -0,0 +1 @@
+69104107ff85194df5acf682178128771863e442
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-parser-zip-commons-2.9.2.jar.sha1 b/plugins/ingest-attachment/licenses/tika-parser-zip-commons-2.9.2.jar.sha1
new file mode 100644
index 0000000000000..bda62033e4e8c
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/tika-parser-zip-commons-2.9.2.jar.sha1
@@ -0,0 +1 @@
+2fcea85a56f93a5c0cb81f3d6dd8673f3d81c598
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-parsers-standard-package-2.6.0.jar.sha1 b/plugins/ingest-attachment/licenses/tika-parsers-standard-package-2.6.0.jar.sha1
deleted file mode 100644
index 83c0777fcbe8a..0000000000000
--- a/plugins/ingest-attachment/licenses/tika-parsers-standard-package-2.6.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-00980e70b1df13c1236b750f0ca1462edd5d7417
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/tika-parsers-standard-package-2.9.2.jar.sha1 b/plugins/ingest-attachment/licenses/tika-parsers-standard-package-2.9.2.jar.sha1
new file mode 100644
index 0000000000000..bb76974b6344e
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/tika-parsers-standard-package-2.9.2.jar.sha1
@@ -0,0 +1 @@
+c8408deb51fa617ef4e912b4d161712e695d3a29
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/commons-lang3-3.13.0.jar.sha1 b/plugins/repository-azure/licenses/commons-lang3-3.13.0.jar.sha1
deleted file mode 100644
index d0c2f2486ee1f..0000000000000
--- a/plugins/repository-azure/licenses/commons-lang3-3.13.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b7263237aa89c1f99b327197c41d0669707a462e
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/commons-lang3-3.14.0.jar.sha1 b/plugins/repository-azure/licenses/commons-lang3-3.14.0.jar.sha1
new file mode 100644
index 0000000000000..d783e07e40902
--- /dev/null
+++ b/plugins/repository-azure/licenses/commons-lang3-3.14.0.jar.sha1
@@ -0,0 +1 @@
+1ed471194b02f2c6cb734a0cd6f6f107c673afae
\ No newline at end of file
diff --git a/plugins/repository-gcs/licenses/commons-codec-1.15.jar.sha1 b/plugins/repository-gcs/licenses/commons-codec-1.15.jar.sha1
deleted file mode 100644
index 62d99837b87e1..0000000000000
--- a/plugins/repository-gcs/licenses/commons-codec-1.15.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-49d94806b6e3dc933dacbd8acb0fdbab8ebd1e5d
\ No newline at end of file
diff --git a/plugins/repository-gcs/licenses/commons-codec-1.16.1.jar.sha1 b/plugins/repository-gcs/licenses/commons-codec-1.16.1.jar.sha1
new file mode 100644
index 0000000000000..6b8803089c6d7
--- /dev/null
+++ b/plugins/repository-gcs/licenses/commons-codec-1.16.1.jar.sha1
@@ -0,0 +1 @@
+47bd4d333fba53406f6c6c51884ddbca435c8862
\ No newline at end of file
diff --git a/plugins/repository-hdfs/build.gradle b/plugins/repository-hdfs/build.gradle
index af07fa9e5d80b..2c51bb4cbea53 100644
--- a/plugins/repository-hdfs/build.gradle
+++ b/plugins/repository-hdfs/build.gradle
@@ -75,7 +75,7 @@ dependencies {
   api 'commons-collections:commons-collections:3.2.2'
   api "org.apache.commons:commons-compress:${versions.commonscompress}"
   api 'org.apache.commons:commons-configuration2:2.10.1'
-  api 'commons-io:commons-io:2.15.1'
+  api "commons-io:commons-io:${versions.commonsio}"
   api 'org.apache.commons:commons-lang3:3.14.0'
   implementation 'com.google.re2j:re2j:1.7'
   api 'javax.servlet:servlet-api:2.5'
diff --git a/plugins/repository-hdfs/licenses/commons-codec-1.15.jar.sha1 b/plugins/repository-hdfs/licenses/commons-codec-1.15.jar.sha1
deleted file mode 100644
index 62d99837b87e1..0000000000000
--- a/plugins/repository-hdfs/licenses/commons-codec-1.15.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-49d94806b6e3dc933dacbd8acb0fdbab8ebd1e5d
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/commons-codec-1.16.1.jar.sha1 b/plugins/repository-hdfs/licenses/commons-codec-1.16.1.jar.sha1
new file mode 100644
index 0000000000000..6b8803089c6d7
--- /dev/null
+++ b/plugins/repository-hdfs/licenses/commons-codec-1.16.1.jar.sha1
@@ -0,0 +1 @@
+47bd4d333fba53406f6c6c51884ddbca435c8862
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/commons-compress-1.24.0.jar.sha1 b/plugins/repository-hdfs/licenses/commons-compress-1.24.0.jar.sha1
deleted file mode 100644
index 23999d1bfbde4..0000000000000
--- a/plugins/repository-hdfs/licenses/commons-compress-1.24.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b4b1b5a3d9573b2970fddab236102c0a4d27d35e
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/commons-compress-1.26.1.jar.sha1 b/plugins/repository-hdfs/licenses/commons-compress-1.26.1.jar.sha1
new file mode 100644
index 0000000000000..912bda85de18a
--- /dev/null
+++ b/plugins/repository-hdfs/licenses/commons-compress-1.26.1.jar.sha1
@@ -0,0 +1 @@
+44331c1130c370e726a2e1a3e6fba6d2558ef04a
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/commons-io-2.15.1.jar.sha1 b/plugins/repository-hdfs/licenses/commons-io-2.15.1.jar.sha1
deleted file mode 100644
index 47c5d13812a36..0000000000000
--- a/plugins/repository-hdfs/licenses/commons-io-2.15.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-f11560da189ab563a5c8e351941415430e9304ea
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/commons-io-2.16.0.jar.sha1 b/plugins/repository-hdfs/licenses/commons-io-2.16.0.jar.sha1
new file mode 100644
index 0000000000000..6a7b638719fa3
--- /dev/null
+++ b/plugins/repository-hdfs/licenses/commons-io-2.16.0.jar.sha1
@@ -0,0 +1 @@
+27875a7935f1ddcc13267eb6fae1f719e0409572
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/commons-codec-1.15.jar.sha1 b/plugins/repository-s3/licenses/commons-codec-1.15.jar.sha1
deleted file mode 100644
index 62d99837b87e1..0000000000000
--- a/plugins/repository-s3/licenses/commons-codec-1.15.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-49d94806b6e3dc933dacbd8acb0fdbab8ebd1e5d
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/commons-codec-1.16.1.jar.sha1 b/plugins/repository-s3/licenses/commons-codec-1.16.1.jar.sha1
new file mode 100644
index 0000000000000..6b8803089c6d7
--- /dev/null
+++ b/plugins/repository-s3/licenses/commons-codec-1.16.1.jar.sha1
@@ -0,0 +1 @@
+47bd4d333fba53406f6c6c51884ddbca435c8862
\ No newline at end of file
diff --git a/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3BlobContainer.java b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3BlobContainer.java
index 25f361b40636e..1f23a09a047f2 100644
--- a/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3BlobContainer.java
+++ b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3BlobContainer.java
@@ -285,7 +285,7 @@ public void readBlobAsync(String blobName, ActionListener<ReadContext> listener)
                             );
                         }
                     }
-                    listener.onResponse(new ReadContext(blobSize, blobPartInputStreamFutures, blobChecksum));
+                    listener.onResponse(new ReadContext.Builder(blobSize, blobPartInputStreamFutures).blobChecksum(blobChecksum).build());
                 } catch (Exception ex) {
                     listener.onFailure(ex);
                 }
diff --git a/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/S3BlobContainerMockClientTests.java b/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/S3BlobContainerMockClientTests.java
index 8c7e196d7c812..9e830c409a58b 100644
--- a/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/S3BlobContainerMockClientTests.java
+++ b/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/S3BlobContainerMockClientTests.java
@@ -30,7 +30,7 @@
 
 import org.apache.lucene.store.IndexInput;
 import org.opensearch.cluster.metadata.RepositoryMetadata;
-import org.opensearch.common.CheckedTriFunction;
+import org.opensearch.common.CheckedConsumer;
 import org.opensearch.common.StreamContext;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.blobstore.stream.write.StreamContextSupplier;
@@ -49,6 +49,7 @@
 import org.opensearch.repositories.s3.async.AsyncTransferManager;
 import org.opensearch.test.OpenSearchTestCase;
 import org.junit.After;
+import org.junit.Assert;
 import org.junit.Before;
 
 import java.io.IOException;
@@ -466,24 +467,30 @@ private void testWriteBlobByStreams(boolean expectException, boolean throwExcept
             exceptionRef.set(ex);
             countDownLatch.countDown();
         });
-        blobContainer.asyncBlobUpload(new WriteContext("write_blob_by_streams_max_retries", new StreamContextSupplier() {
-            @Override
-            public StreamContext supplyStreamContext(long partSize) {
-                return new StreamContext(new CheckedTriFunction<Integer, Long, Long, InputStreamContainer, IOException>() {
-                    @Override
-                    public InputStreamContainer apply(Integer partNo, Long size, Long position) throws IOException {
-                        InputStream inputStream = new OffsetRangeIndexInputStream(new ByteArrayIndexInput("desc", bytes), size, position);
-                        openInputStreams.add(inputStream);
-                        return new InputStreamContainer(inputStream, size, position);
-                    }
-                }, partSize, calculateLastPartSize(bytes.length, partSize), calculateNumberOfParts(bytes.length, partSize));
-            }
-        }, bytes.length, false, WritePriority.NORMAL, uploadSuccess -> {
+
+        StreamContextSupplier streamContextSupplier = partSize -> new StreamContext((partNo, size, position) -> {
+            InputStream inputStream = new OffsetRangeIndexInputStream(new ByteArrayIndexInput("desc", bytes), size, position);
+            openInputStreams.add(inputStream);
+            return new InputStreamContainer(inputStream, size, position);
+        }, partSize, calculateLastPartSize(bytes.length, partSize), calculateNumberOfParts(bytes.length, partSize));
+
+        CheckedConsumer<Boolean, IOException> uploadFinalizer = uploadSuccess -> {
             assertTrue(uploadSuccess);
             if (throwExceptionOnFinalizeUpload) {
                 throw new RuntimeException();
             }
-        }, false, null), completionListener);
+        };
+
+        WriteContext writeContext = new WriteContext.Builder().fileName("write_blob_by_streams_max_retries")
+            .streamContextSupplier(streamContextSupplier)
+            .fileSize(bytes.length)
+            .failIfAlreadyExists(false)
+            .writePriority(WritePriority.NORMAL)
+            .uploadFinalizer(uploadFinalizer)
+            .doRemoteDataIntegrityCheck(false)
+            .build();
+
+        blobContainer.asyncBlobUpload(writeContext, completionListener);
 
         assertTrue(countDownLatch.await(5000, TimeUnit.SECONDS));
         // wait for completableFuture to finish
@@ -516,24 +523,30 @@ private void testWriteBlobByStreamsLargeBlob(boolean expectException, boolean th
             countDownLatch.countDown();
         });
         List<InputStream> openInputStreams = new ArrayList<>();
-        blobContainer.asyncBlobUpload(new WriteContext("write_large_blob", new StreamContextSupplier() {
-            @Override
-            public StreamContext supplyStreamContext(long partSize) {
-                return new StreamContext(new CheckedTriFunction<Integer, Long, Long, InputStreamContainer, IOException>() {
-                    @Override
-                    public InputStreamContainer apply(Integer partNo, Long size, Long position) throws IOException {
-                        InputStream inputStream = new OffsetRangeIndexInputStream(new ZeroIndexInput("desc", blobSize), size, position);
-                        openInputStreams.add(inputStream);
-                        return new InputStreamContainer(inputStream, size, position);
-                    }
-                }, partSize, calculateLastPartSize(blobSize, partSize), calculateNumberOfParts(blobSize, partSize));
-            }
-        }, blobSize, false, WritePriority.NORMAL, uploadSuccess -> {
+
+        StreamContextSupplier streamContextSupplier = partSize1 -> new StreamContext((partNo, size, position) -> {
+            InputStream inputStream = new OffsetRangeIndexInputStream(new ZeroIndexInput("desc", blobSize), size, position);
+            openInputStreams.add(inputStream);
+            return new InputStreamContainer(inputStream, size, position);
+        }, partSize1, calculateLastPartSize(blobSize, partSize1), calculateNumberOfParts(blobSize, partSize1));
+
+        CheckedConsumer<Boolean, IOException> uploadFinalizer = uploadSuccess -> {
             assertTrue(uploadSuccess);
             if (throwExceptionOnFinalizeUpload) {
                 throw new RuntimeException();
             }
-        }, false, null), completionListener);
+        };
+
+        WriteContext writeContext = new WriteContext.Builder().fileName("write_large_blob")
+            .streamContextSupplier(streamContextSupplier)
+            .fileSize(blobSize)
+            .failIfAlreadyExists(false)
+            .writePriority(WritePriority.NORMAL)
+            .uploadFinalizer(uploadFinalizer)
+            .doRemoteDataIntegrityCheck(false)
+            .build();
+
+        blobContainer.asyncBlobUpload(writeContext, completionListener);
 
         assertTrue(countDownLatch.await(5000, TimeUnit.SECONDS));
         if (expectException || throwExceptionOnFinalizeUpload) {
@@ -632,20 +645,23 @@ private void testLargeFilesRedirectedToSlowSyncClient(boolean expectException) t
 
         List<InputStream> openInputStreams = new ArrayList<>();
         final S3BlobContainer s3BlobContainer = Mockito.spy(new S3BlobContainer(blobPath, blobStore));
-        s3BlobContainer.asyncBlobUpload(new WriteContext("write_large_blob", new StreamContextSupplier() {
-            @Override
-            public StreamContext supplyStreamContext(long partSize) {
-                return new StreamContext(new CheckedTriFunction<Integer, Long, Long, InputStreamContainer, IOException>() {
-                    @Override
-                    public InputStreamContainer apply(Integer partNo, Long size, Long position) throws IOException {
-                        InputStream inputStream = new OffsetRangeIndexInputStream(new ZeroIndexInput("desc", blobSize), size, position);
-                        openInputStreams.add(inputStream);
-                        return new InputStreamContainer(inputStream, size, position);
-                    }
-                }, partSize, calculateLastPartSize(blobSize, partSize), calculateNumberOfParts(blobSize, partSize));
-            }
-        }, blobSize, false, WritePriority.HIGH, uploadSuccess -> { assertTrue(uploadSuccess); }, false, null), completionListener);
 
+        StreamContextSupplier streamContextSupplier = partSize1 -> new StreamContext((partNo, size, position) -> {
+            InputStream inputStream = new OffsetRangeIndexInputStream(new ZeroIndexInput("desc", blobSize), size, position);
+            openInputStreams.add(inputStream);
+            return new InputStreamContainer(inputStream, size, position);
+        }, partSize1, calculateLastPartSize(blobSize, partSize1), calculateNumberOfParts(blobSize, partSize1));
+
+        WriteContext writeContext = new WriteContext.Builder().fileName("write_large_blob")
+            .streamContextSupplier(streamContextSupplier)
+            .fileSize(blobSize)
+            .failIfAlreadyExists(false)
+            .writePriority(WritePriority.HIGH)
+            .uploadFinalizer(Assert::assertTrue)
+            .doRemoteDataIntegrityCheck(false)
+            .build();
+
+        s3BlobContainer.asyncBlobUpload(writeContext, completionListener);
         assertTrue(countDownLatch.await(5000, TimeUnit.SECONDS));
         if (expectException) {
             assertNotNull(exceptionRef.get());
diff --git a/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/S3BlobContainerRetriesTests.java b/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/S3BlobContainerRetriesTests.java
index ceab06bd051e9..8e25ba4d950ef 100644
--- a/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/S3BlobContainerRetriesTests.java
+++ b/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/S3BlobContainerRetriesTests.java
@@ -37,7 +37,6 @@
 
 import org.apache.http.HttpStatus;
 import org.opensearch.cluster.metadata.RepositoryMetadata;
-import org.opensearch.common.CheckedTriFunction;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.StreamContext;
 import org.opensearch.common.SuppressForbidden;
@@ -332,22 +331,24 @@ public void testWriteBlobByStreamsWithRetries() throws Exception {
             exceptionRef.set(ex);
             countDownLatch.countDown();
         });
-        blobContainer.asyncBlobUpload(new WriteContext("write_blob_by_streams_max_retries", new StreamContextSupplier() {
-            @Override
-            public StreamContext supplyStreamContext(long partSize) {
-                return new StreamContext(new CheckedTriFunction<Integer, Long, Long, InputStreamContainer, IOException>() {
-                    @Override
-                    public InputStreamContainer apply(Integer partNo, Long size, Long position) throws IOException {
-                        InputStream inputStream = new OffsetRangeIndexInputStream(new ByteArrayIndexInput("desc", bytes), size, position);
-                        openInputStreams.add(inputStream);
-                        return new InputStreamContainer(inputStream, size, position);
-                    }
-                }, partSize, calculateLastPartSize(bytes.length, partSize), calculateNumberOfParts(bytes.length, partSize));
-            }
-        }, bytes.length, false, WritePriority.NORMAL, Assert::assertTrue, false, null), completionListener);
 
+        StreamContextSupplier streamContextSupplier = partSize -> new StreamContext((partNo, size, position) -> {
+            InputStream inputStream = new OffsetRangeIndexInputStream(new ByteArrayIndexInput("desc", bytes), size, position);
+            openInputStreams.add(inputStream);
+            return new InputStreamContainer(inputStream, size, position);
+        }, partSize, calculateLastPartSize(bytes.length, partSize), calculateNumberOfParts(bytes.length, partSize));
+
+        WriteContext writeContext = new WriteContext.Builder().fileName("write_blob_by_streams_max_retries")
+            .streamContextSupplier(streamContextSupplier)
+            .fileSize(bytes.length)
+            .failIfAlreadyExists(false)
+            .writePriority(WritePriority.NORMAL)
+            .uploadFinalizer(Assert::assertTrue)
+            .doRemoteDataIntegrityCheck(false)
+            .build();
+
+        blobContainer.asyncBlobUpload(writeContext, completionListener);
         assertTrue(countDownLatch.await(5000, TimeUnit.SECONDS));
-
         assertThat(countDown.isCountedDown(), is(true));
 
         openInputStreams.forEach(inputStream -> {
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.aliases.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.aliases.json
index 1ba12b00c8178..b280452e313da 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.aliases.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.aliases.json
@@ -1,7 +1,7 @@
 {
   "cat.aliases":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-alias.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-aliases/",
       "description":"Shows information about currently configured aliases to indices including filter and routing infos."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.allocation.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.allocation.json
index 717c1c49808f6..a56d3e9e8a95e 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.allocation.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.allocation.json
@@ -1,7 +1,7 @@
 {
   "cat.allocation":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-allocation.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-allocation/",
       "description":"Provides a snapshot of how many shards are allocated to each data node and how much disk space they are using."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.cluster_manager.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.cluster_manager.json
index cd96038ad0693..3b999d98eb60d 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.cluster_manager.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.cluster_manager.json
@@ -1,7 +1,7 @@
 {
   "cat.cluster_manager":{
     "documentation":{
-      "url":"https://opensearch.org/docs/latest/opensearch/rest-api/cat/cat-master/",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-cluster_manager/",
       "description":"Returns information about the cluster-manager node."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.count.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.count.json
index 8cfaddf8db83b..e85f399c29fd3 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.count.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.count.json
@@ -1,7 +1,7 @@
 {
   "cat.count":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-count.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-count/",
       "description":"Provides quick access to the document count of the entire cluster, or individual indices."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.fielddata.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.fielddata.json
index 9fbde4736b5ef..f2a3cfa8250cb 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.fielddata.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.fielddata.json
@@ -1,7 +1,7 @@
 {
   "cat.fielddata":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-fielddata.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-field-data/",
       "description":"Shows how much heap memory is currently being used by fielddata on every data node in the cluster."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.help.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.help.json
index 54ab6d6e5168c..c2f1771977cd5 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.help.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.help.json
@@ -1,7 +1,7 @@
 {
   "cat.help":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/index/",
       "description":"Returns help for the Cat APIs."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.indices.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.indices.json
index 2491ab309531d..aa36f8fd809aa 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.indices.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.indices.json
@@ -1,7 +1,7 @@
 {
   "cat.indices":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-indices.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-indices/",
       "description":"Returns information about indices: number of primaries and replicas, document counts, disk size, ..."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.nodeattrs.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.nodeattrs.json
index c8afa4cb17039..92a7e14b234ce 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.nodeattrs.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.nodeattrs.json
@@ -1,7 +1,7 @@
 {
   "cat.nodeattrs":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-nodeattrs.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-nodeattrs/",
       "description":"Returns information about custom node attributes."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.nodes.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.nodes.json
index abb13d015b4d5..63c70afcb9465 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.nodes.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.nodes.json
@@ -1,7 +1,7 @@
 {
   "cat.nodes":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-nodes.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-nodes/",
       "description":"Returns basic statistics about performance of cluster nodes."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.pending_tasks.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.pending_tasks.json
index 9c0edf8c53d90..d89ce8af72270 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.pending_tasks.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.pending_tasks.json
@@ -1,7 +1,7 @@
 {
   "cat.pending_tasks":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-pending-tasks.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-pending-tasks/",
       "description":"Returns a concise representation of the cluster pending tasks."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.plugins.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.plugins.json
index 0b5b39b01ee58..5dd76c0dec4e4 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.plugins.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.plugins.json
@@ -1,7 +1,7 @@
 {
   "cat.plugins":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-plugins.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-plugins/",
       "description":"Returns information about installed plugins across nodes node."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.recovery.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.recovery.json
index 7baf0b8ded609..a3dee81e73abc 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.recovery.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.recovery.json
@@ -1,7 +1,7 @@
 {
   "cat.recovery":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-recovery.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-recovery/",
       "description":"Returns information about index shard recoveries, both on-going completed."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.repositories.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.repositories.json
index 58960709a99bb..a8174bbd48e07 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.repositories.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.repositories.json
@@ -1,7 +1,7 @@
 {
   "cat.repositories":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-repositories.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-repositories/",
       "description":"Returns information about snapshot repositories registered in the cluster."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.segment_replication.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.segment_replication.json
index a815cd5b1101b..91d913d7c9340 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.segment_replication.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.segment_replication.json
@@ -1,7 +1,7 @@
 {
   "cat.segment_replication":{
     "documentation":{
-      "url":"https://github.com/opensearch-project/documentation-website/issues/2627",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-segment-replication/",
       "description":"Returns information about both on-going and latest completed Segment Replication events"
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.segments.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.segments.json
index 5107353c7b14f..f9b0de3e2eb50 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.segments.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.segments.json
@@ -1,7 +1,7 @@
 {
   "cat.segments":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-segments.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-segments/",
       "description":"Provides low-level information about the segments in the shards of an index."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.shards.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.shards.json
index fab381a098e3f..05a04c4b580ec 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.shards.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.shards.json
@@ -1,7 +1,7 @@
 {
   "cat.shards":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-shards.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-shards/",
       "description":"Provides a detailed view of shard allocation on nodes."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.snapshots.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.snapshots.json
index 1320207abfe75..c6eb24a50e435 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.snapshots.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.snapshots.json
@@ -1,7 +1,7 @@
 {
   "cat.snapshots":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-snapshots.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-snapshots/",
       "description":"Returns all snapshots in a specific repository."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.tasks.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.tasks.json
index 384668f839642..806b993849940 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.tasks.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.tasks.json
@@ -1,7 +1,7 @@
 {
   "cat.tasks":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/tasks.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-tasks/",
       "description":"Returns information about the tasks currently executing on one or more nodes in the cluster."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.templates.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.templates.json
index d45593b7bb2c8..2f4a5f6e40186 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.templates.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.templates.json
@@ -1,7 +1,7 @@
 {
   "cat.templates":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-templates.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-templates/",
       "description":"Returns information about existing templates."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.thread_pool.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.thread_pool.json
index 1165703490d1a..e5bffbb43de5b 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cat.thread_pool.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cat.thread_pool.json
@@ -1,7 +1,7 @@
 {
   "cat.thread_pool":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-thread-pool.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cat/cat-thread-pool/",
       "description":"Returns cluster-wide thread pool statistics per node.\nBy default the active, queue and rejected statistics are returned for all thread pools."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/clear_scroll.json b/rest-api-spec/src/main/resources/rest-api-spec/api/clear_scroll.json
index b0e50045cd7cd..ed158978e44a4 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/clear_scroll.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/clear_scroll.json
@@ -1,7 +1,7 @@
 {
   "clear_scroll":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/current/clear-scroll-api.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/scroll/",
       "description":"Explicitly clears the search context for a scroll."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.allocation_explain.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.allocation_explain.json
index e46218a781e1b..2f5985faa5f63 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.allocation_explain.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.allocation_explain.json
@@ -1,7 +1,7 @@
 {
   "cluster.allocation_explain":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-allocation-explain.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cluster-api/cluster-allocation/",
       "description":"Provides explanations for shard allocations in the cluster."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.delete_component_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.delete_component_template.json
index 43e14ad0e2dd8..737716cec2527 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.delete_component_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.delete_component_template.json
@@ -1,7 +1,7 @@
 {
   "cluster.delete_component_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-component-template.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/index-templates/#create-a-component-template",
       "description":"Deletes a component template"
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.delete_decommission_awareness.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.delete_decommission_awareness.json
index 13ea101169e60..24e9a59baa742 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.delete_decommission_awareness.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.delete_decommission_awareness.json
@@ -1,7 +1,7 @@
 {
   "cluster.delete_decommission_awareness": {
     "documentation": {
-      "url": "https://opensearch.org/docs/latest/opensearch/rest-api/decommission/",
+      "url": "https://opensearch.org/docs/latest/api-reference/cluster-api/cluster-decommission/",
       "description": "Delete any existing decommission."
     },
     "stability": "experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.delete_weighted_routing.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.delete_weighted_routing.json
index 2cd4081b645e8..a6b09e34e488e 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.delete_weighted_routing.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.delete_weighted_routing.json
@@ -1,7 +1,7 @@
 {
   "cluster.delete_weighted_routing": {
     "documentation": {
-      "url": "https://opensearch.org/docs/latest/opensearch/rest-api/weighted-routing/delete",
+      "url": "https://opensearch.org/docs/latest/api-reference/cluster-api/cluster-awareness",
       "description": "Delete weighted shard routing weights"
     },
     "stability": "stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.get_decommission_awareness.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.get_decommission_awareness.json
index 302dea4ec31a7..feb760c2d7783 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.get_decommission_awareness.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.get_decommission_awareness.json
@@ -1,7 +1,7 @@
 {
   "cluster.get_decommission_awareness": {
     "documentation": {
-      "url": "https://opensearch.org/docs/latest/opensearch/rest-api/decommission/",
+      "url": "https://opensearch.org/docs/latest/api-reference/cluster-api/cluster-decommission/",
       "description": "Get details and status of decommissioned attribute"
     },
     "stability": "experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.get_settings.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.get_settings.json
index c60230dbc43b3..df3e6adb6596d 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.get_settings.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.get_settings.json
@@ -1,7 +1,7 @@
 {
   "cluster.get_settings":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-update-settings.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cluster-api/cluster-settings/",
       "description":"Returns cluster settings."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.get_weighted_routing.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.get_weighted_routing.json
index 45eb3d2b62a84..c800314f1297e 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.get_weighted_routing.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.get_weighted_routing.json
@@ -1,7 +1,7 @@
 {
   "cluster.get_weighted_routing": {
     "documentation": {
-      "url": "https://opensearch.org/docs/latest/opensearch/rest-api/weighted-routing/get",
+      "url": "https://opensearch.org/docs/latest/api-reference/cluster-api/cluster-awareness/",
       "description": "Fetches weighted shard routing weights"
     },
     "stability": "stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.health.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.health.json
index b96340d682546..db820bc4b2c85 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.health.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.health.json
@@ -1,7 +1,7 @@
 {
   "cluster.health":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-health.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cluster-api/cluster-health/",
       "description":"Returns basic information about the health of the cluster."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_component_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_component_template.json
index 05558bc7bfc50..5ac77f0f5eeb1 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_component_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_component_template.json
@@ -1,7 +1,7 @@
 {
   "cluster.put_component_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-component-template.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/index-templates/#create-a-component-template",
       "description":"Creates or updates a component template"
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_decommission_awareness.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_decommission_awareness.json
index bf4ffd454d9df..9bb0b4e96ff2b 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_decommission_awareness.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_decommission_awareness.json
@@ -1,7 +1,7 @@
 {
   "cluster.put_decommission_awareness": {
     "documentation": {
-      "url": "https://opensearch.org/docs/latest/opensearch/rest-api/decommission/",
+      "url": "https://opensearch.org/docs/latest/api-reference/cluster-api/cluster-decommission/",
       "description": "Decommissions an awareness attribute"
     },
     "stability": "experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_settings.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_settings.json
index 1e36acc51544d..eec2a24057095 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_settings.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_settings.json
@@ -1,7 +1,7 @@
 {
   "cluster.put_settings":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-update-settings.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cluster-api/cluster-settings/",
       "description":"Updates the cluster settings."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_weighted_routing.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_weighted_routing.json
index 88498517ba336..f22402def2fc4 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_weighted_routing.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.put_weighted_routing.json
@@ -1,7 +1,7 @@
 {
   "cluster.put_weighted_routing": {
     "documentation": {
-      "url": "https://opensearch.org/docs/latest/opensearch/rest-api/weighted-routing/put",
+      "url": "https://opensearch.org/docs/latest/api-reference/cluster-api/cluster-awareness",
       "description": "Updates weighted shard routing weights"
     },
     "stability": "stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.remote_info.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.remote_info.json
index 4eac0b55ce6f1..32315ec39f1e4 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.remote_info.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.remote_info.json
@@ -1,7 +1,7 @@
 {
   "cluster.remote_info":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-remote-info.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/remote-info/",
       "description":"Returns the information about configured remote clusters."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.state.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.state.json
index b43ab901785bd..b4c7240548a79 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.state.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.state.json
@@ -1,7 +1,7 @@
 {
   "cluster.state":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-state.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/count/",
       "description":"Returns a comprehensive information about the state of the cluster."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.stats.json b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.stats.json
index f36db0979f4f7..aaaab17fb891a 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.stats.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/cluster.stats.json
@@ -1,7 +1,7 @@
 {
   "cluster.stats":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-stats.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/cluster-api/cluster-stats/",
       "description":"Returns high-level overview of cluster statistics."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/count.json b/rest-api-spec/src/main/resources/rest-api-spec/api/count.json
index 8cdb3db7c12cd..38eb435e29a9e 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/count.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/count.json
@@ -1,7 +1,7 @@
 {
   "count":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/search-count.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/count/",
       "description":"Returns number of documents matching a query."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/create.json b/rest-api-spec/src/main/resources/rest-api-spec/api/create.json
index 767af84b82258..b3e678ace4751 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/create.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/create.json
@@ -1,7 +1,7 @@
 {
   "create":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-index_.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/document-apis/index-document/",
       "description":"Creates a new document in the index.\n\nReturns a 409 response when a document with a same ID already exists in the index."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/create_pit.json b/rest-api-spec/src/main/resources/rest-api-spec/api/create_pit.json
index d3a2104c01bc0..81fb3f7c3b973 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/create_pit.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/create_pit.json
@@ -2,7 +2,7 @@
 {
   "create_pit":{
     "documentation":{
-      "url":"https://opensearch.org/docs/latest/opensearch/rest-api/point_in_time/",
+      "url":"https://opensearch.org/docs/latest/search-plugins/searching-data/point-in-time-api",
       "description":"Creates point in time context."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/dangling_indices.delete_dangling_index.json b/rest-api-spec/src/main/resources/rest-api-spec/api/dangling_indices.delete_dangling_index.json
index 5d832fc794f4f..d0c4aaefbcadf 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/dangling_indices.delete_dangling_index.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/dangling_indices.delete_dangling_index.json
@@ -1,7 +1,7 @@
 {
   "dangling_indices.delete_dangling_index": {
     "documentation": {
-      "url": "https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-gateway-dangling-indices.html",
+      "url": "https://opensearch.org/docs/latest/api-reference/index-apis/dangling-index/",
       "description": "Deletes the specified dangling index"
     },
     "stability": "stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/dangling_indices.import_dangling_index.json b/rest-api-spec/src/main/resources/rest-api-spec/api/dangling_indices.import_dangling_index.json
index 5b056e1fa145f..f6cedbe41ef53 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/dangling_indices.import_dangling_index.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/dangling_indices.import_dangling_index.json
@@ -1,7 +1,7 @@
 {
   "dangling_indices.import_dangling_index": {
     "documentation": {
-      "url": "https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-gateway-dangling-indices.html",
+      "url": "https://opensearch.org/docs/latest/api-reference/index-apis/dangling-index/",
       "description": "Imports the specified dangling index"
     },
     "stability": "stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/dangling_indices.list_dangling_indices.json b/rest-api-spec/src/main/resources/rest-api-spec/api/dangling_indices.list_dangling_indices.json
index dfc21f56ddfac..0d14c8380c7fe 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/dangling_indices.list_dangling_indices.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/dangling_indices.list_dangling_indices.json
@@ -1,7 +1,7 @@
 {
   "dangling_indices.list_dangling_indices": {
     "documentation": {
-      "url": "https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-gateway-dangling-indices.html",
+      "url": "https://opensearch.org/docs/latest/api-reference/index-apis/dangling-index/",
       "description": "Returns all dangling indices."
     },
     "stability": "stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/delete.json b/rest-api-spec/src/main/resources/rest-api-spec/api/delete.json
index 76dceb455627f..668976d360999 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/delete.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/delete.json
@@ -1,7 +1,7 @@
 {
   "delete":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-delete.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/document-apis/delete-document/",
       "description":"Removes a document from the index."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/delete_all_pits.json b/rest-api-spec/src/main/resources/rest-api-spec/api/delete_all_pits.json
index 5ff01aa746df9..1e329e3c27b5b 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/delete_all_pits.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/delete_all_pits.json
@@ -1,7 +1,7 @@
 {
   "delete_all_pits":{
     "documentation":{
-      "url":"https://opensearch.org/docs/latest/opensearch/rest-api/point_in_time/",
+      "url":"https://opensearch.org/docs/latest/search-plugins/searching-data/point-in-time-api",
       "description":"Deletes all active point in time searches."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/delete_by_query.json b/rest-api-spec/src/main/resources/rest-api-spec/api/delete_by_query.json
index 4c32974583aac..0c493a092e244 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/delete_by_query.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/delete_by_query.json
@@ -1,7 +1,7 @@
 {
   "delete_by_query":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-delete-by-query.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/document-apis/delete-by-query/",
       "description":"Deletes documents matching the provided query."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/delete_by_query_rethrottle.json b/rest-api-spec/src/main/resources/rest-api-spec/api/delete_by_query_rethrottle.json
index 112bfc8a7d2e0..c9660fe2e4427 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/delete_by_query_rethrottle.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/delete_by_query_rethrottle.json
@@ -1,7 +1,7 @@
 {
   "delete_by_query_rethrottle":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-delete-by-query.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/document-apis/delete-by-query/",
       "description":"Changes the number of requests per second for a particular Delete By Query operation."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/delete_pit.json b/rest-api-spec/src/main/resources/rest-api-spec/api/delete_pit.json
index b54d9f76204f4..234001349d889 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/delete_pit.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/delete_pit.json
@@ -1,7 +1,7 @@
 {
   "delete_pit":{
     "documentation":{
-      "url":"https://opensearch.org/docs/latest/opensearch/rest-api/point_in_time/",
+      "url":"https://opensearch.org/docs/latest/search-plugins/searching-data/point-in-time-api",
       "description":"Deletes one or more point in time searches based on the IDs passed."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/delete_script.json b/rest-api-spec/src/main/resources/rest-api-spec/api/delete_script.json
index acaa389738606..b858f71eb2812 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/delete_script.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/delete_script.json
@@ -1,7 +1,7 @@
 {
   "delete_script":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-scripting.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/script-apis/delete-script/",
       "description":"Deletes a script."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/exists.json b/rest-api-spec/src/main/resources/rest-api-spec/api/exists.json
index fd221b474a070..0b4f588a673ac 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/exists.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/exists.json
@@ -1,7 +1,7 @@
 {
   "exists":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-get.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/document-apis/get-documents/",
       "description":"Returns information about whether a document exists in an index."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/exists_source.json b/rest-api-spec/src/main/resources/rest-api-spec/api/exists_source.json
index bdbf818fb5d81..5c44f57c289b5 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/exists_source.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/exists_source.json
@@ -1,7 +1,7 @@
 {
   "exists_source":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-get.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/document-apis/get-documents/",
       "description":"Returns information about whether a document source exists in an index."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/explain.json b/rest-api-spec/src/main/resources/rest-api-spec/api/explain.json
index 7f630f7666f30..4ad263262fe14 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/explain.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/explain.json
@@ -1,7 +1,7 @@
 {
   "explain":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/search-explain.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/explain/",
       "description":"Returns information about why a specific matches (or doesn't match) a query."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/get.json b/rest-api-spec/src/main/resources/rest-api-spec/api/get.json
index 2ce77f17aff10..990ec4685fa54 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/get.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/get.json
@@ -1,7 +1,7 @@
 {
   "get":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-get.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/document-apis/get-documents/",
       "description":"Returns a document."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/get_all_pits.json b/rest-api-spec/src/main/resources/rest-api-spec/api/get_all_pits.json
index 544a8cb11b002..9176d499e754b 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/get_all_pits.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/get_all_pits.json
@@ -1,7 +1,7 @@
 {
   "get_all_pits":{
     "documentation":{
-      "url":"https://opensearch.org/docs/latest/opensearch/rest-api/point_in_time/",
+      "url":"https://opensearch.org/docs/latest/search-plugins/searching-data/point-in-time-api",
       "description":"Lists all active point in time searches."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/get_script_context.json b/rest-api-spec/src/main/resources/rest-api-spec/api/get_script_context.json
index aa770ee9d9f2e..c5034e48e6e65 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/get_script_context.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/get_script_context.json
@@ -1,7 +1,7 @@
 {
   "get_script_context":{
     "documentation":{
-      "url": "https://www.elastic.co/guide/en/elasticsearch/painless/master/painless-contexts.html",
+      "url": "https://opensearch.org/docs/latest/api-reference/script-apis/get-script-language/",
       "description":"Returns all script contexts."
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/get_script_languages.json b/rest-api-spec/src/main/resources/rest-api-spec/api/get_script_languages.json
index a5e06cb88901b..006f34a9762b0 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/get_script_languages.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/get_script_languages.json
@@ -1,7 +1,7 @@
 {
   "get_script_languages":{
     "documentation":{
-      "url": "https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-scripting.html",
+      "url": "https://opensearch.org/docs/latest/api-reference/script-apis/get-script-language/",
       "description":"Returns available script types, languages and contexts"
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/get_source.json b/rest-api-spec/src/main/resources/rest-api-spec/api/get_source.json
index ad79678388590..ab269fcc0980f 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/get_source.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/get_source.json
@@ -1,7 +1,7 @@
 {
   "get_source":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-get.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/document-apis/get-documents/",
       "description":"Returns the source of a document."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/index.json b/rest-api-spec/src/main/resources/rest-api-spec/api/index.json
index b4865403331b0..a02e5bbd2c6e8 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/index.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/index.json
@@ -1,7 +1,7 @@
 {
   "index":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-index_.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/document-apis/index-document/",
       "description":"Creates or updates a document in an index."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.analyze.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.analyze.json
index aa8e84c1985d6..ddf6b93bba0c5 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.analyze.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.analyze.json
@@ -1,7 +1,7 @@
 {
   "indices.analyze":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-analyze.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/analyze-apis/",
       "description":"Performs the analysis process on a text and return the tokens breakdown of the text."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.clear_cache.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.clear_cache.json
index 0c7eca8c8e6f5..09ff5af473335 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.clear_cache.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.clear_cache.json
@@ -1,7 +1,7 @@
 {
   "indices.clear_cache":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-clearcache.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/clear-index-cache/",
       "description":"Clears all or specific caches for one or more indices."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.clone.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.clone.json
index 2d874f4933768..0872e1b0d6266 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.clone.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.clone.json
@@ -1,7 +1,7 @@
 {
   "indices.clone": {
     "documentation": {
-      "url": "https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-clone-index.html",
+      "url": "https://opensearch.org/docs/latest/api-reference/index-apis/clone/",
       "description": "Clones an index"
     },
     "stability": "stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.close.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.close.json
index 1182b73541f93..863080befd3d6 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.close.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.close.json
@@ -1,7 +1,7 @@
 {
   "indices.close":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-open-close.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/close-index/",
       "description":"Closes an index."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.create.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.create.json
index 53ea4cbd80803..c35876c9e6f15 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.create.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.create.json
@@ -1,7 +1,7 @@
 {
   "indices.create":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-create-index.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/create-index/",
       "description":"Creates an index with optional settings and mappings."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.data_streams_stats.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.data_streams_stats.json
index 67f90c48eb79f..4dea89d4189b1 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.data_streams_stats.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.data_streams_stats.json
@@ -1,7 +1,7 @@
 {
   "indices.data_streams_stats":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/data-streams.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/data-streams/",
       "description":"Provides statistics on operations happening in a data stream."
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.delete.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.delete.json
index 53fdf44bb36a1..ea8a3f6b769e9 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.delete.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.delete.json
@@ -1,7 +1,7 @@
 {
   "indices.delete":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-delete-index.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/delete-index/",
       "description":"Deletes an index."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.delete_data_stream.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.delete_data_stream.json
index f824fb5207d46..e695fb4cfcf60 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.delete_data_stream.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.delete_data_stream.json
@@ -1,7 +1,7 @@
 {
   "indices.delete_data_stream":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/data-streams.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/data-streams/",
       "description":"Deletes a data stream."
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.delete_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.delete_template.json
index 74dbb1822b64a..252ab47a8df6f 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.delete_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.delete_template.json
@@ -1,7 +1,7 @@
 {
   "indices.delete_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-templates.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/index-templates",
       "description":"Deletes an index template."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists.json
index 7539f44a81eed..7be004cd9c4ea 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists.json
@@ -1,7 +1,7 @@
 {
   "indices.exists":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-exists.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/exists/",
       "description":"Returns information about whether a particular index exists."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists_alias.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists_alias.json
index 66e5ce92cbbe5..88d1c00076757 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists_alias.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists_alias.json
@@ -1,7 +1,7 @@
 {
   "indices.exists_alias":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-aliases.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/alias/",
       "description":"Returns information about whether a particular alias exists."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists_index_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists_index_template.json
index c5312680fa880..8b050881240da 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists_index_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists_index_template.json
@@ -1,7 +1,7 @@
 {
   "indices.exists_index_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-templates.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/index-templates",
       "description":"Returns information about whether a particular index template exists."
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists_template.json
index 9796bdd9d21ff..08ab5cf81e57d 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.exists_template.json
@@ -1,7 +1,7 @@
 {
   "indices.exists_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-templates.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/index-templates",
       "description":"Returns information about whether a particular index template exists."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.forcemerge.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.forcemerge.json
index 986bce55f41e5..a1e066c558cb2 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.forcemerge.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.forcemerge.json
@@ -1,7 +1,7 @@
 {
   "indices.forcemerge":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-forcemerge.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/force-merge/",
       "description":"Performs the force merge operation on one or more indices."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get.json
index 0a43f6481d86d..ca701cc81b0c7 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get.json
@@ -1,7 +1,7 @@
 {
   "indices.get":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-get-index.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/get-index/",
       "description":"Returns information about one or more indices."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_data_stream.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_data_stream.json
index ce19186bea6a9..99f419e593a6f 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_data_stream.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_data_stream.json
@@ -1,7 +1,7 @@
 {
   "indices.get_data_stream":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/data-streams.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/data-streams/",
       "description":"Returns data streams."
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_field_mapping.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_field_mapping.json
index 0e71b6d395777..ef627502f5250 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_field_mapping.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_field_mapping.json
@@ -1,7 +1,7 @@
 {
   "indices.get_field_mapping":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-get-field-mapping.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/put-mapping/",
       "description":"Returns mapping for one or more fields."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_index_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_index_template.json
index fbd03f99d2547..3d10894a787f9 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_index_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_index_template.json
@@ -1,7 +1,7 @@
 {
   "indices.get_index_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-templates.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/index-templates",
       "description":"Returns an index template."
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_mapping.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_mapping.json
index 321bfaba4f941..5f401872c98c4 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_mapping.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_mapping.json
@@ -1,7 +1,7 @@
 {
   "indices.get_mapping":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-get-mapping.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/put-mapping/",
       "description":"Returns mappings for one or more indices."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_settings.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_settings.json
index 1bdaea01f87bf..b3db1ca1cbf90 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_settings.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_settings.json
@@ -1,7 +1,7 @@
 {
   "indices.get_settings":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-get-settings.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/get-settings/",
       "description":"Returns settings for one or more indices."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_template.json
index 52aeb17913db4..7df19812f9d6b 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.get_template.json
@@ -1,7 +1,7 @@
 {
   "indices.get_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-templates.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/index-templates",
       "description":"Returns an index template."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.open.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.open.json
index f44fb04102a7f..e7fe207a254f6 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.open.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.open.json
@@ -1,7 +1,7 @@
 {
   "indices.open":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-open-close.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/open-index/",
       "description":"Opens an index."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_alias.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_alias.json
index 00767afbaec04..c3ccd25da9f86 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_alias.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_alias.json
@@ -1,7 +1,7 @@
 {
   "indices.put_alias":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-aliases.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/alias/",
       "description":"Creates or updates an alias."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_index_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_index_template.json
index a2ceb259a4376..439f96943db04 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_index_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_index_template.json
@@ -1,7 +1,7 @@
 {
   "indices.put_index_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-templates.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/index-templates",
       "description":"Creates or updates an index template."
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_mapping.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_mapping.json
index c8b63d4e1cee1..2db333dc1e8ef 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_mapping.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_mapping.json
@@ -1,7 +1,7 @@
 {
   "indices.put_mapping":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-put-mapping.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/put-mapping/",
       "description":"Updates the index mappings."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_template.json
index 3b1c230178bb8..bdedd5519076d 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_template.json
@@ -1,7 +1,7 @@
 {
   "indices.put_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-templates.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/index-templates",
       "description":"Creates or updates an index template."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.shrink.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.shrink.json
index a20014a1444ec..941ea1127954d 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.shrink.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.shrink.json
@@ -1,7 +1,7 @@
 {
   "indices.shrink":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-shrink-index.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/shrink-index/",
       "description":"Allow to shrink an existing index into a new index with fewer primary shards."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.simulate_index_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.simulate_index_template.json
index 0e42ba6028a9f..1ddb4e54d8bbd 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.simulate_index_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.simulate_index_template.json
@@ -1,7 +1,7 @@
 {
   "indices.simulate_index_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-templates.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/index-templates",
       "description": "Simulate matching the given index name against the index templates in the system"
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.simulate_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.simulate_template.json
index 65b555082c3b1..04a33fe62e1ec 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.simulate_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.simulate_template.json
@@ -1,7 +1,7 @@
 {
   "indices.simulate_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-templates.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/index-templates",
       "description": "Simulate resolving the given template name or body"
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.split.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.split.json
index d399bf9dbdb8a..af041f426b644 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.split.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.split.json
@@ -1,7 +1,7 @@
 {
   "indices.split":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-split-index.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/split/",
       "description":"Allows you to split an existing index into a new index with more primary shards."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.stats.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.stats.json
index 382bb9efde0ff..71ce6dbd443f0 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.stats.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.stats.json
@@ -1,7 +1,7 @@
 {
   "indices.stats":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-stats.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/stats/",
       "description":"Provides statistics on operations happening in an index."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.update_aliases.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.update_aliases.json
index c31cb8fe59c0f..467cc444b6e53 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.update_aliases.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.update_aliases.json
@@ -1,7 +1,7 @@
 {
   "indices.update_aliases":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-aliases.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/alias/",
       "description":"Updates index aliases."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.delete_pipeline.json b/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.delete_pipeline.json
index 3e40136f556fa..2e615ece82c64 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.delete_pipeline.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.delete_pipeline.json
@@ -1,7 +1,7 @@
 {
   "ingest.delete_pipeline":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/delete-pipeline-api.html",
+      "url":"https://opensearch.org/docs/latest/ingest-pipelines/delete-ingest/",
       "description":"Deletes a pipeline."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.get_pipeline.json b/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.get_pipeline.json
index cde980e67c8c9..498aac4ca5a4a 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.get_pipeline.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.get_pipeline.json
@@ -1,7 +1,7 @@
 {
   "ingest.get_pipeline":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/get-pipeline-api.html",
+      "url":"https://opensearch.org/docs/latest/ingest-pipelines/get-ingest/",
       "description":"Returns a pipeline."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.put_pipeline.json b/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.put_pipeline.json
index 5475905e7b99f..0043a32a55310 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.put_pipeline.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.put_pipeline.json
@@ -1,7 +1,7 @@
 {
   "ingest.put_pipeline":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/put-pipeline-api.html",
+      "url":"https://opensearch.org/docs/latest/ingest-pipelines/create-ingest/",
       "description":"Creates or updates a pipeline."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.simulate.json b/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.simulate.json
index 8122f7a0ffa19..6f6b153195255 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.simulate.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/ingest.simulate.json
@@ -1,7 +1,7 @@
 {
   "ingest.simulate":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/simulate-pipeline-api.html",
+      "url":"https://opensearch.org/docs/latest/ingest-pipelines/simulate-ingest/",
       "description":"Allows to simulate a pipeline with example documents."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/msearch.json b/rest-api-spec/src/main/resources/rest-api-spec/api/msearch.json
index 3a3a6ebe1bff5..e4b1c2a798a41 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/msearch.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/msearch.json
@@ -1,7 +1,7 @@
 {
   "msearch":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/search-multi-search.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/multi-search/",
       "description":"Allows to execute several search operations in one request."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/msearch_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/msearch_template.json
index 7ac194f91bf56..42aa8a23b1510 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/msearch_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/msearch_template.json
@@ -1,7 +1,7 @@
 {
   "msearch_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/current/search-multi-search.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/search-template/",
       "description":"Allows to execute several search template operations in one request."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.hot_threads.json b/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.hot_threads.json
index 0830344dc4ad4..bbbe79b2693c2 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.hot_threads.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.hot_threads.json
@@ -1,7 +1,7 @@
 {
   "nodes.hot_threads":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-nodes-hot-threads.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/nodes-apis/nodes-hot-threads/",
       "description":"Returns information about hot threads on each node in the cluster."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.info.json b/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.info.json
index 37279edd3106f..4dce8ec54635a 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.info.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.info.json
@@ -1,7 +1,7 @@
 {
   "nodes.info":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-nodes-info.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/nodes-apis/nodes-info/",
       "description":"Returns information about nodes in the cluster."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.reload_secure_settings.json b/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.reload_secure_settings.json
index 25dc72b6cc037..6ecbf96c1925b 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.reload_secure_settings.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.reload_secure_settings.json
@@ -1,7 +1,7 @@
 {
   "nodes.reload_secure_settings":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/secure-settings.html#reloadable-secure-settings",
+      "url":"https://opensearch.org/docs/latest/api-reference/nodes-apis/nodes-reload-secure/",
       "description":"Reloads secure settings."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.stats.json b/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.stats.json
index cc1a9e8185093..a23b2e5428fb6 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.stats.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.stats.json
@@ -1,7 +1,7 @@
 {
   "nodes.stats":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-nodes-stats.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/nodes-apis/nodes-stats/",
       "description":"Returns statistical information about nodes in the cluster."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.usage.json b/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.usage.json
index 5acbf7a51116c..e23011ce432a8 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.usage.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/nodes.usage.json
@@ -1,7 +1,7 @@
 {
   "nodes.usage":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-nodes-usage.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/nodes-apis/nodes-usage/",
       "description":"Returns low-level information about REST actions usage on nodes."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/put_script.json b/rest-api-spec/src/main/resources/rest-api-spec/api/put_script.json
index c8413d1476402..1c13ea41e3470 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/put_script.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/put_script.json
@@ -1,7 +1,7 @@
 {
   "put_script":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-scripting.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/nodes-apis/nodes-usage/",
       "description":"Creates or updates a script."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/rank_eval.json b/rest-api-spec/src/main/resources/rest-api-spec/api/rank_eval.json
index eadf240192394..04d337a45ec3e 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/rank_eval.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/rank_eval.json
@@ -1,7 +1,7 @@
 {
   "rank_eval":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/search-rank-eval.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/rank-eval/",
       "description":"Allows to evaluate the quality of ranked search results over a set of typical search queries"
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/reindex.json b/rest-api-spec/src/main/resources/rest-api-spec/api/reindex.json
index 2fbaf86cab616..e2cb76d9ab8ca 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/reindex.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/reindex.json
@@ -1,7 +1,7 @@
 {
   "reindex":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-reindex.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/reindex-data/",
       "description":"Allows to copy documents from one index to another, optionally filtering the source\ndocuments by a query, changing the destination index settings, or fetching the\ndocuments from a remote cluster."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/reindex_rethrottle.json b/rest-api-spec/src/main/resources/rest-api-spec/api/reindex_rethrottle.json
index d91365b3c49a5..eafd1122f21c2 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/reindex_rethrottle.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/reindex_rethrottle.json
@@ -1,7 +1,7 @@
 {
   "reindex_rethrottle":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-reindex.html",
+      "url":"https://opensearch.org/docs/latest/im-plugin/reindex-data/",
       "description":"Changes the number of requests per second for a particular Reindex operation."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/remote_store.restore.json b/rest-api-spec/src/main/resources/rest-api-spec/api/remote_store.restore.json
index 6af49f75b9f6e..4d8efb9411bff 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/remote_store.restore.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/remote_store.restore.json
@@ -1,7 +1,7 @@
 {
   "remote_store.restore":{
     "documentation":{
-      "url": "https://opensearch.org/docs/latest/opensearch/rest-api/remote-store#restore",
+      "url": "https://opensearch.org/docs/latest/tuning-your-cluster/availability-and-recovery/remote-store/index/#restoring-from-a-backup",
       "description":"Restores from remote store."
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/remote_store.stats.json b/rest-api-spec/src/main/resources/rest-api-spec/api/remote_store.stats.json
index 437a4439bbcb5..5b456ca35d77a 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/remote_store.stats.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/remote_store.stats.json
@@ -1,7 +1,7 @@
 {
   "remote_store.stats":{
     "documentation":{
-      "url": "https://opensearch.org/docs/latest/tuning-your-cluster/availability-and-recovery/remote",
+      "url": "https://opensearch.org/docs/latest/tuning-your-cluster/availability-and-recovery/remote-store/remote-store-stats-api/",
       "description":"Stats for remote store."
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/render_search_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/render_search_template.json
index c2c474edd9853..a16839aa83a7d 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/render_search_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/render_search_template.json
@@ -1,7 +1,7 @@
 {
   "render_search_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/current/search-template.html#_validating_templates",
+      "url":"https://opensearch.org/docs/latest/api-reference/search-template/",
       "description":"Allows to use the Mustache language to pre-render a search definition."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/scripts_painless_execute.json b/rest-api-spec/src/main/resources/rest-api-spec/api/scripts_painless_execute.json
index 9f761fb452ba1..168620c0d1f3c 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/scripts_painless_execute.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/scripts_painless_execute.json
@@ -1,7 +1,7 @@
 {
   "scripts_painless_execute":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/painless/master/painless-execute-api.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/script-apis/exec-stored-script/",
       "description":"Allows an arbitrary script to be executed and a result to be returned"
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/scroll.json b/rest-api-spec/src/main/resources/rest-api-spec/api/scroll.json
index ea0cbe2675325..3a4987ff2f6f4 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/scroll.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/scroll.json
@@ -1,7 +1,7 @@
 {
   "scroll":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/search-request-body.html#request-body-search-scroll",
+      "url":"https://opensearch.org/docs/latest/api-reference/scroll/",
       "description":"Allows to retrieve a large numbers of results from a single search request."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/search.json b/rest-api-spec/src/main/resources/rest-api-spec/api/search.json
index e78d49a67a98a..01120eb07250d 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/search.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/search.json
@@ -1,7 +1,7 @@
 {
   "search":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/search-search.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/search/",
       "description":"Returns results matching a query."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/search_pipeline.delete.json b/rest-api-spec/src/main/resources/rest-api-spec/api/search_pipeline.delete.json
index 1fa7060b974dc..260bf482822cc 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/search_pipeline.delete.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/search_pipeline.delete.json
@@ -2,7 +2,7 @@
   "search_pipeline.delete": {
     "documentation": {
       "description": "Deletes a search pipeline.",
-      "url": "https://opensearch.org/docs/latest/opensearch/rest-api/search_pipelines/"
+      "url": "https://opensearch.org/docs/latest/search-plugins/search-pipelines/index/"
     },
     "stability": "stable",
     "url": {
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/search_pipeline.get.json b/rest-api-spec/src/main/resources/rest-api-spec/api/search_pipeline.get.json
index 7cac6e7aa4bcf..05aec5d5de860 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/search_pipeline.get.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/search_pipeline.get.json
@@ -2,7 +2,7 @@
   "search_pipeline.get": {
     "documentation": {
       "description": "Returns a search pipeline",
-      "url": "https://opensearch.org/docs/latest/opensearch/rest-api/search_pipelines/"
+      "url": "https://opensearch.org/docs/latest/search-plugins/search-pipelines/retrieving-search-pipeline/"
     },
     "stability": "stable",
     "url": {
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/search_pipeline.put.json b/rest-api-spec/src/main/resources/rest-api-spec/api/search_pipeline.put.json
index b7375d36825a2..90d4baea4ecf2 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/search_pipeline.put.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/search_pipeline.put.json
@@ -2,7 +2,7 @@
   "search_pipeline.put": {
     "documentation": {
       "description": "Creates or updates a search pipeline.",
-      "url": "https://opensearch.org/docs/latest/opensearch/rest-api/search_pipelines/"
+      "url": "https://opensearch.org/docs/latest/search-plugins/search-pipelines/creating-search-pipeline/"
     },
     "stability": "stable",
     "url": {
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/search_template.json b/rest-api-spec/src/main/resources/rest-api-spec/api/search_template.json
index 4230b660523b8..00fa06bb96c7e 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/search_template.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/search_template.json
@@ -1,7 +1,7 @@
 {
   "search_template":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/current/search-template.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/search-template/",
       "description":"Allows to use the Mustache language to pre-render a search definition."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.cleanup_repository.json b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.cleanup_repository.json
index 05eb3309b11e6..826660ce58dea 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.cleanup_repository.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.cleanup_repository.json
@@ -1,7 +1,7 @@
 {
   "snapshot.cleanup_repository": {
     "documentation": {
-      "url": "https://www.elastic.co/guide/en/elasticsearch/reference/master/clean-up-snapshot-repo-api.html",
+      "url": "https://opensearch.org/docs/latest/api-reference/snapshots/index/",
       "description": "Removes stale data from repository."
     },
     "stability": "stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.clone.json b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.clone.json
index c79460fc30a48..ae83d9fa6497a 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.clone.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.clone.json
@@ -1,7 +1,7 @@
 {
   "snapshot.clone":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/snapshots/index/",
       "description":"Clones indices from one snapshot into another snapshot in the same repository."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.create.json b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.create.json
index 64aaeaef9d897..9b4abd1b41a93 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.create.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.create.json
@@ -1,7 +1,7 @@
 {
   "snapshot.create":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/snapshots/create-snapshot/",
       "description":"Creates a snapshot in a repository."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.create_repository.json b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.create_repository.json
index 4965162bcd86c..02f7350495cfc 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.create_repository.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.create_repository.json
@@ -1,7 +1,7 @@
 {
   "snapshot.create_repository":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/snapshots/create-repository/",
       "description":"Creates a repository."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.delete.json b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.delete.json
index 2e21a08219942..205872dfa95ea 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.delete.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.delete.json
@@ -1,7 +1,7 @@
 {
   "snapshot.delete":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/snapshots/delete-snapshot/",
       "description":"Deletes a snapshot."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.delete_repository.json b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.delete_repository.json
index 3fc22f969784c..61a8c2b5f8086 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.delete_repository.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.delete_repository.json
@@ -1,7 +1,7 @@
 {
   "snapshot.delete_repository":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/snapshots/delete-snapshot-repository/",
       "description":"Deletes a repository."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.get.json b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.get.json
index e084a997a61b1..41b7d728da63f 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.get.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.get.json
@@ -1,7 +1,7 @@
 {
   "snapshot.get":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/snapshots/get-snapshot/",
       "description":"Returns information about a snapshot."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.get_repository.json b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.get_repository.json
index cf03bab18c03f..dc3e4a91d2a77 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.get_repository.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.get_repository.json
@@ -1,7 +1,7 @@
 {
   "snapshot.get_repository":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/snapshots/get-snapshot-repository/",
       "description":"Returns information about a repository."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.restore.json b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.restore.json
index 07148c7d261f4..401f612a33203 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.restore.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.restore.json
@@ -1,7 +1,7 @@
 {
   "snapshot.restore":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/snapshots/restore-snapshot/",
       "description":"Restores a snapshot."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.status.json b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.status.json
index 4f22c24fd9a56..1ac6042941013 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.status.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.status.json
@@ -1,7 +1,7 @@
 {
   "snapshot.status":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/snapshots/get-snapshot-status/",
       "description":"Returns information about the status of a snapshot."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.verify_repository.json b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.verify_repository.json
index 865eb15d11310..fc0fd400f8bbd 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.verify_repository.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.verify_repository.json
@@ -1,7 +1,7 @@
 {
   "snapshot.verify_repository":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/snapshots/verify-snapshot-repository/",
       "description":"Verifies a repository."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/tasks.cancel.json b/rest-api-spec/src/main/resources/rest-api-spec/api/tasks.cancel.json
index 32f90abab60f6..70dc99d7eb2da 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/tasks.cancel.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/tasks.cancel.json
@@ -1,7 +1,7 @@
 {
   "tasks.cancel":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/tasks.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/tasks/",
       "description":"Cancels a task, if it can be cancelled through an API."
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/tasks.get.json b/rest-api-spec/src/main/resources/rest-api-spec/api/tasks.get.json
index 63646ae539de5..d10fe62aa84b8 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/tasks.get.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/tasks.get.json
@@ -1,7 +1,7 @@
 {
   "tasks.get":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/tasks.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/tasks/",
       "description":"Returns information about a task."
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/tasks.list.json b/rest-api-spec/src/main/resources/rest-api-spec/api/tasks.list.json
index 7137114c96bff..20a6cb5f7f7d6 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/tasks.list.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/tasks.list.json
@@ -1,7 +1,7 @@
 {
   "tasks.list":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/tasks.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/tasks/",
       "description":"Returns a list of tasks."
     },
     "stability":"experimental",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/update.json b/rest-api-spec/src/main/resources/rest-api-spec/api/update.json
index c8d1ed435756b..131036486e024 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/update.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/update.json
@@ -1,7 +1,7 @@
 {
   "update":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-update.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/document-apis/update-document/",
       "description":"Updates a document with a script or partial document."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/update_by_query.json b/rest-api-spec/src/main/resources/rest-api-spec/api/update_by_query.json
index 71a0c1fc8ad95..7f6cb797da861 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/update_by_query.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/update_by_query.json
@@ -1,7 +1,7 @@
 {
   "update_by_query":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-update-by-query.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/document-apis/update-by-query/",
       "description":"Performs an update on every document in the index without changing the source,\nfor example to pick up a mapping change."
     },
     "stability":"stable",
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/update_by_query_rethrottle.json b/rest-api-spec/src/main/resources/rest-api-spec/api/update_by_query_rethrottle.json
index bd70f6e1231c9..bc266ed7df68f 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/update_by_query_rethrottle.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/update_by_query_rethrottle.json
@@ -1,7 +1,7 @@
 {
   "update_by_query_rethrottle":{
     "documentation":{
-      "url":"https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-update-by-query.html",
+      "url":"https://opensearch.org/docs/latest/api-reference/document-apis/update-by-query/",
       "description":"Changes the number of requests per second for a particular Update By Query operation."
     },
     "stability":"stable",
diff --git a/server/build.gradle b/server/build.gradle
index bbbe93bd6e517..cb48142a61159 100644
--- a/server/build.gradle
+++ b/server/build.gradle
@@ -36,6 +36,7 @@ plugins {
   id('opensearch.publish')
   id('opensearch.internal-cluster-test')
   id('opensearch.optional-dependencies')
+  id('me.champeau.gradle.japicmp') version '0.4.2'
 }
 
 publishing {
@@ -378,3 +379,81 @@ tasks.named("sourcesJar").configure {
     duplicatesStrategy = DuplicatesStrategy.EXCLUDE
   }
 }
+
+/** Compares the current build against a snapshot build */
+tasks.register("japicmp", me.champeau.gradle.japicmp.JapicmpTask) {
+    oldClasspath.from(files("${buildDir}/snapshot/opensearch-${version}.jar"))
+    newClasspath.from(tasks.named('jar'))
+    onlyModified = true
+    failOnModification = true
+    ignoreMissingClasses = true
+    annotationIncludes = ['@org.opensearch.common.annotation.PublicApi', '@org.opensearch.common.annotation.DeprecatedApi']
+    txtOutputFile = layout.buildDirectory.file("reports/java-compatibility/report.txt")
+    htmlOutputFile = layout.buildDirectory.file("reports/java-compatibility/report.html")
+    dependsOn downloadSnapshot
+}
+
+/** If the Java API Comparison task failed, print a hint if the change should be merged from its target branch */
+gradle.taskGraph.afterTask { Task task, TaskState state ->
+    if (task.name == 'japicmp' && state.failure != null) {
+        def sha = getGitShaFromJar("${buildDir}/snapshot/opensearch-${version}.jar")
+        logger.info("Incompatiable java api from snapshot jar built off of commit ${sha}")
+
+        if (!inHistory(sha)) {
+          logger.warn('\u001B[33mPlease merge from the target branch and run this task again.\u001B[0m')
+        }
+    }
+}
+
+/** Downloads latest snapshot from maven repository */
+tasks.register("downloadSnapshot", Copy) {
+    def mavenSnapshotRepoUrl = "https://aws.oss.sonatype.org/content/repositories/snapshots/"
+    def groupId = "org.opensearch"
+    def artifactId = "opensearch"
+
+    repositories {
+        maven {
+            url mavenSnapshotRepoUrl
+        }
+    }
+
+    configurations {
+        snapshotArtifact
+    }
+
+    dependencies {
+        snapshotArtifact("${groupId}:${artifactId}:${version}:")
+    }
+
+    from configurations.snapshotArtifact
+    into "$buildDir/snapshot"
+}
+
+/** Check if the sha is in the current history */
+def inHistory(String sha) {
+    try {
+      def commandCheckSha = "git merge-base --is-ancestor ${sha} HEAD"
+      commandCheckSha.execute()
+      return true
+    } catch (Exception) {
+      return false
+    }
+}
+
+/** Extracts the Git SHA used to build a jar from its manifest */
+def getGitShaFromJar(String jarPath) {
+    def sha = ''
+    try {
+        // Open the JAR file
+        def jarFile = new java.util.jar.JarFile(jarPath)
+        // Get the manifest from the JAR file
+        def manifest = jarFile.manifest
+        def attributes = manifest.mainAttributes
+        // Assuming the Git SHA is stored under an attribute named 'Git-SHA'
+        sha = attributes.getValue('Change')
+        jarFile.close()
+    } catch (IOException e) {
+        println "Failed to read the JAR file: $e.message"
+    }
+    return sha
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/index/shard/IndexShardIT.java b/server/src/internalClusterTest/java/org/opensearch/index/shard/IndexShardIT.java
index d218f0a985cf3..f97950f2652a3 100644
--- a/server/src/internalClusterTest/java/org/opensearch/index/shard/IndexShardIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/index/shard/IndexShardIT.java
@@ -715,7 +715,8 @@ public static final IndexShard newIndexShard(
             nodeId,
             null,
             DefaultRemoteStoreSettings.INSTANCE,
-            false
+            false,
+            IndexShardTestUtils.getFakeDiscoveryNodes(initializingShardRouting)
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationAllocationIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationAllocationIT.java
index 30edea6551067..669e24f9fb555 100644
--- a/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationAllocationIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationAllocationIT.java
@@ -31,6 +31,9 @@
 import java.util.stream.Collectors;
 
 import static org.opensearch.cluster.routing.ShardRoutingState.STARTED;
+import static org.opensearch.cluster.routing.allocation.allocator.BalancedShardsAllocator.PREFER_PRIMARY_SHARD_BALANCE;
+import static org.opensearch.cluster.routing.allocation.allocator.BalancedShardsAllocator.PREFER_PRIMARY_SHARD_REBALANCE;
+import static org.opensearch.cluster.routing.allocation.allocator.BalancedShardsAllocator.PRIMARY_SHARD_REBALANCE_BUFFER;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
@@ -58,6 +61,20 @@ public void enablePreferPrimaryBalance() {
         );
     }
 
+    public void setAllocationRelocationStrategy(boolean preferPrimaryBalance, boolean preferPrimaryRebalance, float buffer) {
+        assertAcked(
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setPersistentSettings(
+                    Settings.builder()
+                        .put(PREFER_PRIMARY_SHARD_BALANCE.getKey(), preferPrimaryBalance)
+                        .put(PREFER_PRIMARY_SHARD_REBALANCE.getKey(), preferPrimaryRebalance)
+                        .put(PRIMARY_SHARD_REBALANCE_BUFFER.getKey(), buffer)
+                )
+        );
+    }
+
     /**
      * This test verifies that the overall primary balance is attained during allocation. This test verifies primary
      * balance per index and across all indices is maintained.
@@ -87,7 +104,7 @@ public void testGlobalPrimaryAllocation() throws Exception {
         state = client().admin().cluster().prepareState().execute().actionGet().getState();
         logger.info(ShardAllocations.printShardDistribution(state));
         verifyPerIndexPrimaryBalance();
-        verifyPrimaryBalance();
+        verifyPrimaryBalance(0.0f);
     }
 
     /**
@@ -224,6 +241,70 @@ public void testAllocationWithDisruption() throws Exception {
         verifyPerIndexPrimaryBalance();
     }
 
+    /**
+     * Similar to testSingleIndexShardAllocation test but creates multiple indices, multiple nodes adding in and getting
+     * removed. The test asserts post each such event that primary shard distribution is balanced for each index as well as across the nodes
+     * when the PREFER_PRIMARY_SHARD_REBALANCE is set to true
+     */
+    public void testAllocationAndRebalanceWithDisruption() throws Exception {
+        internalCluster().startClusterManagerOnlyNode();
+        final int maxReplicaCount = 2;
+        final int maxShardCount = 2;
+        // Create higher number of nodes than number of shards to reduce chances of SameShardAllocationDecider kicking-in
+        // and preventing primary relocations
+        final int nodeCount = randomIntBetween(5, 10);
+        final int numberOfIndices = randomIntBetween(1, 10);
+        final float buffer = randomIntBetween(1, 4) * 0.10f;
+
+        logger.info("--> Creating {} nodes", nodeCount);
+        final List<String> nodeNames = new ArrayList<>();
+        for (int i = 0; i < nodeCount; i++) {
+            nodeNames.add(internalCluster().startNode());
+        }
+        setAllocationRelocationStrategy(true, true, buffer);
+
+        int shardCount, replicaCount;
+        ClusterState state;
+        for (int i = 0; i < numberOfIndices; i++) {
+            shardCount = randomIntBetween(1, maxShardCount);
+            replicaCount = randomIntBetween(1, maxReplicaCount);
+            logger.info("--> Creating index test{} with primary {} and replica {}", i, shardCount, replicaCount);
+            createIndex("test" + i, shardCount, replicaCount, i % 2 == 0);
+            ensureGreen(TimeValue.timeValueSeconds(60));
+            if (logger.isTraceEnabled()) {
+                state = client().admin().cluster().prepareState().execute().actionGet().getState();
+                logger.info(ShardAllocations.printShardDistribution(state));
+            }
+        }
+        state = client().admin().cluster().prepareState().execute().actionGet().getState();
+        logger.info(ShardAllocations.printShardDistribution(state));
+        verifyPerIndexPrimaryBalance();
+        verifyPrimaryBalance(buffer);
+
+        final int additionalNodeCount = randomIntBetween(1, 5);
+        logger.info("--> Adding {} nodes", additionalNodeCount);
+
+        internalCluster().startNodes(additionalNodeCount);
+        ensureGreen(TimeValue.timeValueSeconds(60));
+        state = client().admin().cluster().prepareState().execute().actionGet().getState();
+        logger.info(ShardAllocations.printShardDistribution(state));
+        verifyPerIndexPrimaryBalance();
+        verifyPrimaryBalance(buffer);
+
+        int nodeCountToStop = additionalNodeCount;
+        while (nodeCountToStop > 0) {
+            internalCluster().stopRandomDataNode();
+            // give replica a chance to promote as primary before terminating node containing the replica
+            ensureGreen(TimeValue.timeValueSeconds(60));
+            nodeCountToStop--;
+        }
+        state = client().admin().cluster().prepareState().execute().actionGet().getState();
+        logger.info("--> Cluster state post nodes stop {}", state);
+        logger.info(ShardAllocations.printShardDistribution(state));
+        verifyPerIndexPrimaryBalance();
+        verifyPrimaryBalance(buffer);
+    }
+
     /**
      * Utility method which ensures cluster has balanced primary shard distribution across a single index.
      * @throws Exception exception
@@ -263,7 +344,7 @@ private void verifyPerIndexPrimaryBalance() throws Exception {
         }, 60, TimeUnit.SECONDS);
     }
 
-    private void verifyPrimaryBalance() throws Exception {
+    private void verifyPrimaryBalance(float buffer) throws Exception {
         assertBusy(() -> {
             final ClusterState currentState = client().admin().cluster().prepareState().execute().actionGet().getState();
             RoutingNodes nodes = currentState.getRoutingNodes();
@@ -278,7 +359,7 @@ private void verifyPrimaryBalance() throws Exception {
                     .filter(ShardRouting::primary)
                     .collect(Collectors.toList())
                     .size();
-                assertTrue(primaryCount <= avgPrimaryShardsPerNode);
+                assertTrue(primaryCount <= (avgPrimaryShardsPerNode * (1 + buffer)));
             }
         }, 60, TimeUnit.SECONDS);
     }
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/MigrationBaseTestCase.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/MigrationBaseTestCase.java
index 19da668c432cf..0c35f91121059 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotemigration/MigrationBaseTestCase.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/MigrationBaseTestCase.java
@@ -8,17 +8,29 @@
 
 package org.opensearch.remotemigration;
 
+import org.opensearch.action.DocWriteResponse;
 import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesRequest;
 import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesResponse;
+import org.opensearch.action.bulk.BulkRequest;
+import org.opensearch.action.bulk.BulkResponse;
+import org.opensearch.action.delete.DeleteResponse;
+import org.opensearch.action.index.IndexRequest;
+import org.opensearch.action.index.IndexResponse;
 import org.opensearch.cluster.metadata.RepositoryMetadata;
+import org.opensearch.common.UUIDs;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.repositories.fs.ReloadableFsRepository;
 import org.opensearch.test.OpenSearchIntegTestCase;
 
 import java.nio.file.Path;
+import java.util.List;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
 
+import static org.opensearch.node.remotestore.RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING;
+import static org.opensearch.node.remotestore.RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING;
 import static org.opensearch.repositories.fs.ReloadableFsRepository.REPOSITORIES_FAILRATE_SETTING;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 
@@ -28,8 +40,16 @@ public class MigrationBaseTestCase extends OpenSearchIntegTestCase {
 
     protected Path segmentRepoPath;
     protected Path translogRepoPath;
-
     boolean addRemote = false;
+    Settings extraSettings = Settings.EMPTY;
+
+    private final List<String> documentKeys = List.of(
+        randomAlphaOfLength(5),
+        randomAlphaOfLength(5),
+        randomAlphaOfLength(5),
+        randomAlphaOfLength(5),
+        randomAlphaOfLength(5)
+    );
 
     protected Settings nodeSettings(int nodeOrdinal) {
         if (segmentRepoPath == null || translogRepoPath == null) {
@@ -40,6 +60,7 @@ protected Settings nodeSettings(int nodeOrdinal) {
             logger.info("Adding remote store node");
             return Settings.builder()
                 .put(super.nodeSettings(nodeOrdinal))
+                .put(extraSettings)
                 .put(remoteStoreClusterSettings(REPOSITORY_NAME, segmentRepoPath, REPOSITORY_2_NAME, translogRepoPath))
                 .build();
         } else {
@@ -64,4 +85,76 @@ protected void setFailRate(String repoName, int value) throws ExecutionException
             client().admin().cluster().preparePutRepository(repoName).setType(ReloadableFsRepository.TYPE).setSettings(settings).get()
         );
     }
+
+    public void initDocRepToRemoteMigration() {
+        assertTrue(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setPersistentSettings(
+                    Settings.builder()
+                        .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "mixed")
+                        .put(MIGRATION_DIRECTION_SETTING.getKey(), "remote_store")
+                )
+                .get()
+                .isAcknowledged()
+        );
+    }
+
+    public BulkResponse indexBulk(String indexName, int numDocs) {
+        BulkRequest bulkRequest = new BulkRequest();
+        for (int i = 0; i < numDocs; i++) {
+            final IndexRequest request = client().prepareIndex(indexName)
+                .setId(UUIDs.randomBase64UUID())
+                .setSource(documentKeys.get(randomIntBetween(0, documentKeys.size() - 1)), randomAlphaOfLength(5))
+                .request();
+            bulkRequest.add(request);
+        }
+        return client().bulk(bulkRequest).actionGet();
+    }
+
+    private void indexSingleDoc(String indexName) {
+        IndexResponse indexResponse = client().prepareIndex(indexName).setId("id").setSource("field", "value").get();
+        assertEquals(DocWriteResponse.Result.CREATED, indexResponse.getResult());
+        DeleteResponse deleteResponse = client().prepareDelete(indexName, "id").get();
+        assertEquals(DocWriteResponse.Result.DELETED, deleteResponse.getResult());
+        client().prepareIndex(indexName).setSource("auto", true).get();
+    }
+
+    public class AsyncIndexingService {
+        private String indexName;
+        private AtomicLong indexedDocs = new AtomicLong(0);
+        private AtomicBoolean finished = new AtomicBoolean();
+        private Thread indexingThread;
+
+        AsyncIndexingService(String indexName) {
+            this.indexName = indexName;
+        }
+
+        public void startIndexing() {
+            indexingThread = getIndexingThread();
+            indexingThread.start();
+        }
+
+        public void stopIndexing() throws InterruptedException {
+            finished.set(true);
+            indexingThread.join();
+        }
+
+        public long getIndexedDocs() {
+            return indexedDocs.get();
+        }
+
+        private Thread getIndexingThread() {
+            return new Thread(() -> {
+                while (finished.get() == false) {
+                    indexSingleDoc(indexName);
+                    long currentDocCount = indexedDocs.incrementAndGet();
+                    logger.info("Completed ingestion of {} docs", currentDocCount);
+
+                }
+            });
+        }
+    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteDualReplicationIT.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteDualReplicationIT.java
new file mode 100644
index 0000000000000..34b60d5f3e9b3
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteDualReplicationIT.java
@@ -0,0 +1,530 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.remotemigration;
+
+import org.opensearch.action.admin.indices.stats.CommonStats;
+import org.opensearch.action.admin.indices.stats.ShardStats;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.allocation.command.MoveAllocationCommand;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.index.IndexService;
+import org.opensearch.index.remote.RemoteSegmentStats;
+import org.opensearch.index.seqno.RetentionLease;
+import org.opensearch.index.seqno.RetentionLeases;
+import org.opensearch.indices.IndexingMemoryController;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.remotestore.multipart.mocks.MockFsRepositoryPlugin;
+import org.opensearch.test.InternalSettingsPlugin;
+import org.opensearch.test.InternalTestCluster;
+import org.opensearch.test.OpenSearchIntegTestCase;
+import org.opensearch.test.transport.MockTransportService;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
+public class RemoteDualReplicationIT extends MigrationBaseTestCase {
+    private final String REMOTE_PRI_DOCREP_REP = "remote-primary-docrep-replica";
+    private final String REMOTE_PRI_DOCREP_REMOTE_REP = "remote-primary-docrep-remote-replica";
+    private final String FAILOVER_REMOTE_TO_DOCREP = "failover-remote-to-docrep";
+
+    @Override
+    protected Collection<Class<? extends Plugin>> nodePlugins() {
+        /* Adding the following mock plugins:
+        - InternalSettingsPlugin : To override default intervals of retention lease and global ckp sync
+        - MockFsRepositoryPlugin and MockTransportService.TestPlugin: To ensure remote interactions are not no-op and retention leases are properly propagated
+         */
+        return Stream.concat(
+            super.nodePlugins().stream(),
+            Stream.of(InternalSettingsPlugin.class, MockFsRepositoryPlugin.class, MockTransportService.TestPlugin.class)
+        ).collect(Collectors.toList());
+    }
+
+    /*
+    Scenario:
+    - Starts 2 docrep backed node
+    - Creates index with 1 replica
+    - Index some docs
+    - Start 1 remote backed node
+    - Move primary copy from docrep to remote through _cluster/reroute
+    - Index some more docs
+    - Assert primary-replica consistency
+     */
+    public void testRemotePrimaryDocRepReplica() throws Exception {
+        internalCluster().startClusterManagerOnlyNode();
+
+        logger.info("---> Starting 2 docrep data nodes");
+        internalCluster().startDataOnlyNodes(2);
+        internalCluster().validateClusterFormed();
+        assertEquals(internalCluster().client().admin().cluster().prepareGetRepositories().get().repositories().size(), 0);
+
+        logger.info("---> Creating index with 1 replica");
+        Settings oneReplica = Settings.builder()
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 1)
+            .put(IndexService.RETENTION_LEASE_SYNC_INTERVAL_SETTING.getKey(), "1s")
+            .put(IndexService.GLOBAL_CHECKPOINT_SYNC_INTERVAL_SETTING.getKey(), "1s")
+            .build();
+        createIndex(REMOTE_PRI_DOCREP_REP, oneReplica);
+        ensureGreen(REMOTE_PRI_DOCREP_REP);
+
+        int initialBatch = randomIntBetween(1, 1000);
+        logger.info("---> Indexing {} docs", initialBatch);
+        indexBulk(REMOTE_PRI_DOCREP_REP, initialBatch);
+
+        initDocRepToRemoteMigration();
+
+        logger.info("---> Starting 1 remote enabled data node");
+        addRemote = true;
+        String remoteNodeName = internalCluster().startDataOnlyNode();
+        internalCluster().validateClusterFormed();
+        assertEquals(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareGetRepositories(REPOSITORY_NAME, REPOSITORY_2_NAME)
+                .get()
+                .repositories()
+                .size(),
+            2
+        );
+
+        String primaryShardHostingNode = primaryNodeName(REMOTE_PRI_DOCREP_REP);
+        logger.info("---> Moving primary copy from {} to remote enabled node {}", primaryShardHostingNode, remoteNodeName);
+        assertAcked(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareReroute()
+                .add(new MoveAllocationCommand(REMOTE_PRI_DOCREP_REP, 0, primaryShardHostingNode, remoteNodeName))
+                .get()
+        );
+        ensureGreen(REMOTE_PRI_DOCREP_REP);
+        ClusterState clusterState = internalCluster().client().admin().cluster().prepareState().get().getState();
+        String primaryShardHostingNodeId = clusterState.getRoutingTable()
+            .index(REMOTE_PRI_DOCREP_REP)
+            .shard(0)
+            .primaryShard()
+            .currentNodeId();
+        assertTrue(clusterState.getNodes().get(primaryShardHostingNodeId).isRemoteStoreNode());
+
+        int secondBatch = randomIntBetween(1, 10);
+        logger.info("---> Indexing another {} docs", secondBatch);
+        indexBulk(REMOTE_PRI_DOCREP_REP, secondBatch);
+        // Defensive check to ensure that doc count in replica shard catches up to the primary copy
+        refreshAndWaitForReplication(REMOTE_PRI_DOCREP_REP);
+        assertReplicaAndPrimaryConsistency(REMOTE_PRI_DOCREP_REP, initialBatch, secondBatch);
+    }
+
+    /*
+    Scenario:
+    - Starts 1 docrep backed data node
+    - Creates an index with 0 replica
+    - Starts 1 remote backed data node
+    - Index some docs
+    - Move primary copy from docrep to remote through _cluster/reroute
+    - Starts another remote backed data node
+    - Expands index to 2 replicas. One replica copy lies in remote backed node and other in docrep backed node
+    - Index some more docs
+    - Assert primary-replica consistency
+     */
+    public void testRemotePrimaryDocRepAndRemoteReplica() throws Exception {
+        internalCluster().startClusterManagerOnlyNode();
+
+        logger.info("---> Starting 1 docrep data nodes");
+        String docrepNodeName = internalCluster().startDataOnlyNode();
+        internalCluster().validateClusterFormed();
+        assertEquals(internalCluster().client().admin().cluster().prepareGetRepositories().get().repositories().size(), 0);
+
+        logger.info("---> Creating index with 0 replica");
+        Settings zeroReplicas = Settings.builder()
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+            .put(IndexService.RETENTION_LEASE_SYNC_INTERVAL_SETTING.getKey(), "1s")
+            .put(IndexService.GLOBAL_CHECKPOINT_SYNC_INTERVAL_SETTING.getKey(), "1s")
+            .build();
+        createIndex(REMOTE_PRI_DOCREP_REMOTE_REP, zeroReplicas);
+        ensureGreen(REMOTE_PRI_DOCREP_REMOTE_REP);
+        initDocRepToRemoteMigration();
+
+        logger.info("---> Starting 1 remote enabled data node");
+        addRemote = true;
+
+        String remoteNodeName = internalCluster().startDataOnlyNode();
+        internalCluster().validateClusterFormed();
+        assertEquals(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareGetRepositories(REPOSITORY_NAME, REPOSITORY_2_NAME)
+                .get()
+                .repositories()
+                .size(),
+            2
+        );
+
+        int firstBatch = randomIntBetween(1, 100);
+        logger.info("---> Indexing {} docs", firstBatch);
+        indexBulk(REMOTE_PRI_DOCREP_REMOTE_REP, firstBatch);
+
+        String primaryShardHostingNode = primaryNodeName(REMOTE_PRI_DOCREP_REMOTE_REP);
+        logger.info("---> Moving primary copy from {} to remote enabled node {}", primaryShardHostingNode, remoteNodeName);
+        assertAcked(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareReroute()
+                .add(new MoveAllocationCommand(REMOTE_PRI_DOCREP_REMOTE_REP, 0, primaryShardHostingNode, remoteNodeName))
+                .get()
+        );
+        ensureGreen(REMOTE_PRI_DOCREP_REMOTE_REP);
+        ClusterState clusterState = internalCluster().client().admin().cluster().prepareState().get().getState();
+        String primaryShardHostingNodeId = clusterState.getRoutingTable()
+            .index(REMOTE_PRI_DOCREP_REMOTE_REP)
+            .shard(0)
+            .primaryShard()
+            .currentNodeId();
+        assertTrue(clusterState.getNodes().get(primaryShardHostingNodeId).isRemoteStoreNode());
+
+        logger.info("---> Starting another remote enabled node");
+        internalCluster().startDataOnlyNode();
+        internalCluster().validateClusterFormed();
+
+        logger.info("---> Expanding index to 2 replica copies");
+        Settings twoReplicas = Settings.builder().put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 2).build();
+        assertAcked(
+            internalCluster().client()
+                .admin()
+                .indices()
+                .prepareUpdateSettings()
+                .setIndices(REMOTE_PRI_DOCREP_REMOTE_REP)
+                .setSettings(twoReplicas)
+                .get()
+        );
+        ensureGreen(REMOTE_PRI_DOCREP_REMOTE_REP);
+
+        int secondBatch = randomIntBetween(1, 10);
+        logger.info("---> Indexing another {} docs", secondBatch);
+        indexBulk(REMOTE_PRI_DOCREP_REMOTE_REP, secondBatch);
+        // Defensive check to ensure that doc count in replica shard catches up to the primary copy
+        refreshAndWaitForReplication(REMOTE_PRI_DOCREP_REMOTE_REP);
+        assertReplicaAndPrimaryConsistency(REMOTE_PRI_DOCREP_REMOTE_REP, firstBatch, secondBatch);
+    }
+
+    /*
+    Checks if retention leases are published on primary shard and it's docrep copies, but not on remote copies
+     */
+    public void testRetentionLeasePresentOnDocrepReplicaButNotRemote() throws Exception {
+        /* Reducing indices.memory.shard_inactive_time to force a flush and trigger translog sync,
+        instead of relying on Global CKP Sync action which doesn't run on remote enabled copies
+
+        Under steady state, RetentionLeases would be on (GlobalCkp + 1) on a
+        docrep enabled shard copy and (GlobalCkp) for a remote enabled shard copy.
+        This is because we block translog sync on remote enabled shard copies during the GlobalCkpSync background task.
+
+        RLs on remote enabled copies are brought up to (GlobalCkp + 1) upon a flush request issued by IndexingMemoryController
+        when the shard becomes inactive after SHARD_INACTIVE_TIME_SETTING interval.
+
+        Flush triggers a force sync of translog which bumps the RetentionLease sequence number along with it
+        */
+        extraSettings = Settings.builder().put(IndexingMemoryController.SHARD_INACTIVE_TIME_SETTING.getKey(), "3s").build();
+        testRemotePrimaryDocRepAndRemoteReplica();
+        DiscoveryNodes nodes = internalCluster().client().admin().cluster().prepareState().get().getState().getNodes();
+        assertBusy(() -> {
+            for (ShardStats shardStats : internalCluster().client()
+                .admin()
+                .indices()
+                .prepareStats(REMOTE_PRI_DOCREP_REMOTE_REP)
+                .get()
+                .getShards()) {
+                ShardRouting shardRouting = shardStats.getShardRouting();
+                DiscoveryNode discoveryNode = nodes.get(shardRouting.currentNodeId());
+                RetentionLeases retentionLeases = shardStats.getRetentionLeaseStats().retentionLeases();
+                if (shardRouting.primary()) {
+                    // Primary copy should be on remote node and should have retention leases
+                    assertTrue(discoveryNode.isRemoteStoreNode());
+                    assertCheckpointsConsistency(shardStats);
+                    assertRetentionLeaseConsistency(shardStats, retentionLeases);
+                } else {
+                    // Checkpoints and Retention Leases are not synced to remote replicas
+                    if (discoveryNode.isRemoteStoreNode()) {
+                        assertTrue(shardStats.getRetentionLeaseStats().retentionLeases().leases().isEmpty());
+                    } else {
+                        // Replica copy on docrep node should have retention leases
+                        assertCheckpointsConsistency(shardStats);
+                        assertRetentionLeaseConsistency(shardStats, retentionLeases);
+                    }
+                }
+            }
+        });
+    }
+
+    /*
+    Scenario:
+    - Starts 1 docrep backed data node
+    - Creates an index with 0 replica
+    - Starts 1 remote backed data node
+    - Move primary copy from docrep to remote through _cluster/reroute
+    - Expands index to 1 replica
+    - Stops remote enabled node
+    - Ensure doc count is same after failover
+    - Index some more docs to ensure working of failed-over primary
+     */
+    public void testFailoverRemotePrimaryToDocrepReplica() throws Exception {
+        internalCluster().startClusterManagerOnlyNode();
+
+        logger.info("---> Starting 1 docrep data nodes");
+        String docrepNodeName = internalCluster().startDataOnlyNode();
+        internalCluster().validateClusterFormed();
+        assertEquals(internalCluster().client().admin().cluster().prepareGetRepositories().get().repositories().size(), 0);
+
+        logger.info("---> Creating index with 0 replica");
+        Settings excludeRemoteNode = Settings.builder().put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0).build();
+        createIndex(FAILOVER_REMOTE_TO_DOCREP, excludeRemoteNode);
+        ensureGreen(FAILOVER_REMOTE_TO_DOCREP);
+        initDocRepToRemoteMigration();
+        logger.info("---> Starting 1 remote enabled data node");
+        addRemote = true;
+        String remoteNodeName = internalCluster().startDataOnlyNode();
+        internalCluster().validateClusterFormed();
+        assertEquals(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareGetRepositories(REPOSITORY_NAME, REPOSITORY_2_NAME)
+                .get()
+                .repositories()
+                .size(),
+            2
+        );
+
+        logger.info("---> Starting doc ingestion in parallel thread");
+        AsyncIndexingService asyncIndexingService = new AsyncIndexingService(FAILOVER_REMOTE_TO_DOCREP);
+        asyncIndexingService.startIndexing();
+
+        String primaryShardHostingNode = primaryNodeName(FAILOVER_REMOTE_TO_DOCREP);
+        logger.info("---> Moving primary copy from {} to remote enabled node {}", primaryShardHostingNode, remoteNodeName);
+        assertAcked(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareReroute()
+                .add(new MoveAllocationCommand(FAILOVER_REMOTE_TO_DOCREP, 0, primaryShardHostingNode, remoteNodeName))
+                .get()
+        );
+        ensureGreen(FAILOVER_REMOTE_TO_DOCREP);
+
+        logger.info("---> Expanding index to 1 replica copy");
+        Settings twoReplicas = Settings.builder().put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 1).build();
+        assertAcked(
+            internalCluster().client()
+                .admin()
+                .indices()
+                .prepareUpdateSettings()
+                .setIndices(FAILOVER_REMOTE_TO_DOCREP)
+                .setSettings(twoReplicas)
+                .get()
+        );
+        ensureGreen(FAILOVER_REMOTE_TO_DOCREP);
+        logger.info("---> Stopping indexing thread");
+        asyncIndexingService.stopIndexing();
+
+        refreshAndWaitForReplication(FAILOVER_REMOTE_TO_DOCREP);
+        Map<ShardRouting, ShardStats> shardStatsMap = internalCluster().client()
+            .admin()
+            .indices()
+            .prepareStats(FAILOVER_REMOTE_TO_DOCREP)
+            .setDocs(true)
+            .get()
+            .asMap();
+        DiscoveryNodes nodes = internalCluster().client().admin().cluster().prepareState().get().getState().getNodes();
+        long initialPrimaryDocCount = 0;
+        for (ShardRouting shardRouting : shardStatsMap.keySet()) {
+            if (shardRouting.primary()) {
+                assertTrue(nodes.get(shardRouting.currentNodeId()).isRemoteStoreNode());
+                initialPrimaryDocCount = shardStatsMap.get(shardRouting).getStats().getDocs().getCount();
+            }
+        }
+        int firstBatch = (int) asyncIndexingService.getIndexedDocs();
+        assertReplicaAndPrimaryConsistency(FAILOVER_REMOTE_TO_DOCREP, firstBatch, 0);
+
+        logger.info("---> Stop remote store enabled node");
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(remoteNodeName));
+        ensureStableCluster(2);
+        ensureYellow(FAILOVER_REMOTE_TO_DOCREP);
+
+        shardStatsMap = internalCluster().client().admin().indices().prepareStats(FAILOVER_REMOTE_TO_DOCREP).setDocs(true).get().asMap();
+        nodes = internalCluster().client().admin().cluster().prepareState().get().getState().getNodes();
+        long primaryDocCountAfterFailover = 0;
+        for (ShardRouting shardRouting : shardStatsMap.keySet()) {
+            if (shardRouting.primary()) {
+                assertFalse(nodes.get(shardRouting.currentNodeId()).isRemoteStoreNode());
+                primaryDocCountAfterFailover = shardStatsMap.get(shardRouting).getStats().getDocs().getCount();
+            }
+        }
+        assertEquals(initialPrimaryDocCount, primaryDocCountAfterFailover);
+
+        logger.info("---> Index some more docs to ensure that the failed over primary is ingesting new docs");
+        int secondBatch = randomIntBetween(1, 10);
+        logger.info("---> Indexing {} more docs", secondBatch);
+        indexBulk(FAILOVER_REMOTE_TO_DOCREP, secondBatch);
+        refreshAndWaitForReplication(FAILOVER_REMOTE_TO_DOCREP);
+
+        shardStatsMap = internalCluster().client().admin().indices().prepareStats(FAILOVER_REMOTE_TO_DOCREP).setDocs(true).get().asMap();
+        assertEquals(1, shardStatsMap.size());
+        shardStatsMap.forEach(
+            (shardRouting, shardStats) -> { assertEquals(firstBatch + secondBatch, shardStats.getStats().getDocs().getCount()); }
+        );
+    }
+
+    /*
+    Scenario:
+    - Starts 1 docrep backed data node
+    - Creates an index with 0 replica
+    - Starts 1 remote backed data node
+    - Move primary copy from docrep to remote through _cluster/reroute
+    - Expands index to 1 replica
+    - Stops remote enabled node
+    - Ensure doc count is same after failover
+    - Index some more docs to ensure working of failed-over primary
+    - Starts another remote node
+    - Move primary copy from docrep to remote through _cluster/reroute
+    - Ensure that remote store is seeded in the new remote node by asserting remote uploads from that node > 0
+     */
+    public void testFailoverRemotePrimaryToDocrepReplicaReseedToRemotePrimary() throws Exception {
+        testFailoverRemotePrimaryToDocrepReplica();
+
+        logger.info("---> Removing replica copy");
+        assertAcked(
+            internalCluster().client()
+                .admin()
+                .indices()
+                .prepareUpdateSettings(FAILOVER_REMOTE_TO_DOCREP)
+                .setSettings(Settings.builder().put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0))
+                .get()
+        );
+        ensureGreen(FAILOVER_REMOTE_TO_DOCREP);
+
+        logger.info("---> Starting a new remote enabled node");
+        addRemote = true;
+        String remoteNodeName = internalCluster().startDataOnlyNode();
+        internalCluster().validateClusterFormed();
+        assertEquals(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareGetRepositories(REPOSITORY_NAME, REPOSITORY_2_NAME)
+                .get()
+                .repositories()
+                .size(),
+            2
+        );
+
+        String primaryShardHostingNode = primaryNodeName(FAILOVER_REMOTE_TO_DOCREP);
+        logger.info("---> Moving primary copy from {} to remote enabled node {}", primaryShardHostingNode, remoteNodeName);
+        assertAcked(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareReroute()
+                .add(new MoveAllocationCommand(FAILOVER_REMOTE_TO_DOCREP, 0, primaryShardHostingNode, remoteNodeName))
+                .get()
+        );
+        ensureGreen(FAILOVER_REMOTE_TO_DOCREP);
+
+        Map<ShardRouting, ShardStats> shardStatsMap = internalCluster().client()
+            .admin()
+            .indices()
+            .prepareStats(FAILOVER_REMOTE_TO_DOCREP)
+            .get()
+            .asMap();
+        DiscoveryNodes discoveryNodes = internalCluster().client().admin().cluster().prepareState().get().getState().getNodes();
+        assertEquals(1, shardStatsMap.size());
+        shardStatsMap.forEach((shardRouting, shardStats) -> {
+            if (discoveryNodes.get(shardRouting.currentNodeId()).isRemoteStoreNode()) {
+                RemoteSegmentStats remoteSegmentStats = shardStats.getStats().getSegments().getRemoteSegmentStats();
+                assertTrue(remoteSegmentStats.getTotalUploadTime() > 0);
+                assertTrue(remoteSegmentStats.getUploadBytesSucceeded() > 0);
+            }
+        });
+    }
+
+    private void assertReplicaAndPrimaryConsistency(String indexName, int firstBatch, int secondBatch) throws Exception {
+        assertBusy(() -> {
+            Map<ShardRouting, ShardStats> shardStatsMap = internalCluster().client()
+                .admin()
+                .indices()
+                .prepareStats(indexName)
+                .setDocs(true)
+                .get()
+                .asMap();
+            DiscoveryNodes nodes = internalCluster().client().admin().cluster().prepareState().get().getState().getNodes();
+            for (ShardRouting shardRouting : shardStatsMap.keySet()) {
+                CommonStats shardStats = shardStatsMap.get(shardRouting).getStats();
+                if (shardRouting.primary()) {
+                    assertEquals(firstBatch + secondBatch, shardStats.getDocs().getCount());
+                    assertTrue(nodes.get(shardRouting.currentNodeId()).isRemoteStoreNode());
+                    RemoteSegmentStats remoteSegmentStats = shardStats.getSegments().getRemoteSegmentStats();
+                    assertTrue(remoteSegmentStats.getUploadBytesSucceeded() > 0);
+                    assertTrue(remoteSegmentStats.getTotalUploadTime() > 0);
+                } else {
+                    boolean remoteNode = nodes.get(shardRouting.currentNodeId()).isRemoteStoreNode();
+                    assertEquals(
+                        "Mismatched doc count. Is this on remote node ? " + remoteNode,
+                        firstBatch + secondBatch,
+                        shardStats.getDocs().getCount()
+                    );
+                    RemoteSegmentStats remoteSegmentStats = shardStats.getSegments().getRemoteSegmentStats();
+                    if (remoteNode) {
+                        assertTrue(remoteSegmentStats.getDownloadBytesStarted() > 0);
+                        assertTrue(remoteSegmentStats.getTotalDownloadTime() > 0);
+                    } else {
+                        assertEquals(0, remoteSegmentStats.getUploadBytesSucceeded());
+                        assertEquals(0, remoteSegmentStats.getTotalUploadTime());
+                    }
+                }
+            }
+        });
+    }
+
+    /**
+     * For a docrep enabled shard copy or a primary shard copy,
+     * asserts that the stored Retention Leases equals to 1 + maxSeqNo ingested on the node
+     *
+     * @param shardStats ShardStats object from NodesStats API
+     * @param retentionLeases RetentionLeases from NodesStats API
+     */
+    private static void assertRetentionLeaseConsistency(ShardStats shardStats, RetentionLeases retentionLeases) {
+        long maxSeqNo = shardStats.getSeqNoStats().getMaxSeqNo();
+        for (RetentionLease rl : retentionLeases.leases()) {
+            assertEquals(maxSeqNo + 1, rl.retainingSequenceNumber());
+        }
+    }
+
+    /**
+     * For a docrep enabled shard copy or a primary shard copy,
+     * asserts that local and global checkpoints are up-to-date with maxSeqNo of doc operations
+     *
+     * @param shardStats ShardStats object from NodesStats API
+     */
+    private static void assertCheckpointsConsistency(ShardStats shardStats) {
+        long maxSeqNo = shardStats.getSeqNoStats().getMaxSeqNo();
+        long localCkp = shardStats.getSeqNoStats().getLocalCheckpoint();
+        long globalCkp = shardStats.getSeqNoStats().getGlobalCheckpoint();
+
+        assertEquals(maxSeqNo, localCkp);
+        assertEquals(maxSeqNo, globalCkp);
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/ResizeIndexMigrationTestCase.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/ResizeIndexMigrationTestCase.java
new file mode 100644
index 0000000000000..0548ce4a7955f
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/ResizeIndexMigrationTestCase.java
@@ -0,0 +1,208 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.remotemigration;
+
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
+import org.opensearch.action.admin.indices.shrink.ResizeType;
+import org.opensearch.action.support.ActiveShardCount;
+import org.opensearch.client.Client;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.test.OpenSearchIntegTestCase;
+
+import java.util.List;
+
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REPLICATION_TYPE;
+import static org.opensearch.node.remotestore.RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING;
+import static org.opensearch.node.remotestore.RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0, autoManageMasterNodes = false)
+public class ResizeIndexMigrationTestCase extends MigrationBaseTestCase {
+    private static final String TEST_INDEX = "test_index";
+    private final static String REMOTE_STORE_DIRECTION = "remote_store";
+    private final static String DOC_REP_DIRECTION = "docrep";
+    private final static String NONE_DIRECTION = "none";
+    private final static String STRICT_MODE = "strict";
+    private final static String MIXED_MODE = "mixed";
+
+    /*
+    * This test will verify the resize request failure, when cluster mode is mixed
+    * and index is on DocRep node, and migration to remote store is in progress.
+    * */
+    public void testFailResizeIndexWhileDocRepToRemoteStoreMigration() throws Exception {
+
+        internalCluster().setBootstrapClusterManagerNodeIndex(0);
+        List<String> cmNodes = internalCluster().startNodes(1);
+        Client client = internalCluster().client(cmNodes.get(0));
+        ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest();
+        updateSettingsRequest.persistentSettings(Settings.builder().put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), MIXED_MODE));
+        assertAcked(client().admin().cluster().updateSettings(updateSettingsRequest).actionGet());
+
+        // Adding a non remote and a remote node
+        addRemote = false;
+        String nonRemoteNodeName = internalCluster().startNode();
+
+        addRemote = true;
+        String remoteNodeName = internalCluster().startNode();
+
+        logger.info("-->Create index on non-remote node and SETTING_REMOTE_STORE_ENABLED is false. Resize should not happen");
+        Settings.Builder builder = Settings.builder().put(SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT);
+        client.admin()
+            .indices()
+            .prepareCreate(TEST_INDEX)
+            .setSettings(
+                builder.put("index.number_of_shards", 10)
+                    .put("index.number_of_replicas", 0)
+                    .put("index.routing.allocation.include._name", nonRemoteNodeName)
+                    .put("index.routing.allocation.exclude._name", remoteNodeName)
+            )
+            .setWaitForActiveShards(ActiveShardCount.ALL)
+            .execute()
+            .actionGet();
+
+        updateSettingsRequest.persistentSettings(Settings.builder().put(MIGRATION_DIRECTION_SETTING.getKey(), REMOTE_STORE_DIRECTION));
+        assertAcked(client.admin().cluster().updateSettings(updateSettingsRequest).actionGet());
+
+        ResizeType resizeType;
+        int resizeShardsNum;
+        String cause;
+        switch (randomIntBetween(0, 2)) {
+            case 0:
+                resizeType = ResizeType.SHRINK;
+                resizeShardsNum = 5;
+                cause = "shrink_index";
+                break;
+            case 1:
+                resizeType = ResizeType.SPLIT;
+                resizeShardsNum = 20;
+                cause = "split_index";
+                break;
+            default:
+                resizeType = ResizeType.CLONE;
+                resizeShardsNum = 10;
+                cause = "clone_index";
+        }
+
+        client.admin()
+            .indices()
+            .prepareUpdateSettings(TEST_INDEX)
+            .setSettings(Settings.builder().put("index.blocks.write", true))
+            .execute()
+            .actionGet();
+
+        ensureGreen(TEST_INDEX);
+
+        Settings.Builder resizeSettingsBuilder = Settings.builder()
+            .put("index.number_of_replicas", 0)
+            .put("index.number_of_shards", resizeShardsNum)
+            .putNull("index.blocks.write");
+
+        IllegalStateException ex = expectThrows(
+            IllegalStateException.class,
+            () -> client().admin()
+                .indices()
+                .prepareResizeIndex(TEST_INDEX, "first_split")
+                .setResizeType(resizeType)
+                .setSettings(resizeSettingsBuilder.build())
+                .get()
+        );
+        assertEquals(
+            ex.getMessage(),
+            "Index " + resizeType + " is not allowed as remote migration mode is mixed" + " and index is remote store disabled"
+        );
+    }
+
+    /*
+     * This test will verify the resize request failure, when cluster mode is mixed
+     * and index is on Remote Store node, and migration to DocRep node is in progress.
+     * */
+    public void testFailResizeIndexWhileRemoteStoreToDocRepMigration() throws Exception {
+
+        addRemote = true;
+        internalCluster().setBootstrapClusterManagerNodeIndex(0);
+        List<String> cmNodes = internalCluster().startNodes(1);
+        Client client = internalCluster().client(cmNodes.get(0));
+        ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest();
+        updateSettingsRequest.persistentSettings(Settings.builder().put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), MIXED_MODE));
+        assertAcked(client().admin().cluster().updateSettings(updateSettingsRequest).actionGet());
+
+        // Adding a non remote and a remote node
+        String remoteNodeName = internalCluster().startNode();
+
+        addRemote = false;
+        String nonRemoteNodeName = internalCluster().startNode();
+
+        logger.info("-->Create index on remote node and SETTING_REMOTE_STORE_ENABLED is true. Resize should not happen");
+        Settings.Builder builder = Settings.builder().put(SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT);
+        client.admin()
+            .indices()
+            .prepareCreate(TEST_INDEX)
+            .setSettings(
+                builder.put("index.number_of_shards", 10)
+                    .put("index.number_of_replicas", 0)
+                    .put("index.routing.allocation.include._name", remoteNodeName)
+                    .put("index.routing.allocation.exclude._name", nonRemoteNodeName)
+            )
+            .setWaitForActiveShards(ActiveShardCount.ALL)
+            .execute()
+            .actionGet();
+
+        updateSettingsRequest.persistentSettings(Settings.builder().put(MIGRATION_DIRECTION_SETTING.getKey(), DOC_REP_DIRECTION));
+        assertAcked(client.admin().cluster().updateSettings(updateSettingsRequest).actionGet());
+
+        ResizeType resizeType;
+        int resizeShardsNum;
+        String cause;
+        switch (randomIntBetween(0, 2)) {
+            case 0:
+                resizeType = ResizeType.SHRINK;
+                resizeShardsNum = 5;
+                cause = "shrink_index";
+                break;
+            case 1:
+                resizeType = ResizeType.SPLIT;
+                resizeShardsNum = 20;
+                cause = "split_index";
+                break;
+            default:
+                resizeType = ResizeType.CLONE;
+                resizeShardsNum = 10;
+                cause = "clone_index";
+        }
+
+        client.admin()
+            .indices()
+            .prepareUpdateSettings(TEST_INDEX)
+            .setSettings(Settings.builder().put("index.blocks.write", true))
+            .execute()
+            .actionGet();
+
+        ensureGreen(TEST_INDEX);
+
+        Settings.Builder resizeSettingsBuilder = Settings.builder()
+            .put("index.number_of_replicas", 0)
+            .put("index.number_of_shards", resizeShardsNum)
+            .putNull("index.blocks.write");
+
+        IllegalStateException ex = expectThrows(
+            IllegalStateException.class,
+            () -> client().admin()
+                .indices()
+                .prepareResizeIndex(TEST_INDEX, "first_split")
+                .setResizeType(resizeType)
+                .setSettings(resizeSettingsBuilder.build())
+                .get()
+        );
+        assertEquals(
+            ex.getMessage(),
+            "Index " + resizeType + " is not allowed as remote migration mode is mixed" + " and index is remote store enabled"
+        );
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteRestoreSnapshotIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteRestoreSnapshotIT.java
index fff99e65054dc..ec98d5ff531cb 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteRestoreSnapshotIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteRestoreSnapshotIT.java
@@ -20,6 +20,7 @@
 import org.opensearch.client.Requests;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.Nullable;
 import org.opensearch.common.io.PathUtils;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.io.IOUtils;
@@ -27,7 +28,8 @@
 import org.opensearch.core.rest.RestStatus;
 import org.opensearch.index.IndexService;
 import org.opensearch.index.IndexSettings;
-import org.opensearch.index.remote.RemoteStorePathType;
+import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.indices.IndicesService;
 import org.opensearch.indices.replication.common.ReplicationType;
@@ -46,6 +48,7 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
@@ -283,7 +286,7 @@ public void testRemoteStoreCustomDataOnIndexCreationAndRestore() {
 
         indexDocuments(client, indexName1, randomIntBetween(5, 10));
         ensureGreen(indexName1);
-        validateRemoteStorePathType(indexName1, RemoteStorePathType.FIXED);
+        validatePathType(indexName1, PathType.FIXED);
 
         logger.info("--> snapshot");
         SnapshotInfo snapshotInfo = createSnapshot(snapshotRepoName, snapshotName1, new ArrayList<>(Arrays.asList(indexName1)));
@@ -300,14 +303,12 @@ public void testRemoteStoreCustomDataOnIndexCreationAndRestore() {
             .get();
         assertEquals(RestStatus.ACCEPTED, restoreSnapshotResponse.status());
         ensureGreen(restoredIndexName1version1);
-        validateRemoteStorePathType(restoredIndexName1version1, RemoteStorePathType.FIXED);
+        validatePathType(restoredIndexName1version1, PathType.FIXED);
 
         client(clusterManagerNode).admin()
             .cluster()
             .prepareUpdateSettings()
-            .setTransientSettings(
-                Settings.builder().put(CLUSTER_REMOTE_STORE_PATH_PREFIX_TYPE_SETTING.getKey(), RemoteStorePathType.HASHED_PREFIX)
-            )
+            .setTransientSettings(Settings.builder().put(CLUSTER_REMOTE_STORE_PATH_PREFIX_TYPE_SETTING.getKey(), PathType.HASHED_PREFIX))
             .get();
 
         restoreSnapshotResponse = client.admin()
@@ -319,24 +320,59 @@ public void testRemoteStoreCustomDataOnIndexCreationAndRestore() {
             .get();
         assertEquals(RestStatus.ACCEPTED, restoreSnapshotResponse.status());
         ensureGreen(restoredIndexName1version2);
-        validateRemoteStorePathType(restoredIndexName1version2, RemoteStorePathType.HASHED_PREFIX);
+        validatePathType(restoredIndexName1version2, PathType.HASHED_PREFIX, PathHashAlgorithm.FNV_1A);
 
         // Create index with cluster setting cluster.remote_store.index.path.prefix.type as hashed_prefix.
         indexSettings = getIndexSettings(1, 0).build();
         createIndex(indexName2, indexSettings);
         ensureGreen(indexName2);
-        validateRemoteStorePathType(indexName2, RemoteStorePathType.HASHED_PREFIX);
+        validatePathType(indexName2, PathType.HASHED_PREFIX, PathHashAlgorithm.FNV_1A);
 
         // Validating that custom data has not changed for indexes which were created before the cluster setting got updated
-        validateRemoteStorePathType(indexName1, RemoteStorePathType.FIXED);
+        validatePathType(indexName1, PathType.FIXED);
+
+        // Create Snapshot of index 2
+        String snapshotName2 = "test-restore-snapshot2";
+        snapshotInfo = createSnapshot(snapshotRepoName, snapshotName2, new ArrayList<>(List.of(indexName2)));
+        assertEquals(SnapshotState.SUCCESS, snapshotInfo.state());
+        assertTrue(snapshotInfo.successfulShards() > 0);
+        assertEquals(snapshotInfo.totalShards(), snapshotInfo.successfulShards());
+
+        // Update cluster settings to FIXED
+        client(clusterManagerNode).admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setTransientSettings(Settings.builder().put(CLUSTER_REMOTE_STORE_PATH_PREFIX_TYPE_SETTING.getKey(), PathType.FIXED))
+            .get();
+
+        // Close index 2
+        assertAcked(client().admin().indices().prepareClose(indexName2));
+        restoreSnapshotResponse = client.admin()
+            .cluster()
+            .prepareRestoreSnapshot(snapshotRepoName, snapshotName2)
+            .setWaitForCompletion(false)
+            .setIndices(indexName2)
+            .get();
+        assertEquals(RestStatus.ACCEPTED, restoreSnapshotResponse.status());
+        ensureGreen(indexName2);
+
+        // Validating that custom data has not changed for testindex2 which was created before the cluster setting got updated
+        validatePathType(indexName2, PathType.HASHED_PREFIX, PathHashAlgorithm.FNV_1A);
     }
 
-    private void validateRemoteStorePathType(String index, RemoteStorePathType pathType) {
+    private void validatePathType(String index, PathType pathType) {
+        validatePathType(index, pathType, null);
+    }
+
+    private void validatePathType(String index, PathType pathType, @Nullable PathHashAlgorithm pathHashAlgorithm) {
         ClusterState state = client().admin().cluster().prepareState().execute().actionGet().getState();
         // Validate that the remote_store custom data is present in index metadata for the created index.
         Map<String, String> remoteCustomData = state.metadata().index(index).getCustomData(IndexMetadata.REMOTE_STORE_CUSTOM_KEY);
         assertNotNull(remoteCustomData);
-        assertEquals(pathType.toString(), remoteCustomData.get(RemoteStorePathType.NAME));
+        assertEquals(pathType.name(), remoteCustomData.get(PathType.NAME));
+        if (Objects.nonNull(pathHashAlgorithm)) {
+            assertEquals(pathHashAlgorithm.name(), remoteCustomData.get(PathHashAlgorithm.NAME));
+        }
     }
 
     public void testRestoreInSameRemoteStoreEnabledIndex() throws IOException {
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java
index ba90cbe96e157..d7ad0daa43524 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java
@@ -28,7 +28,6 @@
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.core.common.unit.ByteSizeUnit;
 import org.opensearch.core.index.Index;
 import org.opensearch.index.IndexModule;
 import org.opensearch.index.IndexService;
@@ -57,11 +56,8 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 
-import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT;
-import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY;
-import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.repositories.fs.ReloadableFsRepository.REPOSITORIES_FAILRATE_SETTING;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 
@@ -191,121 +187,6 @@ protected BulkResponse indexBulk(String indexName, int numDocs) {
         return client().bulk(bulkRequest).actionGet();
     }
 
-    public static Settings remoteStoreClusterSettings(String name, Path path) {
-        return remoteStoreClusterSettings(name, path, name, path);
-    }
-
-    public static Settings remoteStoreClusterSettings(
-        String segmentRepoName,
-        Path segmentRepoPath,
-        String segmentRepoType,
-        String translogRepoName,
-        Path translogRepoPath,
-        String translogRepoType
-    ) {
-        Settings.Builder settingsBuilder = Settings.builder();
-        settingsBuilder.put(
-            buildRemoteStoreNodeAttributes(
-                segmentRepoName,
-                segmentRepoPath,
-                segmentRepoType,
-                translogRepoName,
-                translogRepoPath,
-                translogRepoType,
-                false
-            )
-        );
-        return settingsBuilder.build();
-    }
-
-    public static Settings remoteStoreClusterSettings(
-        String segmentRepoName,
-        Path segmentRepoPath,
-        String translogRepoName,
-        Path translogRepoPath
-    ) {
-        Settings.Builder settingsBuilder = Settings.builder();
-        settingsBuilder.put(buildRemoteStoreNodeAttributes(segmentRepoName, segmentRepoPath, translogRepoName, translogRepoPath, false));
-        return settingsBuilder.build();
-    }
-
-    public static Settings buildRemoteStoreNodeAttributes(
-        String segmentRepoName,
-        Path segmentRepoPath,
-        String translogRepoName,
-        Path translogRepoPath,
-        boolean withRateLimiterAttributes
-    ) {
-        return buildRemoteStoreNodeAttributes(
-            segmentRepoName,
-            segmentRepoPath,
-            ReloadableFsRepository.TYPE,
-            translogRepoName,
-            translogRepoPath,
-            ReloadableFsRepository.TYPE,
-            withRateLimiterAttributes
-        );
-    }
-
-    public static Settings buildRemoteStoreNodeAttributes(
-        String segmentRepoName,
-        Path segmentRepoPath,
-        String segmentRepoType,
-        String translogRepoName,
-        Path translogRepoPath,
-        String translogRepoType,
-        boolean withRateLimiterAttributes
-    ) {
-        String segmentRepoTypeAttributeKey = String.format(
-            Locale.getDefault(),
-            "node.attr." + REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT,
-            segmentRepoName
-        );
-        String segmentRepoSettingsAttributeKeyPrefix = String.format(
-            Locale.getDefault(),
-            "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
-            segmentRepoName
-        );
-        String translogRepoTypeAttributeKey = String.format(
-            Locale.getDefault(),
-            "node.attr." + REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT,
-            translogRepoName
-        );
-        String translogRepoSettingsAttributeKeyPrefix = String.format(
-            Locale.getDefault(),
-            "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
-            translogRepoName
-        );
-        String stateRepoTypeAttributeKey = String.format(
-            Locale.getDefault(),
-            "node.attr." + REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT,
-            segmentRepoName
-        );
-        String stateRepoSettingsAttributeKeyPrefix = String.format(
-            Locale.getDefault(),
-            "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
-            segmentRepoName
-        );
-
-        Settings.Builder settings = Settings.builder()
-            .put("node.attr." + REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, segmentRepoName)
-            .put(segmentRepoTypeAttributeKey, segmentRepoType)
-            .put(segmentRepoSettingsAttributeKeyPrefix + "location", segmentRepoPath)
-            .put("node.attr." + REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY, translogRepoName)
-            .put(translogRepoTypeAttributeKey, translogRepoType)
-            .put(translogRepoSettingsAttributeKeyPrefix + "location", translogRepoPath)
-            .put("node.attr." + REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, segmentRepoName)
-            .put(stateRepoTypeAttributeKey, segmentRepoType)
-            .put(stateRepoSettingsAttributeKeyPrefix + "location", segmentRepoPath);
-
-        if (withRateLimiterAttributes) {
-            settings.put(segmentRepoSettingsAttributeKeyPrefix + "compress", randomBoolean())
-                .put(segmentRepoSettingsAttributeKeyPrefix + "chunk_size", 200, ByteSizeUnit.BYTES);
-        }
-
-        return settings.build();
-    }
-
     Settings defaultIndexSettings() {
         return Settings.builder()
             .put(super.indexSettings())
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/multipart/mocks/MockFsAsyncBlobContainer.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/multipart/mocks/MockFsAsyncBlobContainer.java
index 36987ac2d4991..d45b4e3deb798 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/multipart/mocks/MockFsAsyncBlobContainer.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/multipart/mocks/MockFsAsyncBlobContainer.java
@@ -131,7 +131,7 @@ public void readBlobAsync(String blobName, ActionListener<ReadContext> listener)
                     InputStreamContainer blobPartStream = new InputStreamContainer(readBlob(blobName, offset, partSize), partSize, offset);
                     blobPartStreams.add(() -> CompletableFuture.completedFuture(blobPartStream));
                 }
-                ReadContext blobReadContext = new ReadContext(contentLength, blobPartStreams, null);
+                ReadContext blobReadContext = new ReadContext.Builder(contentLength, blobPartStreams).build();
                 listener.onResponse(blobReadContext);
             } catch (Exception e) {
                 listener.onFailure(e);
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/shrink/TransportResizeAction.java b/server/src/main/java/org/opensearch/action/admin/indices/shrink/TransportResizeAction.java
index ca4c16935c2b9..cb41325c18a22 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/shrink/TransportResizeAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/shrink/TransportResizeAction.java
@@ -48,6 +48,7 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.inject.Inject;
+import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -57,6 +58,9 @@
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.shard.DocsStats;
 import org.opensearch.index.store.StoreStats;
+import org.opensearch.node.remotestore.RemoteStoreNodeService;
+import org.opensearch.node.remotestore.RemoteStoreNodeService.CompatibilityMode;
+import org.opensearch.node.remotestore.RemoteStoreNodeService.Direction;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportService;
 
@@ -67,6 +71,7 @@
 import java.util.function.IntFunction;
 
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_REPLICAS;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REMOTE_STORE_ENABLED;
 
 /**
  * Main class to initiate resizing (shrink / split) an index into a new index
@@ -140,8 +145,8 @@ protected void clusterManagerOperation(
         // there is no need to fetch docs stats for split but we keep it simple and do it anyway for simplicity of the code
         final String sourceIndex = indexNameExpressionResolver.resolveDateMathExpression(resizeRequest.getSourceIndex());
         final String targetIndex = indexNameExpressionResolver.resolveDateMathExpression(resizeRequest.getTargetIndexRequest().index());
-
         IndexMetadata indexMetadata = state.metadata().index(sourceIndex);
+        ClusterSettings clusterSettings = clusterService.getClusterSettings();
         if (resizeRequest.getResizeType().equals(ResizeType.SHRINK)
             && state.metadata().isSegmentReplicationEnabled(sourceIndex)
             && indexMetadata != null
@@ -161,7 +166,7 @@ protected void clusterManagerOperation(
                             CreateIndexClusterStateUpdateRequest updateRequest = prepareCreateIndexRequest(resizeRequest, state, i -> {
                                 IndexShardStats shard = indicesStatsResponse.getIndex(sourceIndex).getIndexShards().get(i);
                                 return shard == null ? null : shard.getPrimary().getDocs();
-                            }, indicesStatsResponse.getPrimaries().store, sourceIndex, targetIndex);
+                            }, indicesStatsResponse.getPrimaries().store, clusterSettings, sourceIndex, targetIndex);
 
                             if (indicesStatsResponse.getIndex(sourceIndex)
                                 .getTotal()
@@ -200,7 +205,7 @@ protected void clusterManagerOperation(
                     CreateIndexClusterStateUpdateRequest updateRequest = prepareCreateIndexRequest(resizeRequest, state, i -> {
                         IndexShardStats shard = indicesStatsResponse.getIndex(sourceIndex).getIndexShards().get(i);
                         return shard == null ? null : shard.getPrimary().getDocs();
-                    }, indicesStatsResponse.getPrimaries().store, sourceIndex, targetIndex);
+                    }, indicesStatsResponse.getPrimaries().store, clusterSettings, sourceIndex, targetIndex);
                     createIndexService.createIndex(
                         updateRequest,
                         ActionListener.map(
@@ -223,6 +228,7 @@ static CreateIndexClusterStateUpdateRequest prepareCreateIndexRequest(
         final ClusterState state,
         final IntFunction<DocsStats> perShardDocStats,
         final StoreStats primaryShardsStoreStats,
+        final ClusterSettings clusterSettings,
         String sourceIndexName,
         String targetIndexName
     ) {
@@ -231,6 +237,7 @@ static CreateIndexClusterStateUpdateRequest prepareCreateIndexRequest(
         if (metadata == null) {
             throw new IndexNotFoundException(sourceIndexName);
         }
+        validateRemoteMigrationModeSettings(resizeRequest.getResizeType(), metadata, clusterSettings);
         final Settings.Builder targetIndexSettingsBuilder = Settings.builder()
             .put(targetIndex.settings())
             .normalizePrefix(IndexMetadata.INDEX_SETTING_PREFIX);
@@ -368,4 +375,39 @@ protected static int calculateTargetIndexShardsNum(
     protected String getClusterManagerActionName(DiscoveryNode node) {
         return super.getClusterManagerActionName(node);
     }
+
+    /**
+     * Reject resize request if cluster mode is [Mixed] and migration direction is [RemoteStore] and index is not on
+     * REMOTE_STORE_ENABLED node or [DocRep] and index is on REMOTE_STORE_ENABLED node.
+     * @param type resize type
+     * @param sourceIndexMetadata source index's metadata
+     * @param clusterSettings cluster settings
+     * @throws IllegalStateException if cluster mode is [Mixed] and migration direction is [RemoteStore] or [DocRep] and
+     *                               index's SETTING_REMOTE_STORE_ENABLED is not equal to the migration direction's value.
+     *                               For example, if migration direction is [RemoteStore] and index's SETTING_REMOTE_STORE_ENABLED
+     *                               is false, then throw IllegalStateException. If migration direction is [DocRep] and
+     *                               index's SETTING_REMOTE_STORE_ENABLED is true, then throw IllegalStateException.
+     */
+    private static void validateRemoteMigrationModeSettings(
+        final ResizeType type,
+        IndexMetadata sourceIndexMetadata,
+        ClusterSettings clusterSettings
+    ) {
+        CompatibilityMode compatibilityMode = clusterSettings.get(RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING);
+        if (compatibilityMode == CompatibilityMode.MIXED) {
+            boolean isRemoteStoreEnabled = sourceIndexMetadata.getSettings().getAsBoolean(SETTING_REMOTE_STORE_ENABLED, false);
+            Direction migrationDirection = clusterSettings.get(RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING);
+            boolean invalidConfiguration = (migrationDirection == Direction.REMOTE_STORE && isRemoteStoreEnabled == false)
+                || (migrationDirection == Direction.DOCREP && isRemoteStoreEnabled);
+            if (invalidConfiguration) {
+                throw new IllegalStateException(
+                    "Index "
+                        + type
+                        + " is not allowed as remote migration mode is mixed"
+                        + " and index is remote store "
+                        + (isRemoteStoreEnabled ? "enabled" : "disabled")
+                );
+            }
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/bulk/BulkRequestParser.java b/server/src/main/java/org/opensearch/action/bulk/BulkRequestParser.java
index 3fadfe5f2cd6a..f705a218fb8e2 100644
--- a/server/src/main/java/org/opensearch/action/bulk/BulkRequestParser.java
+++ b/server/src/main/java/org/opensearch/action/bulk/BulkRequestParser.java
@@ -371,7 +371,7 @@ public void parse(
                         }
                         IndexRequest upsertRequest = updateRequest.upsertRequest();
                         if (upsertRequest != null) {
-                            upsertRequest.setPipeline(defaultPipeline);
+                            upsertRequest.setPipeline(pipeline);
                         }
 
                         updateRequestConsumer.accept(updateRequest);
diff --git a/server/src/main/java/org/opensearch/action/bulk/TransportShardBulkAction.java b/server/src/main/java/org/opensearch/action/bulk/TransportShardBulkAction.java
index a7a13afd2597c..fdba8a42c0170 100644
--- a/server/src/main/java/org/opensearch/action/bulk/TransportShardBulkAction.java
+++ b/server/src/main/java/org/opensearch/action/bulk/TransportShardBulkAction.java
@@ -442,7 +442,7 @@ protected long primaryOperationSize(BulkShardRequest request) {
 
     @Override
     public ReplicationMode getReplicationMode(IndexShard indexShard) {
-        if (indexShard.isRemoteTranslogEnabled()) {
+        if (indexShard.indexSettings().isAssignedOnRemoteNode()) {
             return ReplicationMode.PRIMARY_TERM_VALIDATION;
         }
         return super.getReplicationMode(indexShard);
diff --git a/server/src/main/java/org/opensearch/action/support/AutoCreateIndex.java b/server/src/main/java/org/opensearch/action/support/AutoCreateIndex.java
index 9e8cbd7bf40c2..ce0a8f84d066f 100644
--- a/server/src/main/java/org/opensearch/action/support/AutoCreateIndex.java
+++ b/server/src/main/java/org/opensearch/action/support/AutoCreateIndex.java
@@ -43,7 +43,6 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.common.Strings;
 import org.opensearch.index.IndexNotFoundException;
-import org.opensearch.index.mapper.MapperService;
 import org.opensearch.indices.SystemIndices;
 
 import java.util.ArrayList;
@@ -64,8 +63,6 @@ public final class AutoCreateIndex {
         Property.NodeScope,
         Setting.Property.Dynamic
     );
-
-    private final boolean dynamicMappingDisabled;
     private final IndexNameExpressionResolver resolver;
     private final SystemIndices systemIndices;
     private volatile AutoCreate autoCreate;
@@ -77,7 +74,6 @@ public AutoCreateIndex(
         SystemIndices systemIndices
     ) {
         this.resolver = resolver;
-        dynamicMappingDisabled = !MapperService.INDEX_MAPPER_DYNAMIC_SETTING.get(settings);
         this.systemIndices = systemIndices;
         this.autoCreate = AUTO_CREATE_INDEX_SETTING.get(settings);
         clusterSettings.addSettingsUpdateConsumer(AUTO_CREATE_INDEX_SETTING, this::setAutoCreate);
@@ -109,9 +105,6 @@ public boolean shouldAutoCreate(String index, ClusterState state) {
         if (autoCreate.autoCreateIndex == false) {
             throw new IndexNotFoundException("[" + AUTO_CREATE_INDEX_SETTING.getKey() + "] is [false]", index);
         }
-        if (dynamicMappingDisabled) {
-            throw new IndexNotFoundException("[" + MapperService.INDEX_MAPPER_DYNAMIC_SETTING.getKey() + "] is [false]", index);
-        }
         // matches not set, default value of "true"
         if (autoCreate.expressions.isEmpty()) {
             return true;
diff --git a/server/src/main/java/org/opensearch/action/support/replication/ReplicationModeAwareProxy.java b/server/src/main/java/org/opensearch/action/support/replication/ReplicationModeAwareProxy.java
index 189bc82348a0c..9f5e31a9c6926 100644
--- a/server/src/main/java/org/opensearch/action/support/replication/ReplicationModeAwareProxy.java
+++ b/server/src/main/java/org/opensearch/action/support/replication/ReplicationModeAwareProxy.java
@@ -9,6 +9,8 @@
 package org.opensearch.action.support.replication;
 
 import org.opensearch.action.support.replication.ReplicationOperation.ReplicaResponse;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.core.action.ActionListener;
 
@@ -31,14 +33,22 @@ public class ReplicationModeAwareProxy<ReplicaRequest extends ReplicationRequest
      */
     private final ReplicationOperation.Replicas<ReplicaRequest> primaryTermValidationProxy;
 
+    private final DiscoveryNodes discoveryNodes;
+
+    private final boolean isRemoteEnabled;
+
     public ReplicationModeAwareProxy(
         ReplicationMode replicationModeOverride,
+        DiscoveryNodes discoveryNodes,
         ReplicationOperation.Replicas<ReplicaRequest> replicasProxy,
-        ReplicationOperation.Replicas<ReplicaRequest> primaryTermValidationProxy
+        ReplicationOperation.Replicas<ReplicaRequest> primaryTermValidationProxy,
+        boolean remoteIndexSettingsEnabled
     ) {
         super(replicasProxy);
         this.replicationModeOverride = Objects.requireNonNull(replicationModeOverride);
         this.primaryTermValidationProxy = Objects.requireNonNull(primaryTermValidationProxy);
+        this.discoveryNodes = discoveryNodes;
+        this.isRemoteEnabled = remoteIndexSettingsEnabled;
     }
 
     @Override
@@ -60,16 +70,26 @@ protected void performOnReplicaProxy(
 
     @Override
     ReplicationMode determineReplicationMode(ShardRouting shardRouting, ShardRouting primaryRouting) {
-
         // If the current routing is the primary, then it does not need to be replicated
         if (shardRouting.isSameAllocation(primaryRouting)) {
             return ReplicationMode.NO_REPLICATION;
         }
-
+        // Perform full replication during primary relocation
         if (primaryRouting.relocating() && shardRouting.isSameAllocation(primaryRouting.getTargetRelocatingShard())) {
             return ReplicationMode.FULL_REPLICATION;
         }
-
+        /*
+        Only applicable during remote store migration.
+        During the migration process, remote based index settings will not be enabled,
+        thus we will rely on node attributes to figure out the replication mode
+         */
+        if (isRemoteEnabled == false) {
+            DiscoveryNode targetNode = discoveryNodes.get(shardRouting.currentNodeId());
+            if (targetNode != null && targetNode.isRemoteStoreNode() == false) {
+                // Perform full replication if replica is hosted on a non-remote node.
+                return ReplicationMode.FULL_REPLICATION;
+            }
+        }
         return replicationModeOverride;
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java b/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
index 95f998e2d89c2..49a96603f6802 100644
--- a/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
+++ b/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
@@ -356,7 +356,7 @@ public void performOn(
      * @return the overridden replication mode.
      */
     public ReplicationMode getReplicationMode(IndexShard indexShard) {
-        if (indexShard.isRemoteTranslogEnabled()) {
+        if (indexShard.indexSettings().isAssignedOnRemoteNode()) {
             return ReplicationMode.NO_REPLICATION;
         }
         return ReplicationMode.FULL_REPLICATION;
@@ -642,8 +642,14 @@ public void handleException(TransportException exp) {
                         primaryRequest.getPrimaryTerm(),
                         initialRetryBackoffBound,
                         retryTimeout,
-                        indexShard.isRemoteTranslogEnabled()
-                            ? new ReplicationModeAwareProxy<>(getReplicationMode(indexShard), replicasProxy, termValidationProxy)
+                        indexShard.indexSettings().isAssignedOnRemoteNode()
+                            ? new ReplicationModeAwareProxy<>(
+                                getReplicationMode(indexShard),
+                                clusterState.getNodes(),
+                                replicasProxy,
+                                termValidationProxy,
+                                indexShard.isRemoteTranslogEnabled()
+                            )
                             : new FanoutReplicationProxy<>(replicasProxy)
                     ).execute();
                 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/MetadataCreateIndexService.java b/server/src/main/java/org/opensearch/cluster/metadata/MetadataCreateIndexService.java
index aee0473be95eb..64bea79c9e47b 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/MetadataCreateIndexService.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/MetadataCreateIndexService.java
@@ -88,8 +88,10 @@
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.mapper.MapperService.MergeReason;
 import org.opensearch.index.query.QueryShardContext;
-import org.opensearch.index.remote.RemoteStorePathType;
-import org.opensearch.index.remote.RemoteStorePathTypeResolver;
+import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
+import org.opensearch.index.remote.RemoteStorePathStrategyResolver;
 import org.opensearch.index.shard.IndexSettingProvider;
 import org.opensearch.index.translog.Translog;
 import org.opensearch.indices.IndexCreationException;
@@ -171,7 +173,7 @@ public class MetadataCreateIndexService {
     private AwarenessReplicaBalance awarenessReplicaBalance;
 
     @Nullable
-    private final RemoteStorePathTypeResolver remoteStorePathTypeResolver;
+    private final RemoteStorePathStrategyResolver remoteStorePathStrategyResolver;
 
     public MetadataCreateIndexService(
         final Settings settings,
@@ -204,8 +206,9 @@ public MetadataCreateIndexService(
 
         // Task is onboarded for throttling, it will get retried from associated TransportClusterManagerNodeAction.
         createIndexTaskKey = clusterService.registerClusterManagerTask(ClusterManagerTaskKeys.CREATE_INDEX_KEY, true);
-        remoteStorePathTypeResolver = isRemoteDataAttributePresent(settings)
-            ? new RemoteStorePathTypeResolver(clusterService.getClusterSettings())
+        Supplier<Version> minNodeVersionSupplier = () -> clusterService.state().nodes().getMinNodeVersion();
+        remoteStorePathStrategyResolver = isRemoteDataAttributePresent(settings)
+            ? new RemoteStorePathStrategyResolver(clusterService.getClusterSettings(), minNodeVersionSupplier)
             : null;
     }
 
@@ -554,7 +557,7 @@ IndexMetadata buildAndValidateTemporaryIndexMetadata(
         tmpImdBuilder.setRoutingNumShards(routingNumShards);
         tmpImdBuilder.settings(indexSettings);
         tmpImdBuilder.system(isSystem);
-        addRemoteStorePathTypeInCustomData(tmpImdBuilder, true);
+        addRemoteStorePathStrategyInCustomData(tmpImdBuilder, true);
 
         // Set up everything, now locally create the index to see that things are ok, and apply
         IndexMetadata tempMetadata = tmpImdBuilder.build();
@@ -569,21 +572,24 @@ IndexMetadata buildAndValidateTemporaryIndexMetadata(
      * @param tmpImdBuilder     index metadata builder.
      * @param assertNullOldType flag to verify that the old remote store path type is null
      */
-    public void addRemoteStorePathTypeInCustomData(IndexMetadata.Builder tmpImdBuilder, boolean assertNullOldType) {
-        if (remoteStorePathTypeResolver != null) {
-            // It is possible that remote custom data exists already. In such cases, we need to only update the path type
-            // in the remote store custom data map.
-            Map<String, String> existingRemoteCustomData = tmpImdBuilder.removeCustom(IndexMetadata.REMOTE_STORE_CUSTOM_KEY);
-            Map<String, String> remoteCustomData = existingRemoteCustomData == null
-                ? new HashMap<>()
-                : new HashMap<>(existingRemoteCustomData);
-            // Determine the path type for use using the remoteStorePathResolver.
-            String newPathType = remoteStorePathTypeResolver.getType().toString();
-            String oldPathType = remoteCustomData.put(RemoteStorePathType.NAME, newPathType);
-            assert !assertNullOldType || Objects.isNull(oldPathType);
-            logger.trace(() -> new ParameterizedMessage("Added new path type {}, replaced old path type {}", newPathType, oldPathType));
-            tmpImdBuilder.putCustom(IndexMetadata.REMOTE_STORE_CUSTOM_KEY, remoteCustomData);
+    public void addRemoteStorePathStrategyInCustomData(IndexMetadata.Builder tmpImdBuilder, boolean assertNullOldType) {
+        if (remoteStorePathStrategyResolver == null) {
+            return;
+        }
+        // It is possible that remote custom data exists already. In such cases, we need to only update the path type
+        // in the remote store custom data map.
+        Map<String, String> existingCustomData = tmpImdBuilder.removeCustom(IndexMetadata.REMOTE_STORE_CUSTOM_KEY);
+        assert assertNullOldType == false || Objects.isNull(existingCustomData);
+
+        // Determine the path type for use using the remoteStorePathResolver.
+        RemoteStorePathStrategy newPathStrategy = remoteStorePathStrategyResolver.get();
+        Map<String, String> remoteCustomData = new HashMap<>();
+        remoteCustomData.put(PathType.NAME, newPathStrategy.getType().name());
+        if (Objects.nonNull(newPathStrategy.getHashAlgorithm())) {
+            remoteCustomData.put(PathHashAlgorithm.NAME, newPathStrategy.getHashAlgorithm().name());
         }
+        logger.trace(() -> new ParameterizedMessage("Added newStrategy={}, replaced oldStrategy={}", remoteCustomData, existingCustomData));
+        tmpImdBuilder.putCustom(IndexMetadata.REMOTE_STORE_CUSTOM_KEY, remoteCustomData);
     }
 
     private ClusterState applyCreateIndexRequestWithV1Templates(
diff --git a/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
index 36149d014ea84..2c250f6a5d86e 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
@@ -34,7 +34,6 @@
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.opensearch.cluster.metadata.WeightedRoutingMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.Nullable;
@@ -63,7 +62,6 @@
 import java.util.Set;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 import static java.util.Collections.emptyMap;
 
@@ -96,8 +94,8 @@ public class IndexShardRoutingTable implements Iterable<ShardRouting> {
     private volatile Map<AttributesKey, AttributesRoutings> initializingShardsByAttributes = emptyMap();
     private final Object shardsByAttributeMutex = new Object();
     private final Object shardsByWeightMutex = new Object();
-    private volatile Map<WeightedRoutingKey, List<ShardRouting>> activeShardsByWeight = emptyMap();
-    private volatile Map<WeightedRoutingKey, List<ShardRouting>> initializingShardsByWeight = emptyMap();
+    private volatile Map<WeightedRoutingKey, WeightedShardRoutings> activeShardsByWeight = emptyMap();
+    private volatile Map<WeightedRoutingKey, WeightedShardRoutings> initializingShardsByWeight = emptyMap();
 
     private static final Logger logger = LogManager.getLogger(IndexShardRoutingTable.class);
 
@@ -249,7 +247,7 @@ public List<ShardRouting> assignedShards() {
         return this.assignedShards;
     }
 
-    public Map<WeightedRoutingKey, List<ShardRouting>> getActiveShardsByWeight() {
+    public Map<WeightedRoutingKey, WeightedShardRoutings> getActiveShardsByWeight() {
         return activeShardsByWeight;
     }
 
@@ -338,23 +336,7 @@ public ShardIterator activeInitializingShardsWeightedIt(
         // append shards for attribute value with weight zero, so that shard search requests can be tried on
         // shard copies in case of request failure from other attribute values.
         if (isFailOpenEnabled) {
-            try {
-                Stream<String> keys = weightedRouting.weights()
-                    .entrySet()
-                    .stream()
-                    .filter(entry -> entry.getValue().intValue() == WeightedRoutingMetadata.WEIGHED_AWAY_WEIGHT)
-                    .map(Map.Entry::getKey);
-                keys.forEach(key -> {
-                    ShardIterator iterator = onlyNodeSelectorActiveInitializingShardsIt(weightedRouting.attributeName() + ":" + key, nodes);
-                    while (iterator.remaining() > 0) {
-                        ordered.add(iterator.nextOrNull());
-                    }
-                });
-            } catch (IllegalArgumentException e) {
-                // this exception is thrown by {@link onlyNodeSelectorActiveInitializingShardsIt} in case count of shard
-                // copies found is zero
-                logger.debug("no shard copies found for shard id [{}] for node attribute with weight zero", shardId);
-            }
+            ordered.addAll(activeInitializingShardsWithoutWeights(weightedRouting, nodes, defaultWeight));
         }
 
         return new PlainShardIterator(shardId, ordered);
@@ -378,6 +360,18 @@ private List<ShardRouting> activeInitializingShardsWithWeights(
         return orderedListWithDistinctShards;
     }
 
+    private List<ShardRouting> activeInitializingShardsWithoutWeights(
+        WeightedRouting weightedRouting,
+        DiscoveryNodes nodes,
+        double defaultWeight
+    ) {
+        List<ShardRouting> ordered = new ArrayList<>(getActiveShardsWithoutWeight(weightedRouting, nodes, defaultWeight));
+        if (!allInitializingShards.isEmpty()) {
+            ordered.addAll(getInitializingShardsWithoutWeight(weightedRouting, nodes, defaultWeight));
+        }
+        return ordered.stream().distinct().collect(Collectors.toList());
+    }
+
     /**
      * Returns a list containing shard routings ordered using weighted round-robin scheduling.
      */
@@ -949,20 +943,60 @@ public int hashCode() {
         }
     }
 
+    /**
+     * Holder class for shard routing(s) which are classified and stored based on their weights.
+     *
+     * @opensearch.api
+     */
+    @PublicApi(since = "2.14.0")
+    public static class WeightedShardRoutings {
+        private final List<ShardRouting> shardRoutingsWithWeight;
+        private final List<ShardRouting> shardRoutingWithoutWeight;
+
+        public WeightedShardRoutings(List<ShardRouting> shardRoutingsWithWeight, List<ShardRouting> shardRoutingWithoutWeight) {
+            this.shardRoutingsWithWeight = Collections.unmodifiableList(shardRoutingsWithWeight);
+            this.shardRoutingWithoutWeight = Collections.unmodifiableList(shardRoutingWithoutWeight);
+        }
+
+        public List<ShardRouting> getShardRoutingsWithWeight() {
+            return shardRoutingsWithWeight;
+        }
+
+        public List<ShardRouting> getShardRoutingWithoutWeight() {
+            return shardRoutingWithoutWeight;
+        }
+    }
+
     /**
      * *
      * Gets active shard routing from memory if available, else calculates and put it in memory.
      */
     private List<ShardRouting> getActiveShardsByWeight(WeightedRouting weightedRouting, DiscoveryNodes nodes, double defaultWeight) {
         WeightedRoutingKey key = new WeightedRoutingKey(weightedRouting);
-        List<ShardRouting> shardRoutings = activeShardsByWeight.get(key);
-        if (shardRoutings == null) {
-            synchronized (shardsByWeightMutex) {
-                shardRoutings = shardsOrderedByWeight(activeShards, weightedRouting, nodes, defaultWeight);
-                activeShardsByWeight = new MapBuilder().put(key, shardRoutings).immutableMap();
-            }
+        if (activeShardsByWeight.get(key) == null) {
+            populateActiveShardWeightsMap(weightedRouting, nodes, defaultWeight);
+        }
+        return activeShardsByWeight.get(key).getShardRoutingsWithWeight();
+    }
+
+    private List<ShardRouting> getActiveShardsWithoutWeight(WeightedRouting weightedRouting, DiscoveryNodes nodes, double defaultWeight) {
+        WeightedRoutingKey key = new WeightedRoutingKey(weightedRouting);
+        if (activeShardsByWeight.get(key) == null) {
+            populateActiveShardWeightsMap(weightedRouting, nodes, defaultWeight);
+        }
+        return activeShardsByWeight.get(key).getShardRoutingWithoutWeight();
+    }
+
+    private void populateActiveShardWeightsMap(WeightedRouting weightedRouting, DiscoveryNodes nodes, double defaultWeight) {
+        WeightedRoutingKey key = new WeightedRoutingKey(weightedRouting);
+        List<ShardRouting> weightedRoutings = shardsOrderedByWeight(activeShards, weightedRouting, nodes, defaultWeight);
+        List<ShardRouting> nonWeightedRoutings = activeShards.stream()
+            .filter(shard -> !weightedRoutings.contains(shard))
+            .collect(Collectors.toUnmodifiableList());
+        synchronized (shardsByWeightMutex) {
+            activeShardsByWeight = new MapBuilder().put(key, new WeightedShardRoutings(weightedRoutings, nonWeightedRoutings))
+                .immutableMap();
         }
-        return shardRoutings;
     }
 
     /**
@@ -971,14 +1005,34 @@ private List<ShardRouting> getActiveShardsByWeight(WeightedRouting weightedRouti
      */
     private List<ShardRouting> getInitializingShardsByWeight(WeightedRouting weightedRouting, DiscoveryNodes nodes, double defaultWeight) {
         WeightedRoutingKey key = new WeightedRoutingKey(weightedRouting);
-        List<ShardRouting> shardRoutings = initializingShardsByWeight.get(key);
-        if (shardRoutings == null) {
-            synchronized (shardsByWeightMutex) {
-                shardRoutings = shardsOrderedByWeight(activeShards, weightedRouting, nodes, defaultWeight);
-                initializingShardsByWeight = new MapBuilder().put(key, shardRoutings).immutableMap();
-            }
+        if (initializingShardsByWeight.get(key) == null) {
+            populateInitializingShardWeightsMap(weightedRouting, nodes, defaultWeight);
+        }
+        return initializingShardsByWeight.get(key).getShardRoutingsWithWeight();
+    }
+
+    private List<ShardRouting> getInitializingShardsWithoutWeight(
+        WeightedRouting weightedRouting,
+        DiscoveryNodes nodes,
+        double defaultWeight
+    ) {
+        WeightedRoutingKey key = new WeightedRoutingKey(weightedRouting);
+        if (initializingShardsByWeight.get(key) == null) {
+            populateInitializingShardWeightsMap(weightedRouting, nodes, defaultWeight);
+        }
+        return initializingShardsByWeight.get(key).getShardRoutingWithoutWeight();
+    }
+
+    private void populateInitializingShardWeightsMap(WeightedRouting weightedRouting, DiscoveryNodes nodes, double defaultWeight) {
+        WeightedRoutingKey key = new WeightedRoutingKey(weightedRouting);
+        List<ShardRouting> weightedRoutings = shardsOrderedByWeight(allInitializingShards, weightedRouting, nodes, defaultWeight);
+        List<ShardRouting> nonWeightedRoutings = allInitializingShards.stream()
+            .filter(shard -> !weightedRoutings.contains(shard))
+            .collect(Collectors.toUnmodifiableList());
+        synchronized (shardsByWeightMutex) {
+            initializingShardsByWeight = new MapBuilder().put(key, new WeightedShardRoutings(weightedRoutings, nonWeightedRoutings))
+                .immutableMap();
         }
-        return shardRoutings;
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/cluster/routing/WeightedRouting.java b/server/src/main/java/org/opensearch/cluster/routing/WeightedRouting.java
index 468fac08d2946..6f0e4fe90cfff 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/WeightedRouting.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/WeightedRouting.java
@@ -14,6 +14,7 @@
 import org.opensearch.core.common.io.stream.Writeable;
 
 import java.io.IOException;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
@@ -25,27 +26,26 @@
  */
 @PublicApi(since = "2.4.0")
 public class WeightedRouting implements Writeable {
-    private String attributeName;
-    private Map<String, Double> weights;
+    private final String attributeName;
+    private final Map<String, Double> weights;
+    private final int hashCode;
 
     public WeightedRouting() {
-        this.attributeName = "";
-        this.weights = new HashMap<>(3);
+        this("", new HashMap<>(3));
     }
 
     public WeightedRouting(String attributeName, Map<String, Double> weights) {
         this.attributeName = attributeName;
-        this.weights = weights;
+        this.weights = Collections.unmodifiableMap(weights);
+        this.hashCode = Objects.hash(this.attributeName, this.weights);
     }
 
     public WeightedRouting(WeightedRouting weightedRouting) {
-        this.attributeName = weightedRouting.attributeName();
-        this.weights = weightedRouting.weights;
+        this(weightedRouting.attributeName(), weightedRouting.weights);
     }
 
     public WeightedRouting(StreamInput in) throws IOException {
-        attributeName = in.readString();
-        weights = (Map<String, Double>) in.readGenericValue();
+        this(in.readString(), (Map<String, Double>) in.readGenericValue());
     }
 
     public boolean isSet() {
@@ -70,7 +70,7 @@ public boolean equals(Object o) {
 
     @Override
     public int hashCode() {
-        return Objects.hash(attributeName, weights);
+        return hashCode;
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationConstraints.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationConstraints.java
index 5375910c57579..6702db4b43e91 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationConstraints.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationConstraints.java
@@ -30,9 +30,9 @@ public class AllocationConstraints {
 
     public AllocationConstraints() {
         this.constraints = new HashMap<>();
-        this.constraints.putIfAbsent(INDEX_SHARD_PER_NODE_BREACH_CONSTRAINT_ID, new Constraint(isIndexShardsPerNodeBreached()));
-        this.constraints.putIfAbsent(INDEX_PRIMARY_SHARD_BALANCE_CONSTRAINT_ID, new Constraint(isPerIndexPrimaryShardsPerNodeBreached()));
-        this.constraints.putIfAbsent(CLUSTER_PRIMARY_SHARD_BALANCE_CONSTRAINT_ID, new Constraint(isPrimaryShardsPerNodeBreached()));
+        this.constraints.put(INDEX_SHARD_PER_NODE_BREACH_CONSTRAINT_ID, new Constraint(isIndexShardsPerNodeBreached()));
+        this.constraints.put(INDEX_PRIMARY_SHARD_BALANCE_CONSTRAINT_ID, new Constraint(isPerIndexPrimaryShardsPerNodeBreached()));
+        this.constraints.put(CLUSTER_PRIMARY_SHARD_BALANCE_CONSTRAINT_ID, new Constraint(isPrimaryShardsPerNodeBreached(0.0f)));
     }
 
     public void updateAllocationConstraint(String constraint, boolean enable) {
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/ConstraintTypes.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/ConstraintTypes.java
index ae2d4a0926194..08fe8f92d1f80 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/ConstraintTypes.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/ConstraintTypes.java
@@ -28,6 +28,11 @@ public class ConstraintTypes {
      */
     public final static String CLUSTER_PRIMARY_SHARD_BALANCE_CONSTRAINT_ID = "cluster.primary.shard.balance.constraint";
 
+    /**
+     * Defines a cluster constraint which is breached when a node contains more than avg primary shards across all indices
+     */
+    public final static String CLUSTER_PRIMARY_SHARD_REBALANCE_CONSTRAINT_ID = "cluster.primary.shard.rebalance.constraint";
+
     /**
      * Defines an index constraint which is breached when a node contains more than avg number of shards for an index
      */
@@ -70,14 +75,14 @@ public static Predicate<Constraint.ConstraintParams> isPerIndexPrimaryShardsPerN
     }
 
     /**
-     * Defines a predicate which returns true when a node contains more than average number of primary shards. This
-     * constraint is used in weight calculation during allocation only. When breached a high weight {@link ConstraintTypes#CONSTRAINT_WEIGHT}
-     * is assigned to node resulting in lesser chances of node being selected as allocation target
+     * Defines a predicate which returns true when a node contains more than average number of primary shards with added buffer. This
+     * constraint is used in weight calculation during allocation/rebalance both. When breached a high weight {@link ConstraintTypes#CONSTRAINT_WEIGHT}
+     * is assigned to node resulting in lesser chances of node being selected as allocation/rebalance target
      */
-    public static Predicate<Constraint.ConstraintParams> isPrimaryShardsPerNodeBreached() {
+    public static Predicate<Constraint.ConstraintParams> isPrimaryShardsPerNodeBreached(float buffer) {
         return (params) -> {
             int primaryShardCount = params.getNode().numPrimaryShards();
-            int allowedPrimaryShardCount = (int) Math.ceil(params.getBalancer().avgPrimaryShardsPerNode());
+            int allowedPrimaryShardCount = (int) Math.ceil(params.getBalancer().avgPrimaryShardsPerNode() * (1 + buffer));
             return primaryShardCount >= allowedPrimaryShardCount;
         };
     }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/RebalanceConstraints.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/RebalanceConstraints.java
index a4036ec47ec0e..2c2138af18abc 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/RebalanceConstraints.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/RebalanceConstraints.java
@@ -14,8 +14,10 @@
 import java.util.HashMap;
 import java.util.Map;
 
+import static org.opensearch.cluster.routing.allocation.ConstraintTypes.CLUSTER_PRIMARY_SHARD_REBALANCE_CONSTRAINT_ID;
 import static org.opensearch.cluster.routing.allocation.ConstraintTypes.INDEX_PRIMARY_SHARD_BALANCE_CONSTRAINT_ID;
 import static org.opensearch.cluster.routing.allocation.ConstraintTypes.isPerIndexPrimaryShardsPerNodeBreached;
+import static org.opensearch.cluster.routing.allocation.ConstraintTypes.isPrimaryShardsPerNodeBreached;
 
 /**
  * Constraints applied during rebalancing round; specify conditions which, if breached, reduce the
@@ -27,9 +29,13 @@ public class RebalanceConstraints {
 
     private Map<String, Constraint> constraints;
 
-    public RebalanceConstraints() {
+    public RebalanceConstraints(RebalanceParameter rebalanceParameter) {
         this.constraints = new HashMap<>();
-        this.constraints.putIfAbsent(INDEX_PRIMARY_SHARD_BALANCE_CONSTRAINT_ID, new Constraint(isPerIndexPrimaryShardsPerNodeBreached()));
+        this.constraints.put(INDEX_PRIMARY_SHARD_BALANCE_CONSTRAINT_ID, new Constraint(isPerIndexPrimaryShardsPerNodeBreached()));
+        this.constraints.put(
+            CLUSTER_PRIMARY_SHARD_REBALANCE_CONSTRAINT_ID,
+            new Constraint(isPrimaryShardsPerNodeBreached(rebalanceParameter.getPreferPrimaryBalanceBuffer()))
+        );
     }
 
     public void updateRebalanceConstraint(String constraint, boolean enable) {
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/RebalanceParameter.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/RebalanceParameter.java
new file mode 100644
index 0000000000000..35fbaede93ba3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/RebalanceParameter.java
@@ -0,0 +1,24 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.allocation;
+
+/**
+ * RebalanceConstraint Params
+ */
+public class RebalanceParameter {
+    private float preferPrimaryBalanceBuffer;
+
+    public RebalanceParameter(float preferPrimaryBalanceBuffer) {
+        this.preferPrimaryBalanceBuffer = preferPrimaryBalanceBuffer;
+    }
+
+    public float getPreferPrimaryBalanceBuffer() {
+        return preferPrimaryBalanceBuffer;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java
index 41ace0e7661fe..b2443490dd973 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java
@@ -46,6 +46,7 @@
 import org.opensearch.cluster.routing.allocation.ConstraintTypes;
 import org.opensearch.cluster.routing.allocation.MoveDecision;
 import org.opensearch.cluster.routing.allocation.RebalanceConstraints;
+import org.opensearch.cluster.routing.allocation.RebalanceParameter;
 import org.opensearch.cluster.routing.allocation.RoutingAllocation;
 import org.opensearch.cluster.routing.allocation.ShardAllocationDecision;
 import org.opensearch.common.inject.Inject;
@@ -61,6 +62,7 @@
 import java.util.Set;
 
 import static org.opensearch.cluster.routing.allocation.ConstraintTypes.CLUSTER_PRIMARY_SHARD_BALANCE_CONSTRAINT_ID;
+import static org.opensearch.cluster.routing.allocation.ConstraintTypes.CLUSTER_PRIMARY_SHARD_REBALANCE_CONSTRAINT_ID;
 import static org.opensearch.cluster.routing.allocation.ConstraintTypes.INDEX_PRIMARY_SHARD_BALANCE_CONSTRAINT_ID;
 import static org.opensearch.cluster.routing.allocation.ConstraintTypes.INDEX_SHARD_PER_NODE_BREACH_CONSTRAINT_ID;
 
@@ -145,10 +147,29 @@ public class BalancedShardsAllocator implements ShardsAllocator {
         Property.NodeScope
     );
 
+    public static final Setting<Boolean> PREFER_PRIMARY_SHARD_REBALANCE = Setting.boolSetting(
+        "cluster.routing.allocation.rebalance.primary.enable",
+        false,
+        Property.Dynamic,
+        Property.NodeScope
+    );
+
+    public static final Setting<Float> PRIMARY_SHARD_REBALANCE_BUFFER = Setting.floatSetting(
+        "cluster.routing.allocation.rebalance.primary.buffer",
+        0.10f,
+        0.0f,
+        Property.Dynamic,
+        Property.NodeScope
+    );
+
     private volatile boolean movePrimaryFirst;
     private volatile ShardMovementStrategy shardMovementStrategy;
 
     private volatile boolean preferPrimaryShardBalance;
+    private volatile boolean preferPrimaryShardRebalance;
+    private volatile float preferPrimaryShardRebalanceBuffer;
+    private volatile float indexBalanceFactor;
+    private volatile float shardBalanceFactor;
     private volatile WeightFunction weightFunction;
     private volatile float threshold;
 
@@ -158,14 +179,21 @@ public BalancedShardsAllocator(Settings settings) {
 
     @Inject
     public BalancedShardsAllocator(Settings settings, ClusterSettings clusterSettings) {
-        setWeightFunction(INDEX_BALANCE_FACTOR_SETTING.get(settings), SHARD_BALANCE_FACTOR_SETTING.get(settings));
+        setShardBalanceFactor(SHARD_BALANCE_FACTOR_SETTING.get(settings));
+        setIndexBalanceFactor(INDEX_BALANCE_FACTOR_SETTING.get(settings));
+        setPreferPrimaryShardRebalanceBuffer(PRIMARY_SHARD_REBALANCE_BUFFER.get(settings));
+        updateWeightFunction();
         setThreshold(THRESHOLD_SETTING.get(settings));
         setPreferPrimaryShardBalance(PREFER_PRIMARY_SHARD_BALANCE.get(settings));
+        setPreferPrimaryShardRebalance(PREFER_PRIMARY_SHARD_REBALANCE.get(settings));
         setShardMovementStrategy(SHARD_MOVEMENT_STRATEGY_SETTING.get(settings));
         clusterSettings.addSettingsUpdateConsumer(PREFER_PRIMARY_SHARD_BALANCE, this::setPreferPrimaryShardBalance);
         clusterSettings.addSettingsUpdateConsumer(SHARD_MOVE_PRIMARY_FIRST_SETTING, this::setMovePrimaryFirst);
         clusterSettings.addSettingsUpdateConsumer(SHARD_MOVEMENT_STRATEGY_SETTING, this::setShardMovementStrategy);
-        clusterSettings.addSettingsUpdateConsumer(INDEX_BALANCE_FACTOR_SETTING, SHARD_BALANCE_FACTOR_SETTING, this::setWeightFunction);
+        clusterSettings.addSettingsUpdateConsumer(INDEX_BALANCE_FACTOR_SETTING, this::updateIndexBalanceFactor);
+        clusterSettings.addSettingsUpdateConsumer(SHARD_BALANCE_FACTOR_SETTING, this::updateShardBalanceFactor);
+        clusterSettings.addSettingsUpdateConsumer(PRIMARY_SHARD_REBALANCE_BUFFER, this::updatePreferPrimaryShardBalanceBuffer);
+        clusterSettings.addSettingsUpdateConsumer(PREFER_PRIMARY_SHARD_REBALANCE, this::setPreferPrimaryShardRebalance);
         clusterSettings.addSettingsUpdateConsumer(THRESHOLD_SETTING, this::setThreshold);
     }
 
@@ -190,8 +218,35 @@ private void setShardMovementStrategy(ShardMovementStrategy shardMovementStrateg
         }
     }
 
-    private void setWeightFunction(float indexBalance, float shardBalanceFactor) {
-        weightFunction = new WeightFunction(indexBalance, shardBalanceFactor);
+    private void setIndexBalanceFactor(float indexBalanceFactor) {
+        this.indexBalanceFactor = indexBalanceFactor;
+    }
+
+    private void setShardBalanceFactor(float shardBalanceFactor) {
+        this.shardBalanceFactor = shardBalanceFactor;
+    }
+
+    private void setPreferPrimaryShardRebalanceBuffer(float preferPrimaryShardRebalanceBuffer) {
+        this.preferPrimaryShardRebalanceBuffer = preferPrimaryShardRebalanceBuffer;
+    }
+
+    private void updateIndexBalanceFactor(float indexBalanceFactor) {
+        this.indexBalanceFactor = indexBalanceFactor;
+        updateWeightFunction();
+    }
+
+    private void updateShardBalanceFactor(float shardBalanceFactor) {
+        this.shardBalanceFactor = shardBalanceFactor;
+        updateWeightFunction();
+    }
+
+    private void updatePreferPrimaryShardBalanceBuffer(float preferPrimaryShardBalanceBuffer) {
+        this.preferPrimaryShardRebalanceBuffer = preferPrimaryShardBalanceBuffer;
+        updateWeightFunction();
+    }
+
+    private void updateWeightFunction() {
+        weightFunction = new WeightFunction(this.indexBalanceFactor, this.shardBalanceFactor, this.preferPrimaryShardRebalanceBuffer);
     }
 
     /**
@@ -205,6 +260,11 @@ private void setPreferPrimaryShardBalance(boolean preferPrimaryShardBalance) {
         this.weightFunction.updateRebalanceConstraint(INDEX_PRIMARY_SHARD_BALANCE_CONSTRAINT_ID, preferPrimaryShardBalance);
     }
 
+    private void setPreferPrimaryShardRebalance(boolean preferPrimaryShardRebalance) {
+        this.preferPrimaryShardRebalance = preferPrimaryShardRebalance;
+        this.weightFunction.updateRebalanceConstraint(CLUSTER_PRIMARY_SHARD_REBALANCE_CONSTRAINT_ID, preferPrimaryShardRebalance);
+    }
+
     private void setThreshold(float threshold) {
         this.threshold = threshold;
     }
@@ -221,7 +281,8 @@ public void allocate(RoutingAllocation allocation) {
             shardMovementStrategy,
             weightFunction,
             threshold,
-            preferPrimaryShardBalance
+            preferPrimaryShardBalance,
+            preferPrimaryShardRebalance
         );
         localShardsBalancer.allocateUnassigned();
         localShardsBalancer.moveShards();
@@ -242,7 +303,8 @@ public ShardAllocationDecision decideShardAllocation(final ShardRouting shard, f
             shardMovementStrategy,
             weightFunction,
             threshold,
-            preferPrimaryShardBalance
+            preferPrimaryShardBalance,
+            preferPrimaryShardRebalance
         );
         AllocateUnassignedDecision allocateUnassignedDecision = AllocateUnassignedDecision.NOT_TAKEN;
         MoveDecision moveDecision = MoveDecision.NOT_TAKEN;
@@ -348,7 +410,7 @@ static class WeightFunction {
         private AllocationConstraints constraints;
         private RebalanceConstraints rebalanceConstraints;
 
-        WeightFunction(float indexBalance, float shardBalance) {
+        WeightFunction(float indexBalance, float shardBalance, float preferPrimaryBalanceBuffer) {
             float sum = indexBalance + shardBalance;
             if (sum <= 0.0f) {
                 throw new IllegalArgumentException("Balance factors must sum to a value > 0 but was: " + sum);
@@ -357,8 +419,9 @@ static class WeightFunction {
             theta1 = indexBalance / sum;
             this.indexBalance = indexBalance;
             this.shardBalance = shardBalance;
+            RebalanceParameter rebalanceParameter = new RebalanceParameter(preferPrimaryBalanceBuffer);
             this.constraints = new AllocationConstraints();
-            this.rebalanceConstraints = new RebalanceConstraints();
+            this.rebalanceConstraints = new RebalanceConstraints(rebalanceParameter);
             // Enable index shard per node breach constraint
             updateAllocationConstraint(INDEX_SHARD_PER_NODE_BREACH_CONSTRAINT_ID, true);
         }
@@ -495,7 +558,7 @@ public Balancer(
             float threshold,
             boolean preferPrimaryBalance
         ) {
-            super(logger, allocation, shardMovementStrategy, weight, threshold, preferPrimaryBalance);
+            super(logger, allocation, shardMovementStrategy, weight, threshold, preferPrimaryBalance, false);
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/LocalShardsBalancer.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/LocalShardsBalancer.java
index 45f64a5b29b04..ec25d041bda43 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/LocalShardsBalancer.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/LocalShardsBalancer.java
@@ -61,6 +61,7 @@ public class LocalShardsBalancer extends ShardsBalancer {
     private final ShardMovementStrategy shardMovementStrategy;
 
     private final boolean preferPrimaryBalance;
+    private final boolean preferPrimaryRebalance;
     private final BalancedShardsAllocator.WeightFunction weight;
 
     private final float threshold;
@@ -76,7 +77,8 @@ public LocalShardsBalancer(
         ShardMovementStrategy shardMovementStrategy,
         BalancedShardsAllocator.WeightFunction weight,
         float threshold,
-        boolean preferPrimaryBalance
+        boolean preferPrimaryBalance,
+        boolean preferPrimaryRebalance
     ) {
         this.logger = logger;
         this.allocation = allocation;
@@ -91,6 +93,7 @@ public LocalShardsBalancer(
         sorter = newNodeSorter();
         inEligibleTargetNode = new HashSet<>();
         this.preferPrimaryBalance = preferPrimaryBalance;
+        this.preferPrimaryRebalance = preferPrimaryRebalance;
         this.shardMovementStrategy = shardMovementStrategy;
     }
 
@@ -995,13 +998,18 @@ private boolean tryRelocateShard(BalancedShardsAllocator.ModelNode minNode, Bala
                     continue;
                 }
                 // This is a safety net which prevents un-necessary primary shard relocations from maxNode to minNode when
-                // doing such relocation wouldn't help in primary balance.
+                // doing such relocation wouldn't help in primary balance. The condition won't be applicable when we enable node level
+                // primary rebalance
                 if (preferPrimaryBalance == true
+                    && preferPrimaryRebalance == false
                     && shard.primary()
                     && maxNode.numPrimaryShards(shard.getIndexName()) - minNode.numPrimaryShards(shard.getIndexName()) < 2) {
                     continue;
                 }
-
+                // Relax the above condition to per node to allow rebalancing to attain global balance
+                if (preferPrimaryRebalance == true && shard.primary() && maxNode.numPrimaryShards() - minNode.numPrimaryShards() < 2) {
+                    continue;
+                }
                 final Decision decision = new Decision.Multi().add(allocationDecision).add(rebalanceDecision);
                 maxNode.removeShard(shard);
                 long shardSize = allocation.clusterInfo().getShardSize(shard, ShardRouting.UNAVAILABLE_EXPECTED_SHARD_SIZE);
diff --git a/server/src/main/java/org/opensearch/common/blobstore/BlobContainer.java b/server/src/main/java/org/opensearch/common/blobstore/BlobContainer.java
index 2e25a532b5abf..e16e75de7f27d 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/BlobContainer.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/BlobContainer.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.common.blobstore;
 
+import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.core.action.ActionListener;
 
 import java.io.IOException;
@@ -77,6 +78,20 @@ public interface BlobContainer {
      */
     InputStream readBlob(String blobName) throws IOException;
 
+    /**
+     * Creates a new {@link BlobDownloadResponse} for the given blob name.
+     *
+     * @param   blobName
+     *          The name of the blob to get an {@link InputStream} for.
+     * @return  The {@link BlobDownloadResponse} of the blob.
+     * @throws  NoSuchFileException if the blob does not exist
+     * @throws  IOException if the blob can not be read.
+     */
+    @ExperimentalApi
+    default BlobDownloadResponse readBlobWithMetadata(String blobName) throws IOException {
+        throw new UnsupportedOperationException("readBlobWithMetadata is not implemented yet");
+    };
+
     /**
      * Creates a new {@link InputStream} that can be used to read the given blob starting from
      * a specific {@code position} in the blob. The {@code length} is an indication of the
@@ -128,6 +143,36 @@ default long readBlobPreferredLength() {
      */
     void writeBlob(String blobName, InputStream inputStream, long blobSize, boolean failIfAlreadyExists) throws IOException;
 
+    /**
+     * Reads blob content from the input stream and writes it to the container in a new blob with the given name, and metadata.
+     * This method assumes the container does not already contain a blob of the same blobName. If a blob by the
+     * same name already exists, the operation will fail and an {@link IOException} will be thrown.
+     *
+     * @param   blobName
+     *          The name of the blob to write the contents of the input stream to.
+     * @param   inputStream
+     *          The input stream from which to retrieve the bytes to write to the blob.
+     * @param   metadata
+     *          The metadata to be associate with the blob upload.
+     * @param   blobSize
+     *          The size of the blob to be written, in bytes.  It is implementation dependent whether
+     *          this value is used in writing the blob to the repository.
+     * @param   failIfAlreadyExists
+     *          whether to throw a FileAlreadyExistsException if the given blob already exists
+     * @throws  FileAlreadyExistsException if failIfAlreadyExists is true and a blob by the same name already exists
+     * @throws  IOException if the input stream could not be read, or the target blob could not be written to.
+     */
+    @ExperimentalApi
+    default void writeBlobWithMetadata(
+        String blobName,
+        InputStream inputStream,
+        Map<String, String> metadata,
+        long blobSize,
+        boolean failIfAlreadyExists
+    ) throws IOException {
+        throw new UnsupportedOperationException("writeBlobWithMetadata is not implemented yet");
+    };
+
     /**
      * Reads blob content from the input stream and writes it to the container in a new blob with the given name,
      * using an atomic write operation if the implementation supports it.
@@ -149,6 +194,38 @@ default long readBlobPreferredLength() {
      */
     void writeBlobAtomic(String blobName, InputStream inputStream, long blobSize, boolean failIfAlreadyExists) throws IOException;
 
+    /**
+     * Reads blob content from the input stream and writes it to the container in a new blob with the given name, and metadata
+     * using an atomic write operation if the implementation supports it.
+     * <p>
+     * This method assumes the container does not already contain a blob of the same blobName. If a blob by the
+     * same name already exists, the operation will fail and an {@link IOException} will be thrown.
+     *
+     * @param   blobName
+     *          The name of the blob to write the contents of the input stream to.
+     * @param   inputStream
+     *          The input stream from which to retrieve the bytes to write to the blob.
+     * @param   metadata
+     *          The metadata to be associate with the blob upload.
+     * @param   blobSize
+     *          The size of the blob to be written, in bytes.  It is implementation dependent whether
+     *          this value is used in writing the blob to the repository.
+     * @param   failIfAlreadyExists
+     *          whether to throw a FileAlreadyExistsException if the given blob already exists
+     * @throws  FileAlreadyExistsException if failIfAlreadyExists is true and a blob by the same name already exists
+     * @throws  IOException if the input stream could not be read, or the target blob could not be written to.
+     */
+    @ExperimentalApi
+    default void writeBlobAtomicWithMetadata(
+        String blobName,
+        InputStream inputStream,
+        Map<String, String> metadata,
+        long blobSize,
+        boolean failIfAlreadyExists
+    ) throws IOException {
+        throw new UnsupportedOperationException("writeBlobAtomicWithMetadata is not implemented yet");
+    };
+
     /**
      * Deletes this container and all its contents from the repository.
      *
diff --git a/server/src/main/java/org/opensearch/common/blobstore/BlobDownloadResponse.java b/server/src/main/java/org/opensearch/common/blobstore/BlobDownloadResponse.java
new file mode 100644
index 0000000000000..97f3e4a16a76c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/blobstore/BlobDownloadResponse.java
@@ -0,0 +1,45 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.blobstore;
+
+import java.io.InputStream;
+import java.util.Map;
+
+/**
+ * Represents the response from a blob download operation, containing both the
+ * input stream of the blob content and the associated metadata.
+ *
+ * @opensearch.experimental
+ */
+public class BlobDownloadResponse {
+
+    /**
+     * Downloaded blob InputStream
+     */
+    private final InputStream inputStream;
+
+    /**
+     * Metadata of the downloaded blob
+     */
+    private final Map<String, String> metadata;
+
+    public InputStream getInputStream() {
+        return inputStream;
+    }
+
+    public Map<String, String> getMetadata() {
+        return metadata;
+    }
+
+    public BlobDownloadResponse(InputStream inputStream, Map<String, String> metadata) {
+        this.inputStream = inputStream;
+        this.metadata = metadata;
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/common/blobstore/stream/read/ReadContext.java b/server/src/main/java/org/opensearch/common/blobstore/stream/read/ReadContext.java
index 1264551401b4c..36ee46c0fc2c8 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/stream/read/ReadContext.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/stream/read/ReadContext.java
@@ -12,6 +12,7 @@
 import org.opensearch.common.io.InputStreamContainer;
 
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Supplier;
 
@@ -25,23 +26,30 @@ public class ReadContext {
     private final long blobSize;
     private final List<StreamPartCreator> asyncPartStreams;
     private final String blobChecksum;
+    private final Map<String, String> metadata;
 
-    public ReadContext(long blobSize, List<StreamPartCreator> asyncPartStreams, String blobChecksum) {
+    private ReadContext(long blobSize, List<StreamPartCreator> asyncPartStreams, String blobChecksum, Map<String, String> metadata) {
         this.blobSize = blobSize;
         this.asyncPartStreams = asyncPartStreams;
         this.blobChecksum = blobChecksum;
+        this.metadata = metadata;
     }
 
     public ReadContext(ReadContext readContext) {
         this.blobSize = readContext.blobSize;
         this.asyncPartStreams = readContext.asyncPartStreams;
         this.blobChecksum = readContext.blobChecksum;
+        this.metadata = readContext.metadata;
     }
 
     public String getBlobChecksum() {
         return blobChecksum;
     }
 
+    public Map<String, String> getMetadata() {
+        return metadata;
+    }
+
     public int getNumberOfParts() {
         return asyncPartStreams.size();
     }
@@ -64,7 +72,7 @@ public List<StreamPartCreator> getPartStreams() {
     @ExperimentalApi
     public interface StreamPartCreator extends Supplier<CompletableFuture<InputStreamContainer>> {
         /**
-         * Kicks off a async process to start streaming.
+         * Kicks off an async process to start streaming.
          *
          * @return When the returned future is completed, streaming has
          * just begun. Clients must fully consume the resulting stream.
@@ -72,4 +80,36 @@ public interface StreamPartCreator extends Supplier<CompletableFuture<InputStrea
         @Override
         CompletableFuture<InputStreamContainer> get();
     }
+
+    /**
+     * Builder for {@link ReadContext}.
+     *
+     * @opensearch.experimental
+     */
+    public static class Builder {
+        private final long blobSize;
+        private final List<StreamPartCreator> asyncPartStreams;
+        private String blobChecksum;
+        private Map<String, String> metadata;
+
+        public Builder(long blobSize, List<StreamPartCreator> asyncPartStreams) {
+            this.blobSize = blobSize;
+            this.asyncPartStreams = asyncPartStreams;
+        }
+
+        public Builder blobChecksum(String blobChecksum) {
+            this.blobChecksum = blobChecksum;
+            return this;
+        }
+
+        public Builder metadata(Map<String, String> metadata) {
+            this.metadata = metadata;
+            return this;
+        }
+
+        public ReadContext build() {
+            return new ReadContext(blobSize, asyncPartStreams, blobChecksum, metadata);
+        }
+
+    }
 }
diff --git a/server/src/main/java/org/opensearch/common/blobstore/stream/write/WriteContext.java b/server/src/main/java/org/opensearch/common/blobstore/stream/write/WriteContext.java
index e74462f82400d..d14800e82e495 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/stream/write/WriteContext.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/stream/write/WriteContext.java
@@ -13,6 +13,7 @@
 import org.opensearch.common.StreamContext;
 
 import java.io.IOException;
+import java.util.Map;
 
 /**
  * WriteContext is used to encapsulate all data needed by <code>BlobContainer#writeStreams</code>
@@ -29,6 +30,7 @@ public class WriteContext {
     private final CheckedConsumer<Boolean, IOException> uploadFinalizer;
     private final boolean doRemoteDataIntegrityCheck;
     private final Long expectedChecksum;
+    private final Map<String, String> metadata;
 
     /**
      * Construct a new WriteContext object
@@ -41,7 +43,7 @@ public class WriteContext {
      * @param doRemoteDataIntegrityCheck A boolean to inform vendor plugins whether remote data integrity checks need to be done
      * @param expectedChecksum           This parameter expected only when the vendor plugin is expected to do server side data integrity verification
      */
-    public WriteContext(
+    private WriteContext(
         String fileName,
         StreamContextSupplier streamContextSupplier,
         long fileSize,
@@ -49,7 +51,8 @@ public WriteContext(
         WritePriority writePriority,
         CheckedConsumer<Boolean, IOException> uploadFinalizer,
         boolean doRemoteDataIntegrityCheck,
-        @Nullable Long expectedChecksum
+        @Nullable Long expectedChecksum,
+        Map<String, String> metadata
     ) {
         this.fileName = fileName;
         this.streamContextSupplier = streamContextSupplier;
@@ -59,6 +62,7 @@ public WriteContext(
         this.uploadFinalizer = uploadFinalizer;
         this.doRemoteDataIntegrityCheck = doRemoteDataIntegrityCheck;
         this.expectedChecksum = expectedChecksum;
+        this.metadata = metadata;
     }
 
     /**
@@ -73,6 +77,7 @@ protected WriteContext(WriteContext writeContext) {
         this.uploadFinalizer = writeContext.uploadFinalizer;
         this.doRemoteDataIntegrityCheck = writeContext.doRemoteDataIntegrityCheck;
         this.expectedChecksum = writeContext.expectedChecksum;
+        this.metadata = writeContext.metadata;
     }
 
     /**
@@ -131,4 +136,87 @@ public boolean doRemoteDataIntegrityCheck() {
     public Long getExpectedChecksum() {
         return expectedChecksum;
     }
+
+    /**
+     * @return the upload metadata.
+     */
+    public Map<String, String> getMetadata() {
+        return metadata;
+    }
+
+    /**
+     * Builder for {@link WriteContext}.
+     *
+     * @opensearch.internal
+     */
+    public static class Builder {
+        private String fileName;
+        private StreamContextSupplier streamContextSupplier;
+        private long fileSize;
+        private boolean failIfAlreadyExists;
+        private WritePriority writePriority;
+        private CheckedConsumer<Boolean, IOException> uploadFinalizer;
+        private boolean doRemoteDataIntegrityCheck;
+        private Long expectedChecksum;
+        private Map<String, String> metadata;
+
+        public Builder fileName(String fileName) {
+            this.fileName = fileName;
+            return this;
+        }
+
+        public Builder streamContextSupplier(StreamContextSupplier streamContextSupplier) {
+            this.streamContextSupplier = streamContextSupplier;
+            return this;
+        }
+
+        public Builder fileSize(long fileSize) {
+            this.fileSize = fileSize;
+            return this;
+        }
+
+        public Builder writePriority(WritePriority writePriority) {
+            this.writePriority = writePriority;
+            return this;
+        }
+
+        public Builder failIfAlreadyExists(boolean failIfAlreadyExists) {
+            this.failIfAlreadyExists = failIfAlreadyExists;
+            return this;
+        }
+
+        public Builder uploadFinalizer(CheckedConsumer<Boolean, IOException> uploadFinalizer) {
+            this.uploadFinalizer = uploadFinalizer;
+            return this;
+        }
+
+        public Builder doRemoteDataIntegrityCheck(boolean doRemoteDataIntegrityCheck) {
+            this.doRemoteDataIntegrityCheck = doRemoteDataIntegrityCheck;
+            return this;
+        }
+
+        public Builder expectedChecksum(Long expectedChecksum) {
+            this.expectedChecksum = expectedChecksum;
+            return this;
+        }
+
+        public Builder metadata(Map<String, String> metadata) {
+            this.metadata = metadata;
+            return this;
+        }
+
+        public WriteContext build() {
+            return new WriteContext(
+                fileName,
+                streamContextSupplier,
+                fileSize,
+                failIfAlreadyExists,
+                writePriority,
+                uploadFinalizer,
+                doRemoteDataIntegrityCheck,
+                expectedChecksum,
+                metadata
+            );
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/common/blobstore/transfer/RemoteTransferContainer.java b/server/src/main/java/org/opensearch/common/blobstore/transfer/RemoteTransferContainer.java
index 2047c99d9e13b..cd2ef22327ebb 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/transfer/RemoteTransferContainer.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/transfer/RemoteTransferContainer.java
@@ -27,6 +27,7 @@
 import java.io.Closeable;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Supplier;
@@ -55,6 +56,7 @@ public class RemoteTransferContainer implements Closeable {
     private final OffsetRangeInputStreamSupplier offsetRangeInputStreamSupplier;
     private final boolean isRemoteDataIntegritySupported;
     private final AtomicBoolean readBlock = new AtomicBoolean();
+    private final Map<String, String> metadata;
 
     private static final Logger log = LogManager.getLogger(RemoteTransferContainer.class);
 
@@ -79,6 +81,43 @@ public RemoteTransferContainer(
         OffsetRangeInputStreamSupplier offsetRangeInputStreamSupplier,
         long expectedChecksum,
         boolean isRemoteDataIntegritySupported
+    ) {
+        this(
+            fileName,
+            remoteFileName,
+            contentLength,
+            failTransferIfFileExists,
+            writePriority,
+            offsetRangeInputStreamSupplier,
+            expectedChecksum,
+            isRemoteDataIntegritySupported,
+            null
+        );
+    }
+
+    /**
+     * Construct a new RemoteTransferContainer object with metadata.
+     *
+     * @param fileName                       Name of the local file
+     * @param remoteFileName                 Name of the remote file
+     * @param contentLength                  Total content length of the file to be uploaded
+     * @param failTransferIfFileExists       A boolean to determine if upload has to be failed if file exists
+     * @param writePriority                  The {@link WritePriority} of current upload
+     * @param offsetRangeInputStreamSupplier A supplier to create OffsetRangeInputStreams
+     * @param expectedChecksum               The expected checksum value for the file being uploaded. This checksum will be used for local or remote data integrity checks
+     * @param isRemoteDataIntegritySupported A boolean to signify whether the remote repository supports server side data integrity verification
+     * @param metadata                       Object metadata to be store with the file.
+     */
+    public RemoteTransferContainer(
+        String fileName,
+        String remoteFileName,
+        long contentLength,
+        boolean failTransferIfFileExists,
+        WritePriority writePriority,
+        OffsetRangeInputStreamSupplier offsetRangeInputStreamSupplier,
+        long expectedChecksum,
+        boolean isRemoteDataIntegritySupported,
+        Map<String, String> metadata
     ) {
         this.fileName = fileName;
         this.remoteFileName = remoteFileName;
@@ -88,22 +127,23 @@ public RemoteTransferContainer(
         this.offsetRangeInputStreamSupplier = offsetRangeInputStreamSupplier;
         this.expectedChecksum = expectedChecksum;
         this.isRemoteDataIntegritySupported = isRemoteDataIntegritySupported;
+        this.metadata = metadata;
     }
 
     /**
      * @return The {@link  WriteContext} for the current upload
      */
     public WriteContext createWriteContext() {
-        return new WriteContext(
-            remoteFileName,
-            this::supplyStreamContext,
-            contentLength,
-            failTransferIfFileExists,
-            writePriority,
-            this::finalizeUpload,
-            isRemoteDataIntegrityCheckPossible(),
-            isRemoteDataIntegrityCheckPossible() ? expectedChecksum : null
-        );
+        return new WriteContext.Builder().fileName(remoteFileName)
+            .streamContextSupplier(this::supplyStreamContext)
+            .fileSize(contentLength)
+            .failIfAlreadyExists(failTransferIfFileExists)
+            .writePriority(writePriority)
+            .uploadFinalizer(this::finalizeUpload)
+            .doRemoteDataIntegrityCheck(isRemoteDataIntegrityCheckPossible())
+            .expectedChecksum(isRemoteDataIntegrityCheckPossible() ? expectedChecksum : null)
+            .metadata(metadata)
+            .build();
     }
 
     // package-private for testing
diff --git a/server/src/main/java/org/opensearch/common/hash/FNV1a.java b/server/src/main/java/org/opensearch/common/hash/FNV1a.java
new file mode 100644
index 0000000000000..cab28d0f2d68f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/hash/FNV1a.java
@@ -0,0 +1,48 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.hash;
+
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Provides hashing function using FNV1a hash function. @see <a href="http://www.isthe.com/chongo/tech/comp/fnv/#FNV-1">FNV author's website</a>.
+ * 32 bit Java port of http://www.isthe.com/chongo/src/fnv/hash_32a.c
+ * 64 bit Java port of http://www.isthe.com/chongo/src/fnv/hash_64a.c
+ *
+ * @opensearch.internal
+ */
+public class FNV1a {
+    private static final long FNV_OFFSET_BASIS_32 = 0x811c9dc5L;
+    private static final long FNV_PRIME_32 = 0x01000193L;
+
+    private static final long FNV_OFFSET_BASIS_64 = 0xcbf29ce484222325L;
+    private static final long FNV_PRIME_64 = 0x100000001b3L;
+
+    // FNV-1a hash computation for 32-bit hash
+    public static long hash32(String input) {
+        long hash = FNV_OFFSET_BASIS_32;
+        byte[] bytes = input.getBytes(StandardCharsets.UTF_8);
+        for (byte b : bytes) {
+            hash ^= (b & 0xFF);
+            hash *= FNV_PRIME_32;
+        }
+        return hash;
+    }
+
+    // FNV-1a hash computation for 64-bit hash
+    public static long hash64(String input) {
+        long hash = FNV_OFFSET_BASIS_64;
+        byte[] bytes = input.getBytes(StandardCharsets.UTF_8);
+        for (byte b : bytes) {
+            hash ^= (b & 0xFF);
+            hash *= FNV_PRIME_64;
+        }
+        return hash;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
index 8760ee3c94309..9d763c970c3e7 100644
--- a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
@@ -252,7 +252,9 @@ public void apply(Settings value, Settings current, Settings previous) {
                 AwarenessReplicaBalance.CLUSTER_ROUTING_ALLOCATION_AWARENESS_BALANCE_SETTING,
                 BalancedShardsAllocator.INDEX_BALANCE_FACTOR_SETTING,
                 BalancedShardsAllocator.SHARD_BALANCE_FACTOR_SETTING,
+                BalancedShardsAllocator.PRIMARY_SHARD_REBALANCE_BUFFER,
                 BalancedShardsAllocator.PREFER_PRIMARY_SHARD_BALANCE,
+                BalancedShardsAllocator.PREFER_PRIMARY_SHARD_REBALANCE,
                 BalancedShardsAllocator.SHARD_MOVE_PRIMARY_FIRST_SETTING,
                 BalancedShardsAllocator.SHARD_MOVEMENT_STRATEGY_SETTING,
                 BalancedShardsAllocator.THRESHOLD_SETTING,
@@ -725,7 +727,8 @@ public void apply(Settings value, Settings current, Settings previous) {
                 SearchService.CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_SETTING,
 
                 RemoteStoreSettings.CLUSTER_REMOTE_INDEX_SEGMENT_METADATA_RETENTION_MAX_COUNT_SETTING,
-                RemoteStoreSettings.CLUSTER_REMOTE_TRANSLOG_BUFFER_INTERVAL_SETTING
+                RemoteStoreSettings.CLUSTER_REMOTE_TRANSLOG_BUFFER_INTERVAL_SETTING,
+                RemoteStoreSettings.CLUSTER_REMOTE_TRANSLOG_TRANSFER_TIMEOUT_SETTING
             )
         )
     );
diff --git a/server/src/main/java/org/opensearch/index/IndexService.java b/server/src/main/java/org/opensearch/index/IndexService.java
index 03cf8f9182211..a7b29314210df 100644
--- a/server/src/main/java/org/opensearch/index/IndexService.java
+++ b/server/src/main/java/org/opensearch/index/IndexService.java
@@ -44,6 +44,7 @@
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.CheckedFunction;
@@ -462,7 +463,8 @@ public synchronized IndexShard createShard(
         final RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
         final RepositoriesService repositoriesService,
         final DiscoveryNode targetNode,
-        @Nullable DiscoveryNode sourceNode
+        @Nullable DiscoveryNode sourceNode,
+        DiscoveryNodes discoveryNodes
     ) throws IOException {
         Objects.requireNonNull(retentionLeaseSyncer);
         /*
@@ -509,7 +511,7 @@ public synchronized IndexShard createShard(
                         RemoteStoreNodeAttribute.getRemoteStoreSegmentRepo(this.indexSettings.getNodeSettings()),
                         this.indexSettings.getUUID(),
                         shardId,
-                        this.indexSettings.getRemoteStorePathType()
+                        this.indexSettings.getRemoteStorePathStrategy()
                     );
                 }
                 remoteStore = new Store(shardId, this.indexSettings, remoteDirectory, lock, Store.OnClose.EMPTY, path);
@@ -553,7 +555,8 @@ public synchronized IndexShard createShard(
                 nodeEnv.nodeId(),
                 recoverySettings,
                 remoteStoreSettings,
-                seedRemote
+                seedRemote,
+                discoveryNodes
             );
             eventListener.indexShardStateChanged(indexShard, null, indexShard.state(), "shard created");
             eventListener.afterIndexShardCreated(indexShard);
diff --git a/server/src/main/java/org/opensearch/index/IndexSettings.java b/server/src/main/java/org/opensearch/index/IndexSettings.java
index 7e3d812974c79..388de65ca58a1 100644
--- a/server/src/main/java/org/opensearch/index/IndexSettings.java
+++ b/server/src/main/java/org/opensearch/index/IndexSettings.java
@@ -48,7 +48,9 @@
 import org.opensearch.core.common.unit.ByteSizeUnit;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.core.index.Index;
-import org.opensearch.index.remote.RemoteStorePathType;
+import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.index.translog.Translog;
 import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.ingest.IngestService;
@@ -61,6 +63,7 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
@@ -761,6 +764,8 @@ public static IndexMergePolicy fromString(String text) {
 
     private volatile String defaultSearchPipeline;
     private final boolean widenIndexSortType;
+    private final boolean assignedOnRemoteNode;
+    private final RemoteStorePathStrategy remoteStorePathStrategy;
 
     /**
      * The maximum age of a retention lease before it is considered expired.
@@ -984,6 +989,8 @@ public IndexSettings(final IndexMetadata indexMetadata, final Settings nodeSetti
          * Now this sortField (IndexSort) is stored in SegmentInfo and we need to maintain backward compatibility for them.
          */
         widenIndexSortType = IndexMetadata.SETTING_INDEX_VERSION_CREATED.get(settings).before(V_2_7_0);
+        assignedOnRemoteNode = RemoteStoreNodeAttribute.isRemoteDataAttributePresent(this.getNodeSettings());
+        remoteStorePathStrategy = determineRemoteStorePathStrategy();
 
         setEnableFuzzySetForDocId(scopedSettings.get(INDEX_DOC_ID_FUZZY_SET_ENABLED_SETTING));
         setDocIdFuzzySetFalsePositiveProbability(scopedSettings.get(INDEX_DOC_ID_FUZZY_SET_FALSE_POSITIVE_PROBABILITY_SETTING));
@@ -1229,15 +1236,11 @@ public int getNumberOfReplicas() {
      * proper index setting during the migration.
      */
     public boolean isSegRepEnabledOrRemoteNode() {
-        return ReplicationType.SEGMENT.equals(replicationType) || isRemoteNode();
+        return ReplicationType.SEGMENT.equals(replicationType) || isAssignedOnRemoteNode();
     }
 
     public boolean isSegRepLocalEnabled() {
-        return isSegRepEnabledOrRemoteNode() && !isRemoteStoreEnabled();
-    }
-
-    public boolean isSegRepWithRemoteEnabled() {
-        return isSegRepEnabledOrRemoteNode() && isRemoteStoreEnabled();
+        return ReplicationType.SEGMENT.equals(replicationType) && !isRemoteStoreEnabled();
     }
 
     /**
@@ -1247,8 +1250,8 @@ public boolean isRemoteStoreEnabled() {
         return isRemoteStoreEnabled;
     }
 
-    public boolean isRemoteNode() {
-        return RemoteStoreNodeAttribute.isRemoteDataAttributePresent(this.getNodeSettings());
+    public boolean isAssignedOnRemoteNode() {
+        return assignedOnRemoteNode;
     }
 
     /**
@@ -1908,10 +1911,19 @@ public void setDocIdFuzzySetFalsePositiveProbability(double docIdFuzzySetFalsePo
         this.docIdFuzzySetFalsePositiveProbability = docIdFuzzySetFalsePositiveProbability;
     }
 
-    public RemoteStorePathType getRemoteStorePathType() {
+    private RemoteStorePathStrategy determineRemoteStorePathStrategy() {
         Map<String, String> remoteCustomData = indexMetadata.getCustomData(IndexMetadata.REMOTE_STORE_CUSTOM_KEY);
-        return remoteCustomData != null && remoteCustomData.containsKey(RemoteStorePathType.NAME)
-            ? RemoteStorePathType.parseString(remoteCustomData.get(RemoteStorePathType.NAME))
-            : RemoteStorePathType.FIXED;
+        assert remoteCustomData == null || remoteCustomData.containsKey(PathType.NAME);
+        if (remoteCustomData != null && remoteCustomData.containsKey(PathType.NAME)) {
+            PathType pathType = PathType.parseString(remoteCustomData.get(PathType.NAME));
+            String hashAlgoStr = remoteCustomData.get(PathHashAlgorithm.NAME);
+            PathHashAlgorithm hashAlgorithm = Objects.nonNull(hashAlgoStr) ? PathHashAlgorithm.parseString(hashAlgoStr) : null;
+            return new RemoteStorePathStrategy(pathType, hashAlgorithm);
+        }
+        return new RemoteStorePathStrategy(PathType.FIXED);
+    }
+
+    public RemoteStorePathStrategy getRemoteStorePathStrategy() {
+        return remoteStorePathStrategy;
     }
 }
diff --git a/server/src/main/java/org/opensearch/index/engine/NRTReplicationEngine.java b/server/src/main/java/org/opensearch/index/engine/NRTReplicationEngine.java
index 1e1825e1f8ace..d759423ce5a55 100644
--- a/server/src/main/java/org/opensearch/index/engine/NRTReplicationEngine.java
+++ b/server/src/main/java/org/opensearch/index/engine/NRTReplicationEngine.java
@@ -437,7 +437,7 @@ protected final void closeNoLock(String reason, CountDownLatch closedLatch) {
                  during promotion.
                  */
                 if (engineConfig.getIndexSettings().isRemoteStoreEnabled() == false
-                    && engineConfig.getIndexSettings().isRemoteNode() == false) {
+                    && engineConfig.getIndexSettings().isAssignedOnRemoteNode() == false) {
                     latestSegmentInfos.counter = latestSegmentInfos.counter + SI_COUNTER_INCREMENT;
                     latestSegmentInfos.changed();
                 }
diff --git a/server/src/main/java/org/opensearch/index/mapper/ConstantKeywordFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/ConstantKeywordFieldMapper.java
new file mode 100644
index 0000000000000..f4730c70362d1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/ConstantKeywordFieldMapper.java
@@ -0,0 +1,191 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.search.MatchAllDocsQuery;
+import org.apache.lucene.search.Query;
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.regex.Regex;
+import org.opensearch.index.fielddata.IndexFieldData;
+import org.opensearch.index.fielddata.plain.ConstantIndexFieldData;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.search.aggregations.support.CoreValuesSourceType;
+import org.opensearch.search.lookup.SearchLookup;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Supplier;
+
+/**
+ * Index specific field mapper
+ *
+ * @opensearch.api
+ */
+@PublicApi(since = "2.14.0")
+public class ConstantKeywordFieldMapper extends ParametrizedFieldMapper {
+
+    public static final String CONTENT_TYPE = "constant_keyword";
+
+    private static final String valuePropertyName = "value";
+
+    /**
+     * A {@link Mapper.TypeParser} for the constant keyword field.
+     *
+     * @opensearch.internal
+     */
+    public static class TypeParser implements Mapper.TypeParser {
+        @Override
+        public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException {
+            if (!node.containsKey(valuePropertyName)) {
+                throw new OpenSearchParseException("Field [" + name + "] is missing required parameter [value]");
+            }
+            Object value = node.remove(valuePropertyName);
+            if (!(value instanceof String)) {
+                throw new OpenSearchParseException("Field [" + name + "] is expected to be a string value");
+            }
+            return new Builder(name, (String) value);
+        }
+    }
+
+    private static ConstantKeywordFieldMapper toType(FieldMapper in) {
+        return (ConstantKeywordFieldMapper) in;
+    }
+
+    /**
+     * Builder for the binary field mapper
+     *
+     * @opensearch.internal
+     */
+    public static class Builder extends ParametrizedFieldMapper.Builder {
+
+        private final Parameter<String> value;
+
+        public Builder(String name, String value) {
+            super(name);
+            this.value = Parameter.stringParam(valuePropertyName, false, m -> toType(m).value, value);
+        }
+
+        @Override
+        public List<Parameter<?>> getParameters() {
+            return Arrays.asList(value);
+        }
+
+        @Override
+        public ConstantKeywordFieldMapper build(BuilderContext context) {
+            return new ConstantKeywordFieldMapper(
+                name,
+                new ConstantKeywordFieldMapper.ConstantKeywordFieldType(buildFullName(context), value.getValue()),
+                multiFieldsBuilder.build(this, context),
+                copyTo.build(),
+                this
+            );
+        }
+    }
+
+    /**
+     * Field type for Index field mapper
+     *
+     * @opensearch.internal
+     */
+    @PublicApi(since = "2.14.0")
+    protected static final class ConstantKeywordFieldType extends ConstantFieldType {
+
+        protected final String value;
+
+        public ConstantKeywordFieldType(String name, String value) {
+            super(name, Collections.emptyMap());
+            this.value = value;
+        }
+
+        @Override
+        public String typeName() {
+            return CONTENT_TYPE;
+        }
+
+        @Override
+        protected boolean matches(String pattern, boolean caseInsensitive, QueryShardContext context) {
+            return Regex.simpleMatch(pattern, value, caseInsensitive);
+        }
+
+        @Override
+        public Query existsQuery(QueryShardContext context) {
+            return new MatchAllDocsQuery();
+        }
+
+        @Override
+        public IndexFieldData.Builder fielddataBuilder(String fullyQualifiedIndexName, Supplier<SearchLookup> searchLookup) {
+            return new ConstantIndexFieldData.Builder(fullyQualifiedIndexName, name(), CoreValuesSourceType.BYTES);
+        }
+
+        @Override
+        public ValueFetcher valueFetcher(QueryShardContext context, SearchLookup searchLookup, String format) {
+            if (format != null) {
+                throw new IllegalArgumentException("Field [" + name() + "] of type [" + typeName() + "] doesn't " + "support formats.");
+            }
+
+            return new SourceValueFetcher(name(), context) {
+                @Override
+                protected Object parseSourceValue(Object value) {
+                    String keywordValue = value.toString();
+                    return Collections.singletonList(keywordValue);
+                }
+            };
+        }
+    }
+
+    private final String value;
+
+    protected ConstantKeywordFieldMapper(
+        String simpleName,
+        MappedFieldType mappedFieldType,
+        MultiFields multiFields,
+        CopyTo copyTo,
+        ConstantKeywordFieldMapper.Builder builder
+    ) {
+        super(simpleName, mappedFieldType, multiFields, copyTo);
+        this.value = builder.value.getValue();
+    }
+
+    public ParametrizedFieldMapper.Builder getMergeBuilder() {
+        return new ConstantKeywordFieldMapper.Builder(simpleName(), this.value).init(this);
+    }
+
+    @Override
+    protected void parseCreateField(ParseContext context) throws IOException {
+
+        final String value;
+        if (context.externalValueSet()) {
+            value = context.externalValue().toString();
+        } else {
+            value = context.parser().textOrNull();
+        }
+        if (value == null) {
+            throw new IllegalArgumentException("constant keyword field [" + name() + "] must have a value");
+        }
+
+        if (!value.equals(fieldType().value)) {
+            throw new IllegalArgumentException("constant keyword field [" + name() + "] must have a value of [" + this.value + "]");
+        }
+
+    }
+
+    @Override
+    public ConstantKeywordFieldMapper.ConstantKeywordFieldType fieldType() {
+        return (ConstantKeywordFieldMapper.ConstantKeywordFieldType) super.fieldType();
+    }
+
+    @Override
+    protected String contentType() {
+        return CONTENT_TYPE;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldMapper.java
new file mode 100644
index 0000000000000..b448487a4f810
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldMapper.java
@@ -0,0 +1,129 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.index.IndexableField;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.script.Script;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+
+/**
+ * A field mapper for derived fields
+ *
+ * @opensearch.internal
+ */
+public class DerivedFieldMapper extends ParametrizedFieldMapper {
+
+    public static final String CONTENT_TYPE = "derived";
+
+    private static DerivedFieldMapper toType(FieldMapper in) {
+        return (DerivedFieldMapper) in;
+    }
+
+    /**
+     * Builder for this field mapper
+     *
+     * @opensearch.internal
+     */
+    public static class Builder extends ParametrizedFieldMapper.Builder {
+        // TODO: The type of parameter may change here if the actual underlying FieldType object is needed
+        private final Parameter<String> type = Parameter.stringParam("type", false, m -> toType(m).type, "text");
+
+        private final Parameter<Script> script = new Parameter<>(
+            "script",
+            false,
+            () -> null,
+            (n, c, o) -> o == null ? null : Script.parse(o),
+            m -> toType(m).script
+        ).setSerializerCheck((id, ic, value) -> value != null);
+
+        public Builder(String name) {
+            super(name);
+        }
+
+        @Override
+        protected List<Parameter<?>> getParameters() {
+            return Arrays.asList(type, script);
+        }
+
+        @Override
+        public DerivedFieldMapper build(BuilderContext context) {
+            FieldMapper fieldMapper = DerivedFieldSupportedTypes.getFieldMapperFromType(type.getValue(), name, context);
+            Function<Object, IndexableField> fieldFunction = DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(
+                type.getValue(),
+                name
+            );
+            DerivedFieldType ft = new DerivedFieldType(
+                buildFullName(context),
+                type.getValue(),
+                script.getValue(),
+                fieldMapper,
+                fieldFunction
+            );
+            return new DerivedFieldMapper(name, ft, multiFieldsBuilder.build(this, context), copyTo.build(), this);
+        }
+    }
+
+    public static final TypeParser PARSER = new TypeParser((n, c) -> new Builder(n));
+    private final String type;
+    private final Script script;
+
+    protected DerivedFieldMapper(
+        String simpleName,
+        MappedFieldType mappedFieldType,
+        MultiFields multiFields,
+        CopyTo copyTo,
+        Builder builder
+    ) {
+        super(simpleName, mappedFieldType, multiFields, copyTo);
+        this.type = builder.type.getValue();
+        this.script = builder.script.getValue();
+    }
+
+    @Override
+    public DerivedFieldType fieldType() {
+        return (DerivedFieldType) super.fieldType();
+    }
+
+    @Override
+    protected void parseCreateField(ParseContext context) throws IOException {
+        // Leaving this empty as the parsing should be handled via the Builder when root object is parsed.
+        // The context would not contain anything in this case since the DerivedFieldMapper is not indexed or stored.
+        throw new UnsupportedOperationException("should not be invoked");
+    }
+
+    @Override
+    public ParametrizedFieldMapper.Builder getMergeBuilder() {
+        return new Builder(simpleName()).init(this);
+    }
+
+    @Override
+    protected String contentType() {
+        return CONTENT_TYPE;
+    }
+
+    @Override
+    protected void doXContentBody(XContentBuilder builder, boolean includeDefaults, Params params) throws IOException {
+        getMergeBuilder().toXContent(builder, includeDefaults);
+        multiFields.toXContent(builder, params);
+        copyTo.toXContent(builder, params);
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public Script getScript() {
+        return script;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldValueFetcher.java b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldValueFetcher.java
index f3bf0c613415a..40aa2f9890965 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldValueFetcher.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldValueFetcher.java
@@ -31,8 +31,8 @@ public DerivedFieldValueFetcher(DerivedFieldScript.LeafFactory derivedFieldScrip
     @Override
     public List<Object> fetchValues(SourceLookup lookup) {
         derivedFieldScript.setDocument(lookup.docId());
-        // TODO: remove List.of() when derivedFieldScript.execute() returns list of objects.
-        return List.of(derivedFieldScript.execute());
+        derivedFieldScript.execute();
+        return derivedFieldScript.getEmittedValues();
     }
 
     public void setNextReader(LeafReaderContext context) {
diff --git a/server/src/main/java/org/opensearch/index/mapper/ObjectMapper.java b/server/src/main/java/org/opensearch/index/mapper/ObjectMapper.java
index 39b0ec224b57c..92ffdb60e6cde 100644
--- a/server/src/main/java/org/opensearch/index/mapper/ObjectMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/ObjectMapper.java
@@ -291,6 +291,15 @@ protected static boolean parseObjectOrDocumentTypeProperties(
             } else if (fieldName.equals("enabled")) {
                 builder.enabled(XContentMapValues.nodeBooleanValue(fieldNode, fieldName + ".enabled"));
                 return true;
+            } else if (fieldName.equals("derived")) {
+                if (fieldNode instanceof Collection && ((Collection) fieldNode).isEmpty()) {
+                    // nothing to do here, empty (to support "derived: []" case)
+                } else if (fieldNode instanceof Map) {
+                    parseDerived(builder, (Map<String, Object>) fieldNode, parserContext);
+                } else {
+                    throw new OpenSearchParseException("derived must be a map type");
+                }
+                return true;
             } else if (fieldName.equals("properties")) {
                 if (fieldNode instanceof Collection && ((Collection) fieldNode).isEmpty()) {
                     // nothing to do here, empty (to support "properties: []" case)
@@ -349,6 +358,55 @@ protected static void parseNested(
             }
         }
 
+        protected static void parseDerived(ObjectMapper.Builder objBuilder, Map<String, Object> derivedNode, ParserContext parserContext) {
+            Iterator<Map.Entry<String, Object>> iterator = derivedNode.entrySet().iterator();
+            while (iterator.hasNext()) {
+                Map.Entry<String, Object> entry = iterator.next();
+                String fieldName = entry.getKey();
+                // Should accept empty arrays, as a work around for when the
+                // user can't provide an empty Map. (PHP for example)
+                boolean isEmptyList = entry.getValue() instanceof List && ((List<?>) entry.getValue()).isEmpty();
+
+                if (entry.getValue() instanceof Map) {
+                    @SuppressWarnings("unchecked")
+                    Map<String, Object> node = (Map<String, Object>) entry.getValue();
+
+                    // Derived fields are a bit unique in that the 'type' attribute does not map to the TypeParser
+                    // like it would for traditional fields in properties.
+                    // So in this case, the DerivedFieldMapper's TypeParser will explicitly be used
+                    Mapper.TypeParser typeParser = parserContext.typeParser(DerivedFieldMapper.CONTENT_TYPE);
+                    String[] fieldNameParts = fieldName.split("\\.");
+                    // field name is just ".", which is invalid
+                    if (fieldNameParts.length < 1) {
+                        throw new MapperParsingException("Invalid field name " + fieldName);
+                    }
+                    String realFieldName = fieldNameParts[fieldNameParts.length - 1];
+                    Mapper.Builder<?> fieldBuilder = typeParser.parse(realFieldName, node, parserContext);
+                    for (int i = fieldNameParts.length - 2; i >= 0; --i) {
+                        ObjectMapper.Builder<?> intermediate = new ObjectMapper.Builder<>(fieldNameParts[i]);
+                        intermediate.add(fieldBuilder);
+                        fieldBuilder = intermediate;
+                    }
+                    objBuilder.add(fieldBuilder);
+                    node.remove("type");
+                    DocumentMapperParser.checkNoRemainingFields(fieldName, node, parserContext.indexVersionCreated());
+                    iterator.remove();
+                } else if (isEmptyList) {
+                    iterator.remove();
+                } else {
+                    throw new MapperParsingException(
+                        "Expected map for property [derived_fields] on field [" + fieldName + "] but got a " + fieldName.getClass()
+                    );
+                }
+            }
+
+            DocumentMapperParser.checkNoRemainingFields(
+                derivedNode,
+                parserContext.indexVersionCreated(),
+                "DocType mapping definition has unsupported parameters: "
+            );
+        }
+
         protected static void parseProperties(ObjectMapper.Builder objBuilder, Map<String, Object> propsNode, ParserContext parserContext) {
             Iterator<Map.Entry<String, Object>> iterator = propsNode.entrySet().iterator();
             while (iterator.hasNext()) {
@@ -663,7 +721,21 @@ public void toXContent(XContentBuilder builder, Params params, ToXContent custom
         doXContent(builder, params);
 
         // sort the mappers so we get consistent serialization format
-        Mapper[] sortedMappers = mappers.values().stream().toArray(size -> new Mapper[size]);
+        Mapper[] derivedSortedMappers = mappers.values()
+            .stream()
+            .filter(m -> m instanceof DerivedFieldMapper)
+            .toArray(size -> new Mapper[size]);
+        Arrays.sort(derivedSortedMappers, new Comparator<Mapper>() {
+            @Override
+            public int compare(Mapper o1, Mapper o2) {
+                return o1.name().compareTo(o2.name());
+            }
+        });
+
+        Mapper[] sortedMappers = mappers.values()
+            .stream()
+            .filter(m -> !(m instanceof DerivedFieldMapper))
+            .toArray(size -> new Mapper[size]);
         Arrays.sort(sortedMappers, new Comparator<Mapper>() {
             @Override
             public int compare(Mapper o1, Mapper o2) {
@@ -672,6 +744,17 @@ public int compare(Mapper o1, Mapper o2) {
         });
 
         int count = 0;
+        for (Mapper mapper : derivedSortedMappers) {
+            if (count++ == 0) {
+                builder.startObject("derived");
+            }
+            mapper.toXContent(builder, params);
+        }
+        if (count > 0) {
+            builder.endObject();
+        }
+
+        count = 0;
         for (Mapper mapper : sortedMappers) {
             if (!(mapper instanceof MetadataFieldMapper)) {
                 if (count++ == 0) {
diff --git a/server/src/main/java/org/opensearch/index/mapper/ParametrizedFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/ParametrizedFieldMapper.java
index f4723b6178137..4f4ec45001a54 100644
--- a/server/src/main/java/org/opensearch/index/mapper/ParametrizedFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/ParametrizedFieldMapper.java
@@ -670,7 +670,11 @@ public final void parse(String name, ParserContext parserContext, Map<String, Ob
                     deprecatedParamsMap.put(deprecatedName, param);
                 }
             }
-            String type = (String) fieldNode.remove("type");
+            String type = (String) fieldNode.get("type");
+            if (paramsMap.get("type") == null) {
+                fieldNode.remove("type");
+            }
+
             for (Iterator<Map.Entry<String, Object>> iterator = fieldNode.entrySet().iterator(); iterator.hasNext();) {
                 Map.Entry<String, Object> entry = iterator.next();
                 final String propName = entry.getKey();
diff --git a/server/src/main/java/org/opensearch/index/query/ExistsQueryBuilder.java b/server/src/main/java/org/opensearch/index/query/ExistsQueryBuilder.java
index 7fd83d5753512..3011a48fbb296 100644
--- a/server/src/main/java/org/opensearch/index/query/ExistsQueryBuilder.java
+++ b/server/src/main/java/org/opensearch/index/query/ExistsQueryBuilder.java
@@ -201,6 +201,11 @@ private static Query newObjectFieldExistsQuery(QueryShardContext context, String
         BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
         Collection<String> fields = context.simpleMatchToIndexNames(objField + ".*");
         for (String field : fields) {
+            int dotPos = field.lastIndexOf('.');
+            if (dotPos > 0 && field.charAt(dotPos + 1) == '_') {
+                // This is a subfield (e.g. prefix) of a complex field type. Skip it.
+                continue;
+            }
             Query existsQuery = context.getMapperService().fieldType(field).existsQuery(context);
             booleanQuery.add(existsQuery, Occur.SHOULD);
         }
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteStoreDataEnums.java b/server/src/main/java/org/opensearch/index/remote/RemoteStoreDataEnums.java
deleted file mode 100644
index 475e29004ba2e..0000000000000
--- a/server/src/main/java/org/opensearch/index/remote/RemoteStoreDataEnums.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.index.remote;
-
-import org.opensearch.common.annotation.PublicApi;
-
-import java.util.Set;
-
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataType.DATA;
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataType.METADATA;
-
-/**
- * This class contains the different enums related to remote store data categories and types.
- *
- * @opensearch.api
- */
-public class RemoteStoreDataEnums {
-
-    /**
-     * Categories of the data in Remote store.
-     */
-    @PublicApi(since = "2.14.0")
-    public enum DataCategory {
-        SEGMENTS("segments", Set.of(DataType.values())),
-        TRANSLOG("translog", Set.of(DATA, METADATA));
-
-        private final String name;
-        private final Set<DataType> supportedDataTypes;
-
-        DataCategory(String name, Set<DataType> supportedDataTypes) {
-            this.name = name;
-            this.supportedDataTypes = supportedDataTypes;
-        }
-
-        public boolean isSupportedDataType(DataType dataType) {
-            return supportedDataTypes.contains(dataType);
-        }
-
-        public String getName() {
-            return name;
-        }
-    }
-
-    /**
-     * Types of data in remote store.
-     */
-    @PublicApi(since = "2.14.0")
-    public enum DataType {
-        DATA("data"),
-        METADATA("metadata"),
-        LOCK_FILES("lock_files");
-
-        private final String name;
-
-        DataType(String name) {
-            this.name = name;
-        }
-
-        public String getName() {
-            return name;
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteStoreEnums.java b/server/src/main/java/org/opensearch/index/remote/RemoteStoreEnums.java
new file mode 100644
index 0000000000000..30cfc054e3d0a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/remote/RemoteStoreEnums.java
@@ -0,0 +1,260 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.remote;
+
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.hash.FNV1a;
+import org.opensearch.index.remote.RemoteStorePathStrategy.PathInput;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import static java.util.Collections.unmodifiableMap;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataType.DATA;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataType.METADATA;
+
+/**
+ * This class contains the different enums related to remote store like data categories and types, path types
+ * and hashing algorithm.
+ *
+ * @opensearch.api
+ */
+public class RemoteStoreEnums {
+
+    /**
+     * Categories of the data in Remote store.
+     */
+    @PublicApi(since = "2.14.0")
+    public enum DataCategory {
+        SEGMENTS("segments", Set.of(DataType.values())),
+        TRANSLOG("translog", Set.of(DATA, METADATA));
+
+        private final String name;
+        private final Set<DataType> supportedDataTypes;
+
+        DataCategory(String name, Set<DataType> supportedDataTypes) {
+            this.name = name;
+            this.supportedDataTypes = supportedDataTypes;
+        }
+
+        public boolean isSupportedDataType(DataType dataType) {
+            return supportedDataTypes.contains(dataType);
+        }
+
+        public String getName() {
+            return name;
+        }
+    }
+
+    /**
+     * Types of data in remote store.
+     */
+    @PublicApi(since = "2.14.0")
+    public enum DataType {
+        DATA("data"),
+        METADATA("metadata"),
+        LOCK_FILES("lock_files");
+
+        private final String name;
+
+        DataType(String name) {
+            this.name = name;
+        }
+
+        public String getName() {
+            return name;
+        }
+    }
+
+    /**
+     * Enumerates the types of remote store paths resolution techniques supported by OpenSearch.
+     * For more information, see <a href="https://github.com/opensearch-project/OpenSearch/issues/12567">Github issue #12567</a>.
+     */
+    @PublicApi(since = "2.14.0")
+    public enum PathType {
+        FIXED(0) {
+            @Override
+            public BlobPath generatePath(PathInput pathInput, PathHashAlgorithm hashAlgorithm) {
+                assert Objects.isNull(hashAlgorithm) : "hashAlgorithm is expected to be null with fixed remote store path type";
+                // Hash algorithm is not used in FIXED path type
+                return pathInput.basePath()
+                    .add(pathInput.indexUUID())
+                    .add(pathInput.shardId())
+                    .add(pathInput.dataCategory().getName())
+                    .add(pathInput.dataType().getName());
+            }
+
+            @Override
+            boolean requiresHashAlgorithm() {
+                return false;
+            }
+        },
+        HASHED_PREFIX(1) {
+            @Override
+            public BlobPath generatePath(PathInput pathInput, PathHashAlgorithm hashAlgorithm) {
+                // TODO - We need to implement this, keeping the same path as Fixed for sake of multiple tests that can fail otherwise.
+                // throw new UnsupportedOperationException("Not implemented"); --> Not using this for unblocking couple of tests.
+                return pathInput.basePath()
+                    .add(pathInput.indexUUID())
+                    .add(pathInput.shardId())
+                    .add(pathInput.dataCategory().getName())
+                    .add(pathInput.dataType().getName());
+            }
+
+            @Override
+            boolean requiresHashAlgorithm() {
+                return true;
+            }
+        };
+
+        private final int code;
+
+        PathType(int code) {
+            this.code = code;
+        }
+
+        public int getCode() {
+            return code;
+        }
+
+        private static final Map<Integer, PathType> CODE_TO_ENUM;
+
+        static {
+            PathType[] values = values();
+            Map<Integer, PathType> codeToStatus = new HashMap<>(values.length);
+            for (PathType value : values) {
+                int code = value.code;
+                if (codeToStatus.containsKey(code)) {
+                    throw new IllegalStateException(
+                        new ParameterizedMessage("{} has same code as {}", codeToStatus.get(code), value).getFormattedMessage()
+                    );
+                }
+                codeToStatus.put(code, value);
+            }
+            CODE_TO_ENUM = unmodifiableMap(codeToStatus);
+        }
+
+        /**
+         * Turn a status code into a {@link PathType}.
+         */
+        public static PathType fromCode(int code) {
+            return CODE_TO_ENUM.get(code);
+        }
+
+        /**
+         * This method generates the path for the given path input which constitutes multiple fields and characteristics
+         * of the data.
+         *
+         * @param pathInput     input.
+         * @param hashAlgorithm hashing algorithm.
+         * @return the blob path for the path input.
+         */
+        public BlobPath path(PathInput pathInput, PathHashAlgorithm hashAlgorithm) {
+            DataCategory dataCategory = pathInput.dataCategory();
+            DataType dataType = pathInput.dataType();
+            assert dataCategory.isSupportedDataType(dataType) : "category:"
+                + dataCategory
+                + " type:"
+                + dataType
+                + " are not supported together";
+            return generatePath(pathInput, hashAlgorithm);
+        }
+
+        protected abstract BlobPath generatePath(PathInput pathInput, PathHashAlgorithm hashAlgorithm);
+
+        abstract boolean requiresHashAlgorithm();
+
+        public static PathType parseString(String pathType) {
+            try {
+                return PathType.valueOf(pathType.toUpperCase(Locale.ROOT));
+            } catch (IllegalArgumentException | NullPointerException e) {
+                // IllegalArgumentException is thrown when the input does not match any enum name
+                // NullPointerException is thrown when the input is null
+                throw new IllegalArgumentException("Could not parse PathType for [" + pathType + "]");
+            }
+        }
+
+        /**
+         * This string is used as key for storing information in the custom data in index settings.
+         */
+        public static final String NAME = "path_type";
+
+    }
+
+    /**
+     * Type of hashes supported for path types that have hashing.
+     */
+    @PublicApi(since = "2.14.0")
+    public enum PathHashAlgorithm {
+
+        FNV_1A(0) {
+            @Override
+            long hash(PathInput pathInput) {
+                String input = pathInput.indexUUID() + pathInput.shardId() + pathInput.dataCategory().getName() + pathInput.dataType()
+                    .getName();
+                return FNV1a.hash32(input);
+            }
+        };
+
+        private final int code;
+
+        PathHashAlgorithm(int code) {
+            this.code = code;
+        }
+
+        public int getCode() {
+            return code;
+        }
+
+        private static final Map<Integer, PathHashAlgorithm> CODE_TO_ENUM;
+        static {
+            PathHashAlgorithm[] values = values();
+            Map<Integer, PathHashAlgorithm> codeToStatus = new HashMap<>(values.length);
+            for (PathHashAlgorithm value : values) {
+                int code = value.code;
+                if (codeToStatus.containsKey(code)) {
+                    throw new IllegalStateException(
+                        new ParameterizedMessage("{} has same code as {}", codeToStatus.get(code), value).getFormattedMessage()
+                    );
+                }
+                codeToStatus.put(code, value);
+            }
+            CODE_TO_ENUM = unmodifiableMap(codeToStatus);
+        }
+
+        /**
+         * Turn a status code into a {@link PathHashAlgorithm}.
+         */
+        public static PathHashAlgorithm fromCode(int code) {
+            return CODE_TO_ENUM.get(code);
+        }
+
+        abstract long hash(PathInput pathInput);
+
+        public static PathHashAlgorithm parseString(String pathHashAlgorithm) {
+            try {
+                return PathHashAlgorithm.valueOf(pathHashAlgorithm.toUpperCase(Locale.ROOT));
+            } catch (IllegalArgumentException | NullPointerException e) {
+                // IllegalArgumentException is thrown when the input does not match any enum name
+                // NullPointerException is thrown when the input is null
+                throw new IllegalArgumentException("Could not parse PathHashAlgorithm for [" + pathHashAlgorithm + "]");
+            }
+        }
+
+        /**
+         * This string is used as key for storing information in the custom data in index settings.
+         */
+        public static final String NAME = "path_hash_algorithm";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteStorePathStrategy.java b/server/src/main/java/org/opensearch/index/remote/RemoteStorePathStrategy.java
new file mode 100644
index 0000000000000..775f8fe19e4ef
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/remote/RemoteStorePathStrategy.java
@@ -0,0 +1,163 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.remote;
+
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.index.remote.RemoteStoreEnums.DataCategory;
+import org.opensearch.index.remote.RemoteStoreEnums.DataType;
+import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+
+import java.util.Objects;
+
+/**
+ * This class wraps internal details on the remote store path for an index.
+ *
+ * @opensearch.internal
+ */
+@PublicApi(since = "2.14.0")
+public class RemoteStorePathStrategy {
+
+    private final PathType type;
+
+    @Nullable
+    private final PathHashAlgorithm hashAlgorithm;
+
+    public RemoteStorePathStrategy(PathType type) {
+        this(type, null);
+    }
+
+    public RemoteStorePathStrategy(PathType type, PathHashAlgorithm hashAlgorithm) {
+        Objects.requireNonNull(type, "pathType can not be null");
+        if (isCompatible(type, hashAlgorithm) == false) {
+            throw new IllegalArgumentException(
+                new ParameterizedMessage("pathType={} pathHashAlgorithm={} are incompatible", type, hashAlgorithm).getFormattedMessage()
+            );
+        }
+        this.type = type;
+        this.hashAlgorithm = hashAlgorithm;
+    }
+
+    public static boolean isCompatible(PathType type, PathHashAlgorithm hashAlgorithm) {
+        return (type.requiresHashAlgorithm() == false && Objects.isNull(hashAlgorithm))
+            || (type.requiresHashAlgorithm() && Objects.nonNull(hashAlgorithm));
+    }
+
+    public PathType getType() {
+        return type;
+    }
+
+    public PathHashAlgorithm getHashAlgorithm() {
+        return hashAlgorithm;
+    }
+
+    @Override
+    public String toString() {
+        return "RemoteStorePathStrategy{" + "type=" + type + ", hashAlgorithm=" + hashAlgorithm + '}';
+    }
+
+    public BlobPath generatePath(PathInput pathInput) {
+        return type.path(pathInput, hashAlgorithm);
+    }
+
+    /**
+     * Wrapper class for the input required to generate path for remote store uploads.
+     * @opensearch.internal
+     */
+    @PublicApi(since = "2.14.0")
+    public static class PathInput {
+        private final BlobPath basePath;
+        private final String indexUUID;
+        private final String shardId;
+        private final DataCategory dataCategory;
+        private final DataType dataType;
+
+        public PathInput(BlobPath basePath, String indexUUID, String shardId, DataCategory dataCategory, DataType dataType) {
+            this.basePath = Objects.requireNonNull(basePath);
+            this.indexUUID = Objects.requireNonNull(indexUUID);
+            this.shardId = Objects.requireNonNull(shardId);
+            this.dataCategory = Objects.requireNonNull(dataCategory);
+            this.dataType = Objects.requireNonNull(dataType);
+        }
+
+        BlobPath basePath() {
+            return basePath;
+        }
+
+        String indexUUID() {
+            return indexUUID;
+        }
+
+        String shardId() {
+            return shardId;
+        }
+
+        DataCategory dataCategory() {
+            return dataCategory;
+        }
+
+        DataType dataType() {
+            return dataType;
+        }
+
+        /**
+         * Returns a new builder for {@link PathInput}.
+         */
+        public static Builder builder() {
+            return new Builder();
+        }
+
+        /**
+         * Builder for {@link PathInput}.
+         *
+         * @opensearch.internal
+         */
+        @PublicApi(since = "2.14.0")
+        public static class Builder {
+            private BlobPath basePath;
+            private String indexUUID;
+            private String shardId;
+            private DataCategory dataCategory;
+            private DataType dataType;
+
+            public Builder basePath(BlobPath basePath) {
+                this.basePath = basePath;
+                return this;
+            }
+
+            public Builder indexUUID(String indexUUID) {
+                this.indexUUID = indexUUID;
+                return this;
+            }
+
+            public Builder shardId(String shardId) {
+                this.shardId = shardId;
+                return this;
+            }
+
+            public Builder dataCategory(DataCategory dataCategory) {
+                this.dataCategory = dataCategory;
+                return this;
+            }
+
+            public Builder dataType(DataType dataType) {
+                this.dataType = dataType;
+                return this;
+            }
+
+            public PathInput build() {
+                return new PathInput(basePath, indexUUID, shardId, dataCategory, dataType);
+            }
+        }
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteStorePathStrategyResolver.java b/server/src/main/java/org/opensearch/index/remote/RemoteStorePathStrategyResolver.java
new file mode 100644
index 0000000000000..5b067115df781
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/remote/RemoteStorePathStrategyResolver.java
@@ -0,0 +1,49 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.remote;
+
+import org.opensearch.Version;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.indices.IndicesService;
+
+import java.util.function.Supplier;
+
+/**
+ * Determines the {@link RemoteStorePathStrategy} at the time of index metadata creation.
+ *
+ * @opensearch.internal
+ */
+public class RemoteStorePathStrategyResolver {
+
+    private volatile PathType type;
+
+    private final Supplier<Version> minNodeVersionSupplier;
+
+    public RemoteStorePathStrategyResolver(ClusterSettings clusterSettings, Supplier<Version> minNodeVersionSupplier) {
+        this.minNodeVersionSupplier = minNodeVersionSupplier;
+        type = clusterSettings.get(IndicesService.CLUSTER_REMOTE_STORE_PATH_PREFIX_TYPE_SETTING);
+        clusterSettings.addSettingsUpdateConsumer(IndicesService.CLUSTER_REMOTE_STORE_PATH_PREFIX_TYPE_SETTING, this::setType);
+    }
+
+    public RemoteStorePathStrategy get() {
+        PathType pathType;
+        PathHashAlgorithm pathHashAlgorithm;
+        // Min node version check ensures that we are enabling the new prefix type only when all the nodes understand it.
+        pathType = Version.CURRENT.compareTo(minNodeVersionSupplier.get()) <= 0 ? type : PathType.FIXED;
+        // If the path type is fixed, hash algorithm is not applicable.
+        pathHashAlgorithm = pathType == PathType.FIXED ? null : PathHashAlgorithm.FNV_1A;
+        return new RemoteStorePathStrategy(pathType, pathHashAlgorithm);
+    }
+
+    private void setType(PathType type) {
+        this.type = type;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteStorePathType.java b/server/src/main/java/org/opensearch/index/remote/RemoteStorePathType.java
deleted file mode 100644
index 742d7b501f227..0000000000000
--- a/server/src/main/java/org/opensearch/index/remote/RemoteStorePathType.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.index.remote;
-
-import org.opensearch.common.annotation.PublicApi;
-import org.opensearch.common.blobstore.BlobPath;
-import org.opensearch.index.remote.RemoteStoreDataEnums.DataCategory;
-import org.opensearch.index.remote.RemoteStoreDataEnums.DataType;
-
-import java.util.Locale;
-
-/**
- * Enumerates the types of remote store paths resolution techniques supported by OpenSearch.
- * For more information, see <a href="https://github.com/opensearch-project/OpenSearch/issues/12567">Github issue #12567</a>.
- *
- * @opensearch.internal
- */
-@PublicApi(since = "2.14.0")
-public enum RemoteStorePathType {
-
-    FIXED {
-        @Override
-        public BlobPath generatePath(BlobPath basePath, String indexUUID, String shardId, String dataCategory, String dataType) {
-            return basePath.add(indexUUID).add(shardId).add(dataCategory).add(dataType);
-        }
-    },
-    HASHED_PREFIX {
-        @Override
-        public BlobPath generatePath(BlobPath basePath, String indexUUID, String shardId, String dataCategory, String dataType) {
-            // TODO - We need to implement this, keeping the same path as Fixed for sake of multiple tests that can fail otherwise.
-            // throw new UnsupportedOperationException("Not implemented"); --> Not using this for unblocking couple of tests.
-            return basePath.add(indexUUID).add(shardId).add(dataCategory).add(dataType);
-        }
-    };
-
-    /**
-     * @param basePath     base path of the underlying blob store repository
-     * @param indexUUID    of the index
-     * @param shardId      shard id
-     * @param dataCategory is either translog or segment
-     * @param dataType     can be one of data, metadata or lock_files.
-     * @return the blob path for the underlying remote store path type.
-     */
-    public BlobPath path(BlobPath basePath, String indexUUID, String shardId, DataCategory dataCategory, DataType dataType) {
-        assert dataCategory.isSupportedDataType(dataType) : "category:"
-            + dataCategory
-            + " type:"
-            + dataType
-            + " are not supported together";
-        return generatePath(basePath, indexUUID, shardId, dataCategory.getName(), dataType.getName());
-    }
-
-    abstract BlobPath generatePath(BlobPath basePath, String indexUUID, String shardId, String dataCategory, String dataType);
-
-    public static RemoteStorePathType parseString(String remoteStoreBlobPathType) {
-        try {
-            return RemoteStorePathType.valueOf(remoteStoreBlobPathType.toUpperCase(Locale.ROOT));
-        } catch (IllegalArgumentException | NullPointerException e) {
-            // IllegalArgumentException is thrown when the input does not match any enum name
-            // NullPointerException is thrown when the input is null
-            throw new IllegalArgumentException("Could not parse RemoteStorePathType for [" + remoteStoreBlobPathType + "]");
-        }
-    }
-
-    /**
-     * This string is used as key for storing information in the custom data in index settings.
-     */
-    public static final String NAME = "path_type";
-}
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteStorePathTypeResolver.java b/server/src/main/java/org/opensearch/index/remote/RemoteStorePathTypeResolver.java
deleted file mode 100644
index 5d014c9862d45..0000000000000
--- a/server/src/main/java/org/opensearch/index/remote/RemoteStorePathTypeResolver.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.index.remote;
-
-import org.opensearch.common.settings.ClusterSettings;
-import org.opensearch.indices.IndicesService;
-
-/**
- * Determines the {@link RemoteStorePathType} at the time of index metadata creation.
- *
- * @opensearch.internal
- */
-public class RemoteStorePathTypeResolver {
-
-    private volatile RemoteStorePathType type;
-
-    public RemoteStorePathTypeResolver(ClusterSettings clusterSettings) {
-        type = clusterSettings.get(IndicesService.CLUSTER_REMOTE_STORE_PATH_PREFIX_TYPE_SETTING);
-        clusterSettings.addSettingsUpdateConsumer(IndicesService.CLUSTER_REMOTE_STORE_PATH_PREFIX_TYPE_SETTING, this::setType);
-    }
-
-    public RemoteStorePathType getType() {
-        return type;
-    }
-
-    public void setType(RemoteStorePathType type) {
-        this.type = type;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteStoreStatsTrackerFactory.java b/server/src/main/java/org/opensearch/index/remote/RemoteStoreStatsTrackerFactory.java
index e4c7eb56d02c6..21753e68db498 100644
--- a/server/src/main/java/org/opensearch/index/remote/RemoteStoreStatsTrackerFactory.java
+++ b/server/src/main/java/org/opensearch/index/remote/RemoteStoreStatsTrackerFactory.java
@@ -68,7 +68,7 @@ public RemoteStoreStatsTrackerFactory(ClusterService clusterService, Settings se
 
     @Override
     public void afterIndexShardCreated(IndexShard indexShard) {
-        if (indexShard.indexSettings().isRemoteStoreEnabled() == false && indexShard.indexSettings().isRemoteNode() == false) {
+        if (indexShard.indexSettings().isRemoteStoreEnabled() == false && indexShard.indexSettings().isAssignedOnRemoteNode() == false) {
             return;
         }
         ShardId shardId = indexShard.shardId();
diff --git a/server/src/main/java/org/opensearch/index/seqno/GlobalCheckpointSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/GlobalCheckpointSyncAction.java
index ca1dfe2d5ad01..c6a1f5f27a875 100644
--- a/server/src/main/java/org/opensearch/index/seqno/GlobalCheckpointSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/GlobalCheckpointSyncAction.java
@@ -135,7 +135,7 @@ protected void shardOperationOnReplica(Request shardRequest, IndexShard replica,
     private void maybeSyncTranslog(final IndexShard indexShard) throws IOException {
         if (indexShard.getTranslogDurability() == Translog.Durability.REQUEST
             && indexShard.getLastSyncedGlobalCheckpoint() < indexShard.getLastKnownGlobalCheckpoint()
-            && indexShard.isRemoteTranslogEnabled() == false) {
+            && indexShard.indexSettings().isAssignedOnRemoteNode() == false) {
             indexShard.sync();
         }
     }
diff --git a/server/src/main/java/org/opensearch/index/seqno/ReplicationTracker.java b/server/src/main/java/org/opensearch/index/seqno/ReplicationTracker.java
index 0e625e9f30320..599c54f293e89 100644
--- a/server/src/main/java/org/opensearch/index/seqno/ReplicationTracker.java
+++ b/server/src/main/java/org/opensearch/index/seqno/ReplicationTracker.java
@@ -253,6 +253,8 @@ public class ReplicationTracker extends AbstractIndexShardComponent implements L
 
     private volatile ReplicationCheckpoint latestReplicationCheckpoint;
 
+    private final Function<String, Boolean> isShardOnRemoteEnabledNode;
+
     /**
      * Get all retention leases tracked on this shard.
      *
@@ -999,7 +1001,8 @@ public ReplicationTracker(
         final LongConsumer onGlobalCheckpointUpdated,
         final LongSupplier currentTimeMillisSupplier,
         final BiConsumer<RetentionLeases, ActionListener<ReplicationResponse>> onSyncRetentionLeases,
-        final Supplier<SafeCommitInfo> safeCommitInfoSupplier
+        final Supplier<SafeCommitInfo> safeCommitInfoSupplier,
+        final Function<String, Boolean> isShardOnRemoteEnabledNode
     ) {
         this(
             shardId,
@@ -1011,7 +1014,8 @@ public ReplicationTracker(
             currentTimeMillisSupplier,
             onSyncRetentionLeases,
             safeCommitInfoSupplier,
-            x -> {}
+            x -> {},
+            isShardOnRemoteEnabledNode
         );
     }
 
@@ -1037,7 +1041,8 @@ public ReplicationTracker(
         final LongSupplier currentTimeMillisSupplier,
         final BiConsumer<RetentionLeases, ActionListener<ReplicationResponse>> onSyncRetentionLeases,
         final Supplier<SafeCommitInfo> safeCommitInfoSupplier,
-        final Consumer<ReplicationGroup> onReplicationGroupUpdated
+        final Consumer<ReplicationGroup> onReplicationGroupUpdated,
+        final Function<String, Boolean> isShardOnRemoteEnabledNode
     ) {
         super(shardId, indexSettings);
         assert globalCheckpoint >= SequenceNumbers.UNASSIGNED_SEQ_NO : "illegal initial global checkpoint: " + globalCheckpoint;
@@ -1060,6 +1065,7 @@ public ReplicationTracker(
         this.safeCommitInfoSupplier = safeCommitInfoSupplier;
         this.onReplicationGroupUpdated = onReplicationGroupUpdated;
         this.latestReplicationCheckpoint = indexSettings.isSegRepEnabledOrRemoteNode() ? ReplicationCheckpoint.empty(shardId) : null;
+        this.isShardOnRemoteEnabledNode = isShardOnRemoteEnabledNode;
         assert Version.V_EMPTY.equals(indexSettings.getIndexVersionCreated()) == false;
         assert invariant();
     }
@@ -1088,8 +1094,12 @@ private ReplicationGroup calculateReplicationGroup() {
         } else {
             newVersion = replicationGroup.getVersion() + 1;
         }
-
-        assert indexSettings().isRemoteTranslogStoreEnabled()
+        assert indexSettings.isRemoteTranslogStoreEnabled()
+            // Handle migration cases. Ignore assertion if any of the shard copies in the replication group is assigned to a remote node
+            || (replicationGroup != null
+                && replicationGroup.getReplicationTargets()
+                    .stream()
+                    .anyMatch(shardRouting -> isShardOnRemoteEnabledNode.apply(shardRouting.currentNodeId())))
             || checkpoints.entrySet().stream().filter(e -> e.getValue().tracked).allMatch(e -> e.getValue().replicated)
             : "In absence of remote translog store, all tracked shards must have replication mode as LOGICAL_REPLICATION";
 
@@ -1248,7 +1258,9 @@ private void createReplicationLagTimers() {
                 if (cps.inSync
                     && replicationGroup.getUnavailableInSyncShards().contains(allocationId) == false
                     && isPrimaryRelocation(allocationId) == false
-                    && latestReplicationCheckpoint.isAheadOf(cps.visibleReplicationCheckpoint)) {
+                    && latestReplicationCheckpoint.isAheadOf(cps.visibleReplicationCheckpoint)
+                    && (indexSettings.isSegRepLocalEnabled() == true
+                        || isShardOnRemoteEnabledNode.apply(routingTable.getByAllocationId(allocationId).currentNodeId()))) {
                     cps.checkpointTimers.computeIfAbsent(latestReplicationCheckpoint, ignored -> new SegmentReplicationLagTimer());
                     logger.trace(
                         () -> new ParameterizedMessage(
@@ -1367,7 +1379,7 @@ private void addPeerRecoveryRetentionLeaseForSolePrimary() {
         final String leaseId = getPeerRecoveryRetentionLeaseId(primaryShard);
         if (retentionLeases.get(leaseId) == null) {
             if (replicationGroup.getReplicationTargets().equals(Collections.singletonList(primaryShard))
-                || indexSettings().isRemoteTranslogStoreEnabled()) {
+                || indexSettings.isAssignedOnRemoteNode()) {
                 assert primaryShard.allocationId().getId().equals(shardAllocationId) : routingTable.assignedShards()
                     + " vs "
                     + shardAllocationId;
@@ -1453,7 +1465,12 @@ public synchronized void updateFromClusterManager(
                                 globalCheckpoint,
                                 inSync,
                                 inSync,
-                                isReplicated(initializingId, primaryAllocationId, primaryTargetAllocationId)
+                                isReplicated(
+                                    initializingId,
+                                    primaryAllocationId,
+                                    primaryTargetAllocationId,
+                                    assignedToRemoteStoreNode(routingTable, initializingId)
+                                )
                             )
                         );
                     }
@@ -1472,7 +1489,12 @@ public synchronized void updateFromClusterManager(
                             globalCheckpoint,
                             false,
                             false,
-                            isReplicated(initializingId, primaryAllocationId, primaryTargetAllocationId)
+                            isReplicated(
+                                initializingId,
+                                primaryAllocationId,
+                                primaryTargetAllocationId,
+                                assignedToRemoteStoreNode(routingTable, initializingId)
+                            )
                         )
                     );
                 }
@@ -1486,7 +1508,12 @@ public synchronized void updateFromClusterManager(
                             globalCheckpoint,
                             true,
                             true,
-                            isReplicated(inSyncId, primaryAllocationId, primaryTargetAllocationId)
+                            isReplicated(
+                                inSyncId,
+                                primaryAllocationId,
+                                primaryTargetAllocationId,
+                                assignedToRemoteStoreNode(routingTable, inSyncId)
+                            )
                         )
                     );
                 }
@@ -1503,6 +1530,12 @@ public synchronized void updateFromClusterManager(
         assert invariant();
     }
 
+    private boolean assignedToRemoteStoreNode(IndexShardRoutingTable routingTable, String allocationId) {
+        return indexSettings().isRemoteStoreEnabled()
+            || (routingTable.getByAllocationId(allocationId) != null
+                && isShardOnRemoteEnabledNode.apply(routingTable.getByAllocationId(allocationId).currentNodeId()));
+    }
+
     /**
      * Returns whether the requests are replicated considering the remote translog existence, current/primary/primary target allocation ids.
      *
@@ -1511,13 +1544,16 @@ public synchronized void updateFromClusterManager(
      * @param primaryTargetAllocationId primary target allocation id
      * @return the replication mode.
      */
-    private boolean isReplicated(String allocationId, String primaryAllocationId, String primaryTargetAllocationId) {
-        // If remote translog is enabled, then returns replication mode checking current allocation id against the
+    private boolean isReplicated(
+        String allocationId,
+        String primaryAllocationId,
+        String primaryTargetAllocationId,
+        boolean assignedToRemoteStoreNode
+    ) {
+        // If assigned to a remote node, returns true if given allocation id matches the primary or it's relocation target allocation
         // primary and primary target allocation id.
-        // If remote translog is enabled, then returns true if given allocation id matches the primary or it's relocation target allocation
-        // id.
-        if (indexSettings().isRemoteTranslogStoreEnabled()) {
-            return (allocationId.equals(primaryAllocationId) || allocationId.equals(primaryTargetAllocationId));
+        if (assignedToRemoteStoreNode == true) {
+            return allocationId.equals(primaryAllocationId) || allocationId.equals(primaryTargetAllocationId);
         }
         // For other case which is local translog, return true as the requests are replicated to all shards in the replication group.
         return true;
diff --git a/server/src/main/java/org/opensearch/index/shard/CheckpointRefreshListener.java b/server/src/main/java/org/opensearch/index/shard/CheckpointRefreshListener.java
index 675d60ec2b63d..7f0806059155a 100644
--- a/server/src/main/java/org/opensearch/index/shard/CheckpointRefreshListener.java
+++ b/server/src/main/java/org/opensearch/index/shard/CheckpointRefreshListener.java
@@ -43,7 +43,7 @@ protected boolean performAfterRefreshWithPermit(boolean didRefresh) {
         if (didRefresh
             && shard.state() == IndexShardState.STARTED
             && shard.getReplicationTracker().isPrimaryMode()
-            && !shard.indexSettings.isSegRepWithRemoteEnabled()) {
+            && shard.indexSettings.isAssignedOnRemoteNode() == false) {
             publisher.publish(shard, shard.getLatestReplicationCheckpoint());
         }
         return true;
diff --git a/server/src/main/java/org/opensearch/index/shard/IndexShard.java b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
index f3a62cdf1436f..26dbbbcdee7c0 100644
--- a/server/src/main/java/org/opensearch/index/shard/IndexShard.java
+++ b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
@@ -67,6 +67,8 @@
 import org.opensearch.cluster.metadata.DataStream;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.MappingMetadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.cluster.routing.RecoverySource.SnapshotRecoverySource;
@@ -357,6 +359,7 @@ Runnable getGlobalCheckpointSyncer() {
      On source remote node , it will be REMOTE_MIGRATING_UNSEEDED when relocating from docrep node
      */
     private final ShardMigrationState shardMigrationState;
+    private DiscoveryNodes discoveryNodes;
 
     public IndexShard(
         final ShardRouting shardRouting,
@@ -386,7 +389,8 @@ public IndexShard(
         final String nodeId,
         final RecoverySettings recoverySettings,
         final RemoteStoreSettings remoteStoreSettings,
-        boolean seedRemote
+        boolean seedRemote,
+        final DiscoveryNodes discoveryNodes
     ) throws IOException {
         super(shardRouting.shardId(), indexSettings);
         assert shardRouting.initializing();
@@ -406,7 +410,7 @@ public IndexShard(
             logger,
             threadPool,
             this::getEngine,
-            indexSettings.isRemoteNode(),
+            indexSettings.isAssignedOnRemoteNode(),
             () -> getRemoteTranslogUploadBufferInterval(remoteStoreSettings::getClusterRemoteTranslogBufferInterval)
         );
         this.mapperService = mapperService;
@@ -448,7 +452,8 @@ public IndexShard(
             threadPool::absoluteTimeInMillis,
             (retentionLeases, listener) -> retentionLeaseSyncer.sync(shardId, aId, getPendingPrimaryTerm(), retentionLeases, listener),
             this::getSafeCommitInfo,
-            pendingReplicationActions
+            pendingReplicationActions,
+            isShardOnRemoteEnabledNode
         );
 
         // the query cache is a node-level thing, however we want the most popular filters
@@ -486,6 +491,7 @@ public boolean shouldCache(Query query) {
         this.remoteStoreSettings = remoteStoreSettings;
         this.fileDownloader = new RemoteStoreFileDownloader(shardRouting.shardId(), threadPool, recoverySettings);
         this.shardMigrationState = getShardMigrationState(indexSettings, seedRemote);
+        this.discoveryNodes = discoveryNodes;
     }
 
     public ThreadPool getThreadPool() {
@@ -506,6 +512,23 @@ public boolean shouldSeedRemoteStore() {
         return shardMigrationState == REMOTE_MIGRATING_UNSEEDED;
     }
 
+    /**
+     * To be delegated to {@link ReplicationTracker} so that relevant remote store based
+     * operations can be ignored during engine migration
+     * <p>
+     * Has explicit null checks to ensure that the {@link ReplicationTracker#invariant()}
+     * checks does not fail during a cluster manager state update when the latest replication group
+     * calculation is not yet done and the cached replication group details are available
+     */
+    public Function<String, Boolean> isShardOnRemoteEnabledNode = nodeId -> {
+        DiscoveryNode node = discoveryNodes.get(nodeId);
+        if (node != null) {
+            logger.trace("Node {} has remote_enabled as {}", nodeId, node.isRemoteStoreNode());
+            return node.isRemoteStoreNode();
+        }
+        return false;
+    };
+
     public boolean isRemoteSeeded() {
         return shardMigrationState == REMOTE_MIGRATING_SEEDED;
     }
@@ -616,8 +639,10 @@ public void updateShardState(
         final BiConsumer<IndexShard, ActionListener<ResyncTask>> primaryReplicaSyncer,
         final long applyingClusterStateVersion,
         final Set<String> inSyncAllocationIds,
-        final IndexShardRoutingTable routingTable
+        final IndexShardRoutingTable routingTable,
+        DiscoveryNodes discoveryNodes
     ) throws IOException {
+        this.discoveryNodes = discoveryNodes;
         final ShardRouting currentRouting;
         synchronized (mutex) {
             currentRouting = this.shardRouting;
@@ -1469,7 +1494,7 @@ public SegmentsStats segmentStats(boolean includeSegmentFileSizes, boolean inclu
         SegmentsStats segmentsStats = getEngine().segmentsStats(includeSegmentFileSizes, includeUnloadedSegments);
         segmentsStats.addBitsetMemoryInBytes(shardBitsetFilterCache.getMemorySizeInBytes());
         // Populate remote_store stats only if the index is remote store backed
-        if (indexSettings().isRemoteNode()) {
+        if (indexSettings().isAssignedOnRemoteNode()) {
             segmentsStats.addRemoteSegmentStats(
                 new RemoteSegmentStats(remoteStoreStatsTrackerFactory.getRemoteSegmentTransferTracker(shardId).stats())
             );
@@ -1491,7 +1516,7 @@ public FieldDataStats fieldDataStats(String... fields) {
     public TranslogStats translogStats() {
         TranslogStats translogStats = getEngine().translogManager().getTranslogStats();
         // Populate remote_store stats only if the index is remote store backed
-        if (indexSettings.isRemoteNode()) {
+        if (indexSettings.isAssignedOnRemoteNode()) {
             translogStats.addRemoteTranslogStats(
                 new RemoteTranslogStats(remoteStoreStatsTrackerFactory.getRemoteTranslogTransferTracker(shardId).stats())
             );
@@ -1530,7 +1555,7 @@ public void flush(FlushRequest request) {
      * {@link org.opensearch.index.translog.TranslogDeletionPolicy} for details
      */
     public void trimTranslog() {
-        if (indexSettings.isRemoteNode()) {
+        if (indexSettings.isAssignedOnRemoteNode()) {
             return;
         }
         verifyNotClosed();
@@ -2050,7 +2075,7 @@ public void close(String reason, boolean flushEngine, boolean deleted) throws IO
     ToDo : Fix this https://github.com/opensearch-project/OpenSearch/issues/8003
      */
     public RemoteSegmentStoreDirectory getRemoteDirectory() {
-        assert indexSettings.isRemoteNode();
+        assert indexSettings.isAssignedOnRemoteNode();
         assert remoteStore.directory() instanceof FilterDirectory : "Store.directory is not an instance of FilterDirectory";
         FilterDirectory remoteStoreDirectory = (FilterDirectory) remoteStore.directory();
         FilterDirectory byteSizeCachingStoreDirectory = (FilterDirectory) remoteStoreDirectory.getDelegate();
@@ -2063,7 +2088,7 @@ public RemoteSegmentStoreDirectory getRemoteDirectory() {
      * is in sync with local
      */
     public boolean isRemoteSegmentStoreInSync() {
-        assert indexSettings.isRemoteNode();
+        assert indexSettings.isAssignedOnRemoteNode();
         try {
             RemoteSegmentStoreDirectory directory = getRemoteDirectory();
             if (directory.readLatestMetadataFile() != null) {
@@ -2102,7 +2127,7 @@ public void waitForRemoteStoreSync() {
     Calls onProgress on seeing an increased file count on remote
     */
     public void waitForRemoteStoreSync(Runnable onProgress) {
-        assert indexSettings.isRemoteNode();
+        assert indexSettings.isAssignedOnRemoteNode();
         RemoteSegmentStoreDirectory directory = getRemoteDirectory();
         int segmentUploadeCount = 0;
         if (shardRouting.primary() == false) {
@@ -2277,7 +2302,7 @@ public long recoverLocallyAndFetchStartSeqNo(boolean localTranslog) {
      * @return the starting sequence number from which the recovery should start.
      */
     private long recoverLocallyUptoLastCommit() {
-        assert indexSettings.isRemoteNode() : "Remote translog store is not enabled";
+        assert indexSettings.isAssignedOnRemoteNode() : "Remote translog store is not enabled";
         long seqNo;
         validateLocalRecoveryState();
 
@@ -3496,7 +3521,7 @@ public void updateGlobalCheckpointOnReplica(final long globalCheckpoint, final S
              * update local checkpoint at replica, so the local checkpoint at replica can be less than globalCheckpoint.
              */
             assert (state() != IndexShardState.POST_RECOVERY && state() != IndexShardState.STARTED)
-                || indexSettings.isRemoteTranslogStoreEnabled() : "supposedly in-sync shard copy received a global checkpoint ["
+                || indexSettings.isAssignedOnRemoteNode() : "supposedly in-sync shard copy received a global checkpoint ["
                     + globalCheckpoint
                     + "] "
                     + "that is higher than its local checkpoint ["
@@ -3540,7 +3565,7 @@ assert getLocalCheckpoint() == primaryContext.getCheckpointStates().get(allocati
     }
 
     private void postActivatePrimaryMode() {
-        if (indexSettings.isRemoteNode()) {
+        if (indexSettings.isAssignedOnRemoteNode()) {
             // We make sure to upload translog (even if it does not contain any operations) to remote translog.
             // This helps to get a consistent state in remote store where both remote segment store and remote
             // translog contains data.
@@ -3993,7 +4018,7 @@ private boolean isRemoteStoreEnabled() {
     }
 
     public boolean isRemoteTranslogEnabled() {
-        return indexSettings() != null && indexSettings().isRemoteTranslogStoreEnabled();
+        return indexSettings() != null && (indexSettings().isRemoteTranslogStoreEnabled());
     }
 
     /**
@@ -4010,7 +4035,7 @@ public boolean enableUploadToRemoteTranslog() {
     }
 
     private boolean hasOneRemoteSegmentSyncHappened() {
-        assert indexSettings.isRemoteNode();
+        assert indexSettings.isAssignedOnRemoteNode();
         // We upload remote translog only after one remote segment upload in case of migration
         RemoteSegmentStoreDirectory rd = getRemoteDirectory();
         AtomicBoolean segment_n_uploaded = new AtomicBoolean(false);
@@ -4624,7 +4649,7 @@ public final boolean isSearchIdle() {
     public final boolean isSearchIdleSupported() {
         // If the index is remote store backed, then search idle is not supported. This is to ensure that async refresh
         // task continues to upload to remote store periodically.
-        if (isRemoteTranslogEnabled() || indexSettings.isRemoteNode()) {
+        if (isRemoteTranslogEnabled() || indexSettings.isAssignedOnRemoteNode()) {
             return false;
         }
         return indexSettings.isSegRepEnabledOrRemoteNode() == false || indexSettings.getNumberOfReplicas() == 0;
@@ -4944,7 +4969,7 @@ public void deleteTranslogFilesFromRemoteTranslog() throws IOException {
         TranslogFactory translogFactory = translogFactorySupplier.apply(indexSettings, shardRouting);
         assert translogFactory instanceof RemoteBlobStoreInternalTranslogFactory;
         Repository repository = ((RemoteBlobStoreInternalTranslogFactory) translogFactory).getRepository();
-        RemoteFsTranslog.cleanup(repository, shardId, getThreadPool(), indexSettings.getRemoteStorePathType());
+        RemoteFsTranslog.cleanup(repository, shardId, getThreadPool(), indexSettings.getRemoteStorePathStrategy(), remoteStoreSettings);
     }
 
     /*
@@ -4966,7 +4991,8 @@ public void syncTranslogFilesFromRemoteTranslog() throws IOException {
             shardId,
             getThreadPool(),
             shardPath().resolveTranslog(),
-            indexSettings.getRemoteStorePathType(),
+            indexSettings.getRemoteStorePathStrategy(),
+            remoteStoreSettings,
             logger
         );
     }
@@ -5263,9 +5289,9 @@ enum ShardMigrationState {
     }
 
     static ShardMigrationState getShardMigrationState(IndexSettings indexSettings, boolean shouldSeed) {
-        if (indexSettings.isRemoteNode() && indexSettings.isRemoteStoreEnabled()) {
+        if (indexSettings.isAssignedOnRemoteNode() && indexSettings.isRemoteStoreEnabled()) {
             return REMOTE_NON_MIGRATING;
-        } else if (indexSettings.isRemoteNode()) {
+        } else if (indexSettings.isAssignedOnRemoteNode()) {
             return shouldSeed ? REMOTE_MIGRATING_UNSEEDED : REMOTE_MIGRATING_SEEDED;
         }
         return ShardMigrationState.DOCREP_NON_MIGRATING;
diff --git a/server/src/main/java/org/opensearch/index/shard/StoreRecovery.java b/server/src/main/java/org/opensearch/index/shard/StoreRecovery.java
index 9779a2320d79f..f5e342d28fde1 100644
--- a/server/src/main/java/org/opensearch/index/shard/StoreRecovery.java
+++ b/server/src/main/java/org/opensearch/index/shard/StoreRecovery.java
@@ -58,7 +58,6 @@
 import org.opensearch.index.engine.Engine;
 import org.opensearch.index.engine.EngineException;
 import org.opensearch.index.mapper.MapperService;
-import org.opensearch.index.remote.RemoteStorePathType;
 import org.opensearch.index.seqno.SequenceNumbers;
 import org.opensearch.index.snapshots.IndexShardRestoreFailedException;
 import org.opensearch.index.snapshots.blobstore.RemoteStoreShardShallowCopySnapshot;
@@ -411,7 +410,7 @@ void recoverFromSnapshotAndRemoteStore(
                     remoteStoreRepository,
                     indexUUID,
                     shardId,
-                    RemoteStorePathType.FIXED // TODO - The path type needs to be obtained from RemoteStoreShardShallowCopySnapshot
+                    shallowCopyShardMetadata.getRemoteStorePathStrategy()
                 );
                 sourceRemoteDirectory.initializeToSpecificCommit(
                     primaryTerm,
diff --git a/server/src/main/java/org/opensearch/index/snapshots/blobstore/RemoteStoreShardShallowCopySnapshot.java b/server/src/main/java/org/opensearch/index/snapshots/blobstore/RemoteStoreShardShallowCopySnapshot.java
index d54e9686ab951..9c0ea42810e16 100644
--- a/server/src/main/java/org/opensearch/index/snapshots/blobstore/RemoteStoreShardShallowCopySnapshot.java
+++ b/server/src/main/java/org/opensearch/index/snapshots/blobstore/RemoteStoreShardShallowCopySnapshot.java
@@ -8,17 +8,22 @@
 
 package org.opensearch.index.snapshots.blobstore;
 
+import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.OpenSearchParseException;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.core.ParseField;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.index.snapshots.IndexShardSnapshotStatus;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * Remote Store based Shard snapshot metadata
@@ -41,8 +46,10 @@ public class RemoteStoreShardShallowCopySnapshot implements ToXContentFragment,
     private final String repositoryBasePath;
     private final String indexUUID;
     private final List<String> fileNames;
+    private final PathType pathType;
+    private final PathHashAlgorithm pathHashAlgorithm;
 
-    static final String DEFAULT_VERSION = "1";
+    static final String DEFAULT_VERSION = "2";
     static final String NAME = "name";
     static final String VERSION = "version";
     static final String INDEX_VERSION = "index_version";
@@ -61,6 +68,8 @@ public class RemoteStoreShardShallowCopySnapshot implements ToXContentFragment,
 
     static final String TOTAL_FILE_COUNT = "number_of_files";
     static final String TOTAL_SIZE = "total_size";
+    static final String PATH_TYPE = "path_type";
+    static final String PATH_HASH_ALGORITHM = "path_hash_algorithm";
 
     private static final ParseField PARSE_NAME = new ParseField(NAME);
     private static final ParseField PARSE_VERSION = new ParseField(VERSION);
@@ -75,6 +84,8 @@ public class RemoteStoreShardShallowCopySnapshot implements ToXContentFragment,
     private static final ParseField PARSE_REMOTE_STORE_REPOSITORY = new ParseField(REMOTE_STORE_REPOSITORY);
     private static final ParseField PARSE_REPOSITORY_BASE_PATH = new ParseField(REPOSITORY_BASE_PATH);
     private static final ParseField PARSE_FILE_NAMES = new ParseField(FILE_NAMES);
+    private static final ParseField PARSE_PATH_TYPE = new ParseField(PATH_TYPE);
+    private static final ParseField PARSE_PATH_HASH_ALGORITHM = new ParseField(PATH_HASH_ALGORITHM);
 
     /**
      * Serializes shard snapshot metadata info into JSON
@@ -101,6 +112,14 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
             builder.value(fileName);
         }
         builder.endArray();
+        // We are handling NP check since a cluster can have indexes created earlier which do not have remote store
+        // path type and path hash algorithm in its custom data in index metadata.
+        if (Objects.nonNull(pathType)) {
+            builder.field(PATH_TYPE, pathType.getCode());
+        }
+        if (Objects.nonNull(pathHashAlgorithm)) {
+            builder.field(PATH_HASH_ALGORITHM, pathHashAlgorithm.getCode());
+        }
         return builder;
     }
 
@@ -116,34 +135,30 @@ public RemoteStoreShardShallowCopySnapshot(
         String indexUUID,
         String remoteStoreRepository,
         String repositoryBasePath,
-        List<String> fileNames
+        List<String> fileNames,
+        PathType pathType,
+        PathHashAlgorithm pathHashAlgorithm
     ) {
-        this.version = DEFAULT_VERSION;
-        verifyParameters(
-            version,
+        this(
+            DEFAULT_VERSION,
             snapshot,
             indexVersion,
             primaryTerm,
             commitGeneration,
+            startTime,
+            time,
+            totalFileCount,
+            totalSize,
             indexUUID,
             remoteStoreRepository,
-            repositoryBasePath
+            repositoryBasePath,
+            fileNames,
+            pathType,
+            pathHashAlgorithm
         );
-        this.snapshot = snapshot;
-        this.indexVersion = indexVersion;
-        this.primaryTerm = primaryTerm;
-        this.commitGeneration = commitGeneration;
-        this.startTime = startTime;
-        this.time = time;
-        this.totalFileCount = totalFileCount;
-        this.totalSize = totalSize;
-        this.indexUUID = indexUUID;
-        this.remoteStoreRepository = remoteStoreRepository;
-        this.repositoryBasePath = repositoryBasePath;
-        this.fileNames = fileNames;
     }
 
-    private RemoteStoreShardShallowCopySnapshot(
+    RemoteStoreShardShallowCopySnapshot(
         String version,
         String snapshot,
         long indexVersion,
@@ -156,7 +171,9 @@ private RemoteStoreShardShallowCopySnapshot(
         String indexUUID,
         String remoteStoreRepository,
         String repositoryBasePath,
-        List<String> fileNames
+        List<String> fileNames,
+        PathType pathType,
+        PathHashAlgorithm pathHashAlgorithm
     ) {
         verifyParameters(
             version,
@@ -166,7 +183,9 @@ private RemoteStoreShardShallowCopySnapshot(
             commitGeneration,
             indexUUID,
             remoteStoreRepository,
-            repositoryBasePath
+            repositoryBasePath,
+            pathType,
+            pathHashAlgorithm
         );
         this.version = version;
         this.snapshot = snapshot;
@@ -181,6 +200,8 @@ private RemoteStoreShardShallowCopySnapshot(
         this.remoteStoreRepository = remoteStoreRepository;
         this.repositoryBasePath = repositoryBasePath;
         this.fileNames = fileNames;
+        this.pathType = pathType;
+        this.pathHashAlgorithm = pathHashAlgorithm;
     }
 
     /**
@@ -203,6 +224,8 @@ public static RemoteStoreShardShallowCopySnapshot fromXContent(XContentParser pa
         long primaryTerm = -1;
         long commitGeneration = -1;
         List<String> fileNames = new ArrayList<>();
+        PathType pathType = null;
+        PathHashAlgorithm pathHashAlgorithm = null;
 
         if (parser.currentToken() == null) { // fresh parser? move to the first token
             parser.nextToken();
@@ -237,6 +260,10 @@ public static RemoteStoreShardShallowCopySnapshot fromXContent(XContentParser pa
                     remoteStoreRepository = parser.text();
                 } else if (PARSE_REPOSITORY_BASE_PATH.match(currentFieldName, parser.getDeprecationHandler())) {
                     repositoryBasePath = parser.text();
+                } else if (PARSE_PATH_TYPE.match(currentFieldName, parser.getDeprecationHandler())) {
+                    pathType = PathType.fromCode(parser.intValue());
+                } else if (PARSE_PATH_HASH_ALGORITHM.match(currentFieldName, parser.getDeprecationHandler())) {
+                    pathHashAlgorithm = PathHashAlgorithm.fromCode(parser.intValue());
                 } else {
                     throw new OpenSearchParseException("unknown parameter [{}]", currentFieldName);
                 }
@@ -266,7 +293,9 @@ public static RemoteStoreShardShallowCopySnapshot fromXContent(XContentParser pa
             indexUUID,
             remoteStoreRepository,
             repositoryBasePath,
-            fileNames
+            fileNames,
+            pathType,
+            pathHashAlgorithm
         );
     }
 
@@ -380,38 +409,47 @@ private void verifyParameters(
         long commitGeneration,
         String indexUUID,
         String remoteStoreRepository,
-        String repositoryBasePath
+        String repositoryBasePath,
+        PathType pathType,
+        PathHashAlgorithm pathHashAlgorithm
     ) {
-        String exceptionStr = null;
-        if (version == null) {
-            exceptionStr = "Invalid Version Provided";
-        }
-        if (snapshot == null) {
-            exceptionStr = "Invalid/Missing Snapshot Name";
-        }
-        if (indexVersion < 0) {
-            exceptionStr = "Invalid Index Version";
-        }
-        if (primaryTerm < 0) {
-            exceptionStr = "Invalid Primary Term";
-        }
-        if (commitGeneration < 0) {
-            exceptionStr = "Invalid Commit Generation";
-        }
-        if (indexUUID == null) {
-            exceptionStr = "Invalid/Missing Index UUID";
-        }
-        if (remoteStoreRepository == null) {
-            exceptionStr = "Invalid/Missing Remote Store Repository";
-        }
-        if (repositoryBasePath == null) {
-            exceptionStr = "Invalid/Missing Repository Base Path";
-        }
-        if (exceptionStr != null) {
+
+        throwExceptionIfInvalid(Objects.isNull(version), "Invalid Version Provided");
+        throwExceptionIfInvalid(Objects.isNull(snapshot), "Invalid/Missing Snapshot Name");
+        throwExceptionIfInvalid(indexVersion < 0, "Invalid Index Version");
+        throwExceptionIfInvalid(primaryTerm < 0, "Invalid Primary Term");
+        throwExceptionIfInvalid(commitGeneration < 0, "Invalid Commit Generation");
+        throwExceptionIfInvalid(Objects.isNull(indexUUID), "Invalid/Missing Index UUID");
+        throwExceptionIfInvalid(Objects.isNull(remoteStoreRepository), "Invalid/Missing Remote Store Repository");
+        throwExceptionIfInvalid(Objects.isNull(repositoryBasePath), "Invalid/Missing Repository Base Path");
+        throwExceptionIfInvalid(
+            isValidRemotePathConfiguration(version, pathType, pathHashAlgorithm) == false,
+            new ParameterizedMessage(
+                "Invalid combination of pathType={} pathHashAlgorithm={} for version={}",
+                pathType,
+                pathHashAlgorithm,
+                version
+            ).getFormattedMessage()
+        );
+    }
+
+    private void throwExceptionIfInvalid(boolean isInvalid, String exceptionStr) {
+        if (isInvalid) {
             throw new IllegalArgumentException(exceptionStr);
         }
     }
 
+    private boolean isValidRemotePathConfiguration(String version, PathType pathType, PathHashAlgorithm pathHashAlgorithm) {
+        switch (version) {
+            case "1":
+                return Objects.isNull(pathType) && Objects.isNull(pathHashAlgorithm);
+            case "2":
+                return Objects.nonNull(pathType) && RemoteStorePathStrategy.isCompatible(pathType, pathHashAlgorithm);
+            default:
+                return false;
+        }
+    }
+
     /**
      * Creates a new instance which has a different name and zero incremental file counts but is identical to this instance in terms of the files
      * it references.
@@ -433,7 +471,9 @@ public RemoteStoreShardShallowCopySnapshot asClone(String targetSnapshotName, lo
             indexUUID,
             remoteStoreRepository,
             repositoryBasePath,
-            fileNames
+            fileNames,
+            pathType,
+            pathHashAlgorithm
         );
     }
 
@@ -449,4 +489,63 @@ public IndexShardSnapshotStatus getIndexShardSnapshotStatus() {
             null
         ); // Not adding a real generation here as it doesn't matter to callers
     }
+
+    public PathType getPathType() {
+        return pathType;
+    }
+
+    public PathHashAlgorithm getPathHashAlgorithm() {
+        return pathHashAlgorithm;
+    }
+
+    public RemoteStorePathStrategy getRemoteStorePathStrategy() {
+        if (Objects.nonNull(pathType)) {
+            return new RemoteStorePathStrategy(pathType, pathHashAlgorithm);
+        }
+        return new RemoteStorePathStrategy(PathType.FIXED);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        RemoteStoreShardShallowCopySnapshot that = (RemoteStoreShardShallowCopySnapshot) obj;
+
+        return Objects.equals(this.snapshot, that.snapshot)
+            && Objects.equals(this.version, that.version)
+            && this.indexVersion == that.indexVersion
+            && this.startTime == that.startTime
+            && this.time == that.time
+            && this.totalFileCount == that.totalFileCount
+            && this.totalSize == that.totalSize
+            && this.primaryTerm == that.primaryTerm
+            && this.commitGeneration == that.commitGeneration
+            && Objects.equals(this.remoteStoreRepository, that.remoteStoreRepository)
+            && Objects.equals(this.repositoryBasePath, that.repositoryBasePath)
+            && Objects.equals(this.indexUUID, that.indexUUID)
+            && Objects.equals(this.fileNames, that.fileNames)
+            && Objects.equals(this.pathType, that.pathType)
+            && Objects.equals(this.pathHashAlgorithm, that.pathHashAlgorithm);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(
+            snapshot,
+            version,
+            indexVersion,
+            startTime,
+            time,
+            totalFileCount,
+            totalSize,
+            primaryTerm,
+            commitGeneration,
+            remoteStoreRepository,
+            repositoryBasePath,
+            indexUUID,
+            fileNames,
+            pathType,
+            pathHashAlgorithm
+        );
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java
index 999625e0e579f..ec1163fe91b6c 100644
--- a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java
+++ b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java
@@ -31,7 +31,7 @@
 import org.opensearch.common.lucene.store.ByteArrayIndexInput;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.index.shard.ShardId;
-import org.opensearch.index.remote.RemoteStorePathType;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.index.remote.RemoteStoreUtils;
 import org.opensearch.index.store.lockmanager.FileLockInfo;
 import org.opensearch.index.store.lockmanager.RemoteStoreCommitLevelLockManager;
@@ -899,14 +899,14 @@ public static void remoteDirectoryCleanup(
         String remoteStoreRepoForIndex,
         String indexUUID,
         ShardId shardId,
-        RemoteStorePathType pathType
+        RemoteStorePathStrategy pathStrategy
     ) {
         try {
             RemoteSegmentStoreDirectory remoteSegmentStoreDirectory = (RemoteSegmentStoreDirectory) remoteDirectoryFactory.newDirectory(
                 remoteStoreRepoForIndex,
                 indexUUID,
                 shardId,
-                pathType
+                pathStrategy
             );
             remoteSegmentStoreDirectory.deleteStaleSegments(0);
             remoteSegmentStoreDirectory.deleteIfEmpty();
diff --git a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactory.java b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactory.java
index f0ecd96bcf1f7..e462f6d4ac011 100644
--- a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactory.java
+++ b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactory.java
@@ -13,7 +13,7 @@
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.IndexSettings;
-import org.opensearch.index.remote.RemoteStorePathType;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.index.shard.ShardPath;
 import org.opensearch.index.store.lockmanager.RemoteStoreLockManager;
 import org.opensearch.index.store.lockmanager.RemoteStoreLockManagerFactory;
@@ -28,9 +28,9 @@
 import java.util.Objects;
 import java.util.function.Supplier;
 
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataCategory.SEGMENTS;
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataType.DATA;
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataType.METADATA;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataCategory.SEGMENTS;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataType.DATA;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataType.METADATA;
 
 /**
  * Factory for a remote store directory
@@ -52,12 +52,12 @@ public RemoteSegmentStoreDirectoryFactory(Supplier<RepositoriesService> reposito
     public Directory newDirectory(IndexSettings indexSettings, ShardPath path) throws IOException {
         String repositoryName = indexSettings.getRemoteStoreRepository();
         String indexUUID = indexSettings.getIndex().getUUID();
-        return newDirectory(repositoryName, indexUUID, path.getShardId(), indexSettings.getRemoteStorePathType());
+        return newDirectory(repositoryName, indexUUID, path.getShardId(), indexSettings.getRemoteStorePathStrategy());
     }
 
-    public Directory newDirectory(String repositoryName, String indexUUID, ShardId shardId, RemoteStorePathType pathType)
+    public Directory newDirectory(String repositoryName, String indexUUID, ShardId shardId, RemoteStorePathStrategy pathStrategy)
         throws IOException {
-        assert Objects.nonNull(pathType);
+        assert Objects.nonNull(pathStrategy);
         try (Repository repository = repositoriesService.get().repository(repositoryName)) {
 
             assert repository instanceof BlobStoreRepository : "repository should be instance of BlobStoreRepository";
@@ -65,16 +65,30 @@ public Directory newDirectory(String repositoryName, String indexUUID, ShardId s
             BlobPath repositoryBasePath = blobStoreRepository.basePath();
             String shardIdStr = String.valueOf(shardId.id());
 
+            RemoteStorePathStrategy.PathInput dataPathInput = RemoteStorePathStrategy.PathInput.builder()
+                .basePath(repositoryBasePath)
+                .indexUUID(indexUUID)
+                .shardId(shardIdStr)
+                .dataCategory(SEGMENTS)
+                .dataType(DATA)
+                .build();
             // Derive the path for data directory of SEGMENTS
-            BlobPath dataPath = pathType.path(repositoryBasePath, indexUUID, shardIdStr, SEGMENTS, DATA);
+            BlobPath dataPath = pathStrategy.generatePath(dataPathInput);
             RemoteDirectory dataDirectory = new RemoteDirectory(
                 blobStoreRepository.blobStore().blobContainer(dataPath),
                 blobStoreRepository::maybeRateLimitRemoteUploadTransfers,
                 blobStoreRepository::maybeRateLimitRemoteDownloadTransfers
             );
 
+            RemoteStorePathStrategy.PathInput mdPathInput = RemoteStorePathStrategy.PathInput.builder()
+                .basePath(repositoryBasePath)
+                .indexUUID(indexUUID)
+                .shardId(shardIdStr)
+                .dataCategory(SEGMENTS)
+                .dataType(METADATA)
+                .build();
             // Derive the path for metadata directory of SEGMENTS
-            BlobPath mdPath = pathType.path(repositoryBasePath, indexUUID, shardIdStr, SEGMENTS, METADATA);
+            BlobPath mdPath = pathStrategy.generatePath(mdPathInput);
             RemoteDirectory metadataDirectory = new RemoteDirectory(blobStoreRepository.blobStore().blobContainer(mdPath));
 
             // The path for lock is derived within the RemoteStoreLockManagerFactory
@@ -83,7 +97,7 @@ public Directory newDirectory(String repositoryName, String indexUUID, ShardId s
                 repositoryName,
                 indexUUID,
                 shardIdStr,
-                pathType
+                pathStrategy
             );
 
             return new RemoteSegmentStoreDirectory(dataDirectory, metadataDirectory, mdLockManager, threadPool, shardId);
diff --git a/server/src/main/java/org/opensearch/index/store/Store.java b/server/src/main/java/org/opensearch/index/store/Store.java
index 0992d86d6f0aa..56fc5b1ffa90d 100644
--- a/server/src/main/java/org/opensearch/index/store/Store.java
+++ b/server/src/main/java/org/opensearch/index/store/Store.java
@@ -893,7 +893,7 @@ public void beforeClose() {
      * @throws IOException when there is an IO error committing.
      */
     public void commitSegmentInfos(SegmentInfos latestSegmentInfos, long maxSeqNo, long processedCheckpoint) throws IOException {
-        assert indexSettings.isSegRepEnabledOrRemoteNode() || indexSettings.isRemoteNode();
+        assert indexSettings.isSegRepEnabledOrRemoteNode() || indexSettings.isAssignedOnRemoteNode();
         metadataLock.writeLock().lock();
         try {
             final Map<String, String> userData = new HashMap<>(latestSegmentInfos.getUserData());
diff --git a/server/src/main/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactory.java b/server/src/main/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactory.java
index c033e4f7ad0aa..45d466d3a8ce8 100644
--- a/server/src/main/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactory.java
+++ b/server/src/main/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactory.java
@@ -11,7 +11,7 @@
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.blobstore.BlobContainer;
 import org.opensearch.common.blobstore.BlobPath;
-import org.opensearch.index.remote.RemoteStorePathType;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.index.store.RemoteBufferedOutputDirectory;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.Repository;
@@ -20,8 +20,8 @@
 
 import java.util.function.Supplier;
 
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataCategory.SEGMENTS;
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataType.LOCK_FILES;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataCategory.SEGMENTS;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataType.LOCK_FILES;
 
 /**
  * Factory for remote store lock manager
@@ -36,8 +36,13 @@ public RemoteStoreLockManagerFactory(Supplier<RepositoriesService> repositoriesS
         this.repositoriesService = repositoriesService;
     }
 
-    public RemoteStoreLockManager newLockManager(String repositoryName, String indexUUID, String shardId, RemoteStorePathType pathType) {
-        return newLockManager(repositoriesService.get(), repositoryName, indexUUID, shardId, pathType);
+    public RemoteStoreLockManager newLockManager(
+        String repositoryName,
+        String indexUUID,
+        String shardId,
+        RemoteStorePathStrategy pathStrategy
+    ) {
+        return newLockManager(repositoriesService.get(), repositoryName, indexUUID, shardId, pathStrategy);
     }
 
     public static RemoteStoreMetadataLockManager newLockManager(
@@ -45,12 +50,20 @@ public static RemoteStoreMetadataLockManager newLockManager(
         String repositoryName,
         String indexUUID,
         String shardId,
-        RemoteStorePathType pathType
+        RemoteStorePathStrategy pathStrategy
     ) {
         try (Repository repository = repositoriesService.repository(repositoryName)) {
             assert repository instanceof BlobStoreRepository : "repository should be instance of BlobStoreRepository";
             BlobPath repositoryBasePath = ((BlobStoreRepository) repository).basePath();
-            BlobPath lockDirectoryPath = pathType.path(repositoryBasePath, indexUUID, shardId, SEGMENTS, LOCK_FILES);
+
+            RemoteStorePathStrategy.PathInput lockFilesPathInput = RemoteStorePathStrategy.PathInput.builder()
+                .basePath(repositoryBasePath)
+                .indexUUID(indexUUID)
+                .shardId(shardId)
+                .dataCategory(SEGMENTS)
+                .dataType(LOCK_FILES)
+                .build();
+            BlobPath lockDirectoryPath = pathStrategy.generatePath(lockFilesPathInput);
             BlobContainer lockDirectoryBlobContainer = ((BlobStoreRepository) repository).blobStore().blobContainer(lockDirectoryPath);
             return new RemoteStoreMetadataLockManager(new RemoteBufferedOutputDirectory(lockDirectoryBlobContainer));
         } catch (RepositoryMissingException e) {
diff --git a/server/src/main/java/org/opensearch/index/translog/RemoteBlobStoreInternalTranslogFactory.java b/server/src/main/java/org/opensearch/index/translog/RemoteBlobStoreInternalTranslogFactory.java
index e100ffaabf13d..4599aa32325c1 100644
--- a/server/src/main/java/org/opensearch/index/translog/RemoteBlobStoreInternalTranslogFactory.java
+++ b/server/src/main/java/org/opensearch/index/translog/RemoteBlobStoreInternalTranslogFactory.java
@@ -9,6 +9,7 @@
 package org.opensearch.index.translog;
 
 import org.opensearch.index.remote.RemoteTranslogTransferTracker;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.Repository;
 import org.opensearch.repositories.RepositoryMissingException;
@@ -34,11 +35,14 @@ public class RemoteBlobStoreInternalTranslogFactory implements TranslogFactory {
 
     private final RemoteTranslogTransferTracker remoteTranslogTransferTracker;
 
+    private final RemoteStoreSettings remoteStoreSettings;
+
     public RemoteBlobStoreInternalTranslogFactory(
         Supplier<RepositoriesService> repositoriesServiceSupplier,
         ThreadPool threadPool,
         String repositoryName,
-        RemoteTranslogTransferTracker remoteTranslogTransferTracker
+        RemoteTranslogTransferTracker remoteTranslogTransferTracker,
+        RemoteStoreSettings remoteStoreSettings
     ) {
         Repository repository;
         try {
@@ -49,6 +53,7 @@ public RemoteBlobStoreInternalTranslogFactory(
         this.repository = repository;
         this.threadPool = threadPool;
         this.remoteTranslogTransferTracker = remoteTranslogTransferTracker;
+        this.remoteStoreSettings = remoteStoreSettings;
     }
 
     @Override
@@ -74,7 +79,8 @@ public Translog newTranslog(
             blobStoreRepository,
             threadPool,
             startedPrimarySupplier,
-            remoteTranslogTransferTracker
+            remoteTranslogTransferTracker,
+            remoteStoreSettings
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/index/translog/RemoteFsTranslog.java b/server/src/main/java/org/opensearch/index/translog/RemoteFsTranslog.java
index f0fb03cc905a4..67799f0465c29 100644
--- a/server/src/main/java/org/opensearch/index/translog/RemoteFsTranslog.java
+++ b/server/src/main/java/org/opensearch/index/translog/RemoteFsTranslog.java
@@ -19,7 +19,7 @@
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.core.util.FileSystemUtils;
-import org.opensearch.index.remote.RemoteStorePathType;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.index.remote.RemoteTranslogTransferTracker;
 import org.opensearch.index.translog.transfer.BlobStoreTransferService;
 import org.opensearch.index.translog.transfer.FileTransferTracker;
@@ -28,6 +28,7 @@
 import org.opensearch.index.translog.transfer.TranslogTransferManager;
 import org.opensearch.index.translog.transfer.TranslogTransferMetadata;
 import org.opensearch.index.translog.transfer.listener.TranslogTransferListener;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.repositories.Repository;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
 import org.opensearch.threadpool.ThreadPool;
@@ -50,9 +51,9 @@
 import java.util.function.LongConsumer;
 import java.util.function.LongSupplier;
 
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataCategory.TRANSLOG;
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataType.DATA;
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataType.METADATA;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataCategory.TRANSLOG;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataType.DATA;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataType.METADATA;
 
 /**
  * A Translog implementation which syncs local FS with a remote store
@@ -100,7 +101,8 @@ public RemoteFsTranslog(
         BlobStoreRepository blobStoreRepository,
         ThreadPool threadPool,
         BooleanSupplier startedPrimarySupplier,
-        RemoteTranslogTransferTracker remoteTranslogTransferTracker
+        RemoteTranslogTransferTracker remoteTranslogTransferTracker,
+        RemoteStoreSettings remoteStoreSettings
     ) throws IOException {
         super(config, translogUUID, deletionPolicy, globalCheckpointSupplier, primaryTermSupplier, persistedSequenceNumberConsumer);
         logger = Loggers.getLogger(getClass(), shardId);
@@ -113,7 +115,8 @@ public RemoteFsTranslog(
             shardId,
             fileTransferTracker,
             remoteTranslogTransferTracker,
-            indexSettings().getRemoteStorePathType()
+            indexSettings().getRemoteStorePathStrategy(),
+            remoteStoreSettings
         );
         try {
             download(translogTransferManager, location, logger);
@@ -162,7 +165,8 @@ public static void download(
         ShardId shardId,
         ThreadPool threadPool,
         Path location,
-        RemoteStorePathType pathType,
+        RemoteStorePathStrategy pathStrategy,
+        RemoteStoreSettings remoteStoreSettings,
         Logger logger
     ) throws IOException {
         assert repository instanceof BlobStoreRepository : String.format(
@@ -181,7 +185,8 @@ public static void download(
             shardId,
             fileTransferTracker,
             remoteTranslogTransferTracker,
-            pathType
+            pathStrategy,
+            remoteStoreSettings
         );
         RemoteFsTranslog.download(translogTransferManager, location, logger);
         logger.trace(remoteTranslogTransferTracker.toString());
@@ -259,15 +264,30 @@ public static TranslogTransferManager buildTranslogTransferManager(
         ShardId shardId,
         FileTransferTracker fileTransferTracker,
         RemoteTranslogTransferTracker tracker,
-        RemoteStorePathType pathType
+        RemoteStorePathStrategy pathStrategy,
+        RemoteStoreSettings remoteStoreSettings
     ) {
-        assert Objects.nonNull(pathType);
+        assert Objects.nonNull(pathStrategy);
         String indexUUID = shardId.getIndex().getUUID();
         String shardIdStr = String.valueOf(shardId.id());
-        BlobPath dataPath = pathType.path(blobStoreRepository.basePath(), indexUUID, shardIdStr, TRANSLOG, DATA);
-        BlobPath mdPath = pathType.path(blobStoreRepository.basePath(), indexUUID, shardIdStr, TRANSLOG, METADATA);
+        RemoteStorePathStrategy.PathInput dataPathInput = RemoteStorePathStrategy.PathInput.builder()
+            .basePath(blobStoreRepository.basePath())
+            .indexUUID(indexUUID)
+            .shardId(shardIdStr)
+            .dataCategory(TRANSLOG)
+            .dataType(DATA)
+            .build();
+        BlobPath dataPath = pathStrategy.generatePath(dataPathInput);
+        RemoteStorePathStrategy.PathInput mdPathInput = RemoteStorePathStrategy.PathInput.builder()
+            .basePath(blobStoreRepository.basePath())
+            .indexUUID(indexUUID)
+            .shardId(shardIdStr)
+            .dataCategory(TRANSLOG)
+            .dataType(METADATA)
+            .build();
+        BlobPath mdPath = pathStrategy.generatePath(mdPathInput);
         BlobStoreTransferService transferService = new BlobStoreTransferService(blobStoreRepository.blobStore(), threadPool);
-        return new TranslogTransferManager(shardId, transferService, dataPath, mdPath, fileTransferTracker, tracker);
+        return new TranslogTransferManager(shardId, transferService, dataPath, mdPath, fileTransferTracker, tracker, remoteStoreSettings);
     }
 
     @Override
@@ -539,8 +559,13 @@ private void deleteStaleRemotePrimaryTerms() {
         }
     }
 
-    public static void cleanup(Repository repository, ShardId shardId, ThreadPool threadPool, RemoteStorePathType pathType)
-        throws IOException {
+    public static void cleanup(
+        Repository repository,
+        ShardId shardId,
+        ThreadPool threadPool,
+        RemoteStorePathStrategy pathStrategy,
+        RemoteStoreSettings remoteStoreSettings
+    ) throws IOException {
         assert repository instanceof BlobStoreRepository : "repository should be instance of BlobStoreRepository";
         BlobStoreRepository blobStoreRepository = (BlobStoreRepository) repository;
         // We use a dummy stats tracker to ensure the flow doesn't break.
@@ -553,7 +578,8 @@ public static void cleanup(Repository repository, ShardId shardId, ThreadPool th
             shardId,
             fileTransferTracker,
             remoteTranslogTransferTracker,
-            pathType
+            pathStrategy,
+            remoteStoreSettings
         );
         // clean up all remote translog files
         translogTransferManager.deleteTranslogFiles();
diff --git a/server/src/main/java/org/opensearch/index/translog/Translog.java b/server/src/main/java/org/opensearch/index/translog/Translog.java
index e78300e368099..7c50ed6ecd58f 100644
--- a/server/src/main/java/org/opensearch/index/translog/Translog.java
+++ b/server/src/main/java/org/opensearch/index/translog/Translog.java
@@ -525,7 +525,7 @@ TranslogWriter createWriter(
                 tragedy,
                 persistedSequenceNumberConsumer,
                 bigArrays,
-                indexSettings.isRemoteNode()
+                indexSettings.isAssignedOnRemoteNode()
             );
         } catch (final IOException e) {
             throw new TranslogException(shardId, "failed to create new translog file", e);
diff --git a/server/src/main/java/org/opensearch/index/translog/transfer/BlobStoreTransferService.java b/server/src/main/java/org/opensearch/index/translog/transfer/BlobStoreTransferService.java
index 82dd6301ef79f..a1d5041ff9aff 100644
--- a/server/src/main/java/org/opensearch/index/translog/transfer/BlobStoreTransferService.java
+++ b/server/src/main/java/org/opensearch/index/translog/transfer/BlobStoreTransferService.java
@@ -12,8 +12,10 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.action.ActionRunnable;
+import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.common.blobstore.AsyncMultiStreamBlobContainer;
 import org.opensearch.common.blobstore.BlobContainer;
+import org.opensearch.common.blobstore.BlobDownloadResponse;
 import org.opensearch.common.blobstore.BlobMetadata;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.blobstore.BlobStore;
@@ -164,6 +166,12 @@ public InputStream downloadBlob(Iterable<String> path, String fileName) throws I
         return blobStore.blobContainer((BlobPath) path).readBlob(fileName);
     }
 
+    @Override
+    @ExperimentalApi
+    public BlobDownloadResponse downloadBlobWithMetadata(Iterable<String> path, String fileName) throws IOException {
+        return blobStore.blobContainer((BlobPath) path).readBlobWithMetadata(fileName);
+    }
+
     @Override
     public void deleteBlobs(Iterable<String> path, List<String> fileNames) throws IOException {
         blobStore.blobContainer((BlobPath) path).deleteBlobsIgnoringIfNotExists(fileNames);
diff --git a/server/src/main/java/org/opensearch/index/translog/transfer/TransferService.java b/server/src/main/java/org/opensearch/index/translog/transfer/TransferService.java
index cfe833dde87eb..5fe8b02058383 100644
--- a/server/src/main/java/org/opensearch/index/translog/transfer/TransferService.java
+++ b/server/src/main/java/org/opensearch/index/translog/transfer/TransferService.java
@@ -8,6 +8,8 @@
 
 package org.opensearch.index.translog.transfer;
 
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.blobstore.BlobDownloadResponse;
 import org.opensearch.common.blobstore.BlobMetadata;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.blobstore.stream.write.WritePriority;
@@ -125,6 +127,16 @@ void uploadBlobs(
      */
     InputStream downloadBlob(Iterable<String> path, String fileName) throws IOException;
 
+    /**
+     *
+     * @param path  the remote path from where download should be made
+     * @param fileName the name of the file
+     * @return {@link BlobDownloadResponse} of the remote file
+     * @throws IOException the exception while reading the data
+     */
+    @ExperimentalApi
+    BlobDownloadResponse downloadBlobWithMetadata(Iterable<String> path, String fileName) throws IOException;
+
     void listAllInSortedOrder(Iterable<String> path, String filenamePrefix, int limit, ActionListener<List<BlobMetadata>> listener);
 
     void listAllInSortedOrderAsync(
diff --git a/server/src/main/java/org/opensearch/index/translog/transfer/TranslogTransferManager.java b/server/src/main/java/org/opensearch/index/translog/transfer/TranslogTransferManager.java
index c9e07ca3ef8c1..1087244623b87 100644
--- a/server/src/main/java/org/opensearch/index/translog/transfer/TranslogTransferManager.java
+++ b/server/src/main/java/org/opensearch/index/translog/transfer/TranslogTransferManager.java
@@ -28,6 +28,7 @@
 import org.opensearch.index.remote.RemoteTranslogTransferTracker;
 import org.opensearch.index.translog.Translog;
 import org.opensearch.index.translog.transfer.listener.TranslogTransferListener;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.threadpool.ThreadPool;
 
 import java.io.IOException;
@@ -60,9 +61,7 @@ public class TranslogTransferManager {
     private final BlobPath remoteMetadataTransferPath;
     private final FileTransferTracker fileTransferTracker;
     private final RemoteTranslogTransferTracker remoteTranslogTransferTracker;
-
-    private static final long TRANSFER_TIMEOUT_IN_MILLIS = 30000;
-
+    private final RemoteStoreSettings remoteStoreSettings;
     private static final int METADATA_FILES_TO_FETCH = 10;
 
     private final Logger logger;
@@ -79,7 +78,8 @@ public TranslogTransferManager(
         BlobPath remoteDataTransferPath,
         BlobPath remoteMetadataTransferPath,
         FileTransferTracker fileTransferTracker,
-        RemoteTranslogTransferTracker remoteTranslogTransferTracker
+        RemoteTranslogTransferTracker remoteTranslogTransferTracker,
+        RemoteStoreSettings remoteStoreSettings
     ) {
         this.shardId = shardId;
         this.transferService = transferService;
@@ -88,6 +88,7 @@ public TranslogTransferManager(
         this.fileTransferTracker = fileTransferTracker;
         this.logger = Loggers.getLogger(getClass(), shardId);
         this.remoteTranslogTransferTracker = remoteTranslogTransferTracker;
+        this.remoteStoreSettings = remoteStoreSettings;
     }
 
     public RemoteTranslogTransferTracker getRemoteTranslogTransferTracker() {
@@ -151,7 +152,7 @@ public boolean transferSnapshot(TransferSnapshot transferSnapshot, TranslogTrans
             transferService.uploadBlobs(toUpload, blobPathMap, latchedActionListener, WritePriority.HIGH);
 
             try {
-                if (latch.await(TRANSFER_TIMEOUT_IN_MILLIS, TimeUnit.MILLISECONDS) == false) {
+                if (latch.await(remoteStoreSettings.getClusterRemoteTranslogTransferTimeout().millis(), TimeUnit.MILLISECONDS) == false) {
                     Exception ex = new TranslogUploadFailedException(
                         "Timed out waiting for transfer of snapshot " + transferSnapshot + " to complete"
                     );
diff --git a/server/src/main/java/org/opensearch/indices/IndicesModule.java b/server/src/main/java/org/opensearch/indices/IndicesModule.java
index b86e98f4ebcbc..d2c26157b1963 100644
--- a/server/src/main/java/org/opensearch/indices/IndicesModule.java
+++ b/server/src/main/java/org/opensearch/indices/IndicesModule.java
@@ -46,8 +46,10 @@
 import org.opensearch.index.mapper.BinaryFieldMapper;
 import org.opensearch.index.mapper.BooleanFieldMapper;
 import org.opensearch.index.mapper.CompletionFieldMapper;
+import org.opensearch.index.mapper.ConstantKeywordFieldMapper;
 import org.opensearch.index.mapper.DataStreamFieldMapper;
 import org.opensearch.index.mapper.DateFieldMapper;
+import org.opensearch.index.mapper.DerivedFieldMapper;
 import org.opensearch.index.mapper.DocCountFieldMapper;
 import org.opensearch.index.mapper.FieldAliasMapper;
 import org.opensearch.index.mapper.FieldNamesFieldMapper;
@@ -168,6 +170,8 @@ public static Map<String, Mapper.TypeParser> getMappers(List<MapperPlugin> mappe
         mappers.put(FieldAliasMapper.CONTENT_TYPE, new FieldAliasMapper.TypeParser());
         mappers.put(GeoPointFieldMapper.CONTENT_TYPE, new GeoPointFieldMapper.TypeParser());
         mappers.put(FlatObjectFieldMapper.CONTENT_TYPE, FlatObjectFieldMapper.PARSER);
+        mappers.put(ConstantKeywordFieldMapper.CONTENT_TYPE, new ConstantKeywordFieldMapper.TypeParser());
+        mappers.put(DerivedFieldMapper.CONTENT_TYPE, DerivedFieldMapper.PARSER);
 
         for (MapperPlugin mapperPlugin : mapperPlugins) {
             for (Map.Entry<String, Mapper.TypeParser> entry : mapperPlugin.getMappers().entrySet()) {
diff --git a/server/src/main/java/org/opensearch/indices/IndicesService.java b/server/src/main/java/org/opensearch/indices/IndicesService.java
index 28ad4b23e319c..75130a4041b77 100644
--- a/server/src/main/java/org/opensearch/indices/IndicesService.java
+++ b/server/src/main/java/org/opensearch/indices/IndicesService.java
@@ -54,6 +54,7 @@
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.service.ClusterService;
@@ -123,7 +124,7 @@
 import org.opensearch.index.query.QueryRewriteContext;
 import org.opensearch.index.recovery.RecoveryStats;
 import org.opensearch.index.refresh.RefreshStats;
-import org.opensearch.index.remote.RemoteStorePathType;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
 import org.opensearch.index.remote.RemoteStoreStatsTrackerFactory;
 import org.opensearch.index.search.stats.SearchStats;
 import org.opensearch.index.seqno.RetentionLeaseStats;
@@ -309,10 +310,10 @@ public class IndicesService extends AbstractLifecycleComponent
      * This setting is used to set the remote store blob store path prefix strategy. This setting is effective only for
      * remote store enabled cluster.
      */
-    public static final Setting<RemoteStorePathType> CLUSTER_REMOTE_STORE_PATH_PREFIX_TYPE_SETTING = new Setting<>(
+    public static final Setting<PathType> CLUSTER_REMOTE_STORE_PATH_PREFIX_TYPE_SETTING = new Setting<>(
         "cluster.remote_store.index.path.prefix.type",
-        RemoteStorePathType.FIXED.toString(),
-        RemoteStorePathType::parseString,
+        PathType.FIXED.toString(),
+        PathType::parseString,
         Property.NodeScope,
         Property.Dynamic
     );
@@ -497,7 +498,8 @@ protected void closeInternal() {
             repositoriesServiceSupplier,
             threadPool,
             remoteStoreStatsTrackerFactory,
-            settings
+            settings,
+            remoteStoreSettings
         );
         this.searchRequestStats = searchRequestStats;
         this.clusterDefaultRefreshInterval = CLUSTER_DEFAULT_INDEX_REFRESH_INTERVAL_SETTING.get(clusterService.getSettings());
@@ -527,7 +529,8 @@ private static BiFunction<IndexSettings, ShardRouting, TranslogFactory> getTrans
         Supplier<RepositoriesService> repositoriesServiceSupplier,
         ThreadPool threadPool,
         RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
-        Settings settings
+        Settings settings,
+        RemoteStoreSettings remoteStoreSettings
     ) {
         return (indexSettings, shardRouting) -> {
             if (indexSettings.isRemoteTranslogStoreEnabled() && shardRouting.primary()) {
@@ -535,14 +538,16 @@ private static BiFunction<IndexSettings, ShardRouting, TranslogFactory> getTrans
                     repositoriesServiceSupplier,
                     threadPool,
                     indexSettings.getRemoteStoreTranslogRepository(),
-                    remoteStoreStatsTrackerFactory.getRemoteTranslogTransferTracker(shardRouting.shardId())
+                    remoteStoreStatsTrackerFactory.getRemoteTranslogTransferTracker(shardRouting.shardId()),
+                    remoteStoreSettings
                 );
             } else if (isRemoteDataAttributePresent(settings) && shardRouting.primary()) {
                 return new RemoteBlobStoreInternalTranslogFactory(
                     repositoriesServiceSupplier,
                     threadPool,
                     RemoteStoreNodeAttribute.getRemoteStoreTranslogRepo(indexSettings.getNodeSettings()),
-                    remoteStoreStatsTrackerFactory.getRemoteTranslogTransferTracker(shardRouting.shardId())
+                    remoteStoreStatsTrackerFactory.getRemoteTranslogTransferTracker(shardRouting.shardId()),
+                    remoteStoreSettings
                 );
             }
             return new InternalTranslogFactory();
@@ -933,7 +938,7 @@ private EngineFactory getEngineFactory(final IndexSettings idxSettings) {
             if (idxSettings.isRemoteSnapshot()) {
                 return config -> new ReadOnlyEngine(config, new SeqNoStats(0, 0, 0), new TranslogStats(), true, Function.identity(), false);
             }
-            if (idxSettings.isSegRepEnabledOrRemoteNode() || idxSettings.isRemoteNode()) {
+            if (idxSettings.isSegRepEnabledOrRemoteNode() || idxSettings.isAssignedOnRemoteNode()) {
                 return new NRTReplicationEngineFactory();
             }
             return new InternalEngineFactory();
@@ -1021,7 +1026,8 @@ public IndexShard createShard(
         final RetentionLeaseSyncer retentionLeaseSyncer,
         final DiscoveryNode targetNode,
         final DiscoveryNode sourceNode,
-        final RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory
+        final RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
+        final DiscoveryNodes discoveryNodes
     ) throws IOException {
         Objects.requireNonNull(retentionLeaseSyncer);
         ensureChangesAllowed();
@@ -1036,7 +1042,8 @@ public IndexShard createShard(
             remoteStoreStatsTrackerFactory,
             repositoriesService,
             targetNode,
-            sourceNode
+            sourceNode,
+            discoveryNodes
         );
         indexShard.addShardFailureCallback(onShardFailure);
         indexShard.startRecovery(recoveryState, recoveryTargetService, recoveryListener, repositoriesService, mapping -> {
diff --git a/server/src/main/java/org/opensearch/indices/RemoteStoreSettings.java b/server/src/main/java/org/opensearch/indices/RemoteStoreSettings.java
index 5e6dba2b398db..7f2121093f8e8 100644
--- a/server/src/main/java/org/opensearch/indices/RemoteStoreSettings.java
+++ b/server/src/main/java/org/opensearch/indices/RemoteStoreSettings.java
@@ -54,8 +54,20 @@ public class RemoteStoreSettings {
         Property.Dynamic
     );
 
+    /**
+     * Controls timeout value while uploading translog and checkpoint files to remote translog
+     */
+    public static final Setting<TimeValue> CLUSTER_REMOTE_TRANSLOG_TRANSFER_TIMEOUT_SETTING = Setting.timeSetting(
+        "cluster.remote_store.translog.transfer_timeout",
+        TimeValue.timeValueSeconds(30),
+        TimeValue.timeValueSeconds(30),
+        Property.NodeScope,
+        Property.Dynamic
+    );
+
     private volatile TimeValue clusterRemoteTranslogBufferInterval;
     private volatile int minRemoteSegmentMetadataFiles;
+    private volatile TimeValue clusterRemoteTranslogTransferTimeout;
 
     public RemoteStoreSettings(Settings settings, ClusterSettings clusterSettings) {
         this.clusterRemoteTranslogBufferInterval = CLUSTER_REMOTE_TRANSLOG_BUFFER_INTERVAL_SETTING.get(settings);
@@ -69,9 +81,14 @@ public RemoteStoreSettings(Settings settings, ClusterSettings clusterSettings) {
             CLUSTER_REMOTE_INDEX_SEGMENT_METADATA_RETENTION_MAX_COUNT_SETTING,
             this::setMinRemoteSegmentMetadataFiles
         );
+
+        this.clusterRemoteTranslogTransferTimeout = CLUSTER_REMOTE_TRANSLOG_TRANSFER_TIMEOUT_SETTING.get(settings);
+        clusterSettings.addSettingsUpdateConsumer(
+            CLUSTER_REMOTE_TRANSLOG_TRANSFER_TIMEOUT_SETTING,
+            this::setClusterRemoteTranslogTransferTimeout
+        );
     }
 
-    // Exclusively for testing, please do not use it elsewhere.
     public TimeValue getClusterRemoteTranslogBufferInterval() {
         return clusterRemoteTranslogBufferInterval;
     }
@@ -87,4 +104,12 @@ private void setMinRemoteSegmentMetadataFiles(int minRemoteSegmentMetadataFiles)
     public int getMinRemoteSegmentMetadataFiles() {
         return this.minRemoteSegmentMetadataFiles;
     }
+
+    public TimeValue getClusterRemoteTranslogTransferTimeout() {
+        return clusterRemoteTranslogTransferTimeout;
+    }
+
+    private void setClusterRemoteTranslogTransferTimeout(TimeValue clusterRemoteTranslogTransferTimeout) {
+        this.clusterRemoteTranslogTransferTimeout = clusterRemoteTranslogTransferTimeout;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/indices/cluster/IndicesClusterStateService.java b/server/src/main/java/org/opensearch/indices/cluster/IndicesClusterStateService.java
index 7fb8b172ae352..2c3ffcdd9e0ba 100644
--- a/server/src/main/java/org/opensearch/indices/cluster/IndicesClusterStateService.java
+++ b/server/src/main/java/org/opensearch/indices/cluster/IndicesClusterStateService.java
@@ -680,7 +680,8 @@ private void createShard(DiscoveryNodes nodes, RoutingTable routingTable, ShardR
                 retentionLeaseSyncer,
                 nodes.getLocalNode(),
                 sourceNode,
-                remoteStoreStatsTrackerFactory
+                remoteStoreStatsTrackerFactory,
+                nodes
             );
         } catch (Exception e) {
             failAndRemoveShard(shardRouting, true, "failed to create shard", e, state);
@@ -714,7 +715,8 @@ private void updateShard(
                 primaryReplicaSyncer::resync,
                 clusterState.version(),
                 inSyncIds,
-                indexShardRoutingTable
+                indexShardRoutingTable,
+                nodes
             );
         } catch (Exception e) {
             failAndRemoveShard(shardRouting, true, "failed updating shard routing entry", e, clusterState);
@@ -922,7 +924,8 @@ void updateShardState(
             BiConsumer<IndexShard, ActionListener<ResyncTask>> primaryReplicaSyncer,
             long applyingClusterStateVersion,
             Set<String> inSyncAllocationIds,
-            IndexShardRoutingTable routingTable
+            IndexShardRoutingTable routingTable,
+            DiscoveryNodes discoveryNodes
         ) throws IOException;
     }
 
@@ -1040,7 +1043,8 @@ T createShard(
             RetentionLeaseSyncer retentionLeaseSyncer,
             DiscoveryNode targetNode,
             @Nullable DiscoveryNode sourceNode,
-            RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory
+            RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
+            DiscoveryNodes discoveryNodes
         ) throws IOException;
 
         /**
diff --git a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
index 227496f72f83d..c24840d0c1333 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
@@ -261,7 +261,7 @@ private void doRecovery(final long recoveryId, final StartRecoveryRequest preExi
                         }
                     }
                     final boolean hasRemoteTranslog = recoveryTarget.state().getPrimary() == false
-                        && indexShard.indexSettings().isRemoteNode();
+                        && indexShard.indexSettings().isAssignedOnRemoteNode();
                     final boolean hasNoTranslog = indexShard.indexSettings().isRemoteSnapshot();
                     final boolean verifyTranslog = (hasRemoteTranslog || hasNoTranslog || hasRemoteSegmentStore) == false;
                     final long startingSeqNo = indexShard.recoverLocallyAndFetchStartSeqNo(!hasRemoteTranslog);
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandlerFactory.java b/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandlerFactory.java
index 0ccb1ac2133cf..96e85154e6248 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandlerFactory.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandlerFactory.java
@@ -23,8 +23,7 @@ public static RecoverySourceHandler create(
         StartRecoveryRequest request,
         RecoverySettings recoverySettings
     ) {
-        boolean isReplicaRecoveryWithRemoteTranslog = request.isPrimaryRelocation() == false
-            && (shard.isRemoteTranslogEnabled() || shard.isMigratingToRemote());
+        boolean isReplicaRecoveryWithRemoteTranslog = request.isPrimaryRelocation() == false && request.targetNode().isRemoteStoreNode();
         if (isReplicaRecoveryWithRemoteTranslog) {
             return new RemoteStorePeerRecoverySourceHandler(
                 shard,
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RecoveryTarget.java b/server/src/main/java/org/opensearch/indices/recovery/RecoveryTarget.java
index 16311d5d2cfb7..f47b082de3856 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RecoveryTarget.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RecoveryTarget.java
@@ -213,10 +213,17 @@ public void prepareForTranslogOperations(int totalTranslogOps, ActionListener<Vo
         ActionListener.completeWith(listener, () -> {
             state().getIndex().setFileDetailsComplete(); // ops-based recoveries don't send the file details
             state().getTranslog().totalOperations(totalTranslogOps);
+            // Cleanup remote contents before opening new translog.
+            // This prevents reading from any old Translog UUIDs during re-seeding
+            // (situation in which primary fails over to docrep replica and is re-seeded to remote again)
+            // which might end up causing a TranslogCorruptedException
+            if (indexShard.shouldSeedRemoteStore()) {
+                assert indexShard.routingEntry().primary() : "Remote seeding should only true be for primary shard copy";
+                indexShard.deleteRemoteStoreContents();
+            }
             indexShard().openEngineAndSkipTranslogRecovery();
             // upload to remote store in migration for primary shard
-            if (indexShard.shouldSeedRemoteStore() && indexShard.routingEntry().primary()) {
-                indexShard.deleteRemoteStoreContents();
+            if (indexShard.shouldSeedRemoteStore()) {
                 // This cleans up remote translog's 0 generation, as we don't want to get that uploaded
                 indexShard.sync();
                 threadPool.executor(ThreadPool.Names.GENERIC).execute(() -> { indexShard.refresh("remote store migration"); });
diff --git a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationSourceFactory.java b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationSourceFactory.java
index 852003c9f3e4d..81eb38757aebe 100644
--- a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationSourceFactory.java
+++ b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationSourceFactory.java
@@ -38,7 +38,7 @@ public SegmentReplicationSourceFactory(
     }
 
     public SegmentReplicationSource get(IndexShard shard) {
-        if (shard.indexSettings().isSegRepWithRemoteEnabled()) {
+        if (shard.indexSettings().isAssignedOnRemoteNode()) {
             return new RemoteStoreReplicationSource(shard);
         } else {
             return new PrimaryShardReplicationSource(
diff --git a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
index 821ae42e31881..8f39aa194b06c 100644
--- a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
+++ b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
@@ -98,7 +98,7 @@ protected void doExecute(Task task, PublishCheckpointRequest request, ActionList
 
     @Override
     public ReplicationMode getReplicationMode(IndexShard indexShard) {
-        if (indexShard.isRemoteTranslogEnabled()) {
+        if (indexShard.indexSettings().isAssignedOnRemoteNode()) {
             return ReplicationMode.FULL_REPLICATION;
         }
         return super.getReplicationMode(indexShard);
@@ -199,6 +199,12 @@ protected void shardOperationOnReplica(PublishCheckpointRequest request, IndexSh
         Objects.requireNonNull(replica);
         ActionListener.completeWith(listener, () -> {
             logger.trace(() -> new ParameterizedMessage("Checkpoint {} received on replica {}", request, replica.shardId()));
+            // Condition for ensuring that we ignore Segrep checkpoints received on Docrep shard copies.
+            // This case will hit iff the replica hosting node is not remote enabled and replication type != SEGMENT
+            if (replica.indexSettings().isAssignedOnRemoteNode() == false && replica.indexSettings().isSegRepLocalEnabled() == false) {
+                logger.trace("Received segrep checkpoint on a docrep shard copy during an ongoing remote migration. NoOp.");
+                return new ReplicaResult();
+            }
             if (request.getCheckpoint().getShardId().equals(replica.shardId())) {
                 replicationService.onNewCheckpoint(request.getCheckpoint(), replica);
             }
diff --git a/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java b/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
index a7c2fb03285b0..ce2ffd8bf3fb4 100644
--- a/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
+++ b/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
@@ -108,7 +108,7 @@
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.index.mapper.MapperService;
-import org.opensearch.index.remote.RemoteStorePathType;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.index.snapshots.IndexShardRestoreFailedException;
 import org.opensearch.index.snapshots.IndexShardSnapshotStatus;
 import org.opensearch.index.snapshots.blobstore.BlobStoreIndexShardSnapshot;
@@ -671,7 +671,7 @@ public void cloneRemoteStoreIndexShardSnapshot(
                 remoteStoreRepository,
                 indexUUID,
                 String.valueOf(shardId.shardId()),
-                RemoteStorePathType.FIXED // TODO - The path type needs to be obtained from RemoteStoreShardShallowCopySnapshot
+                remStoreBasedShardMetadata.getRemoteStorePathStrategy()
             );
             remoteStoreMetadataLockManger.cloneLock(
                 FileLockInfo.getLockInfoBuilder().withAcquirerId(source.getUUID()).build(),
@@ -1110,7 +1110,7 @@ public static void remoteDirectoryCleanupAsync(
         String indexUUID,
         ShardId shardId,
         String threadPoolName,
-        RemoteStorePathType pathType
+        RemoteStorePathStrategy pathStrategy
     ) {
         threadpool.executor(threadPoolName)
             .execute(
@@ -1120,7 +1120,7 @@ public static void remoteDirectoryCleanupAsync(
                         remoteStoreRepoForIndex,
                         indexUUID,
                         shardId,
-                        pathType
+                        pathStrategy
                     ),
                     indexUUID,
                     shardId
@@ -1152,7 +1152,7 @@ protected void releaseRemoteStoreLockAndCleanup(
             remoteStoreRepoForIndex,
             indexUUID,
             shardId,
-            RemoteStorePathType.HASHED_PREFIX // TODO - The path type needs to be obtained from RemoteStoreShardShallowCopySnapshot
+            remoteStoreShardShallowCopySnapshot.getRemoteStorePathStrategy()
         );
         remoteStoreMetadataLockManager.release(FileLockInfo.getLockInfoBuilder().withAcquirerId(shallowSnapshotUUID).build());
         logger.debug("Successfully released lock for shard {} of index with uuid {}", shardId, indexUUID);
@@ -1175,7 +1175,7 @@ protected void releaseRemoteStoreLockAndCleanup(
                 indexUUID,
                 new ShardId(Index.UNKNOWN_INDEX_NAME, indexUUID, Integer.parseInt(shardId)),
                 ThreadPool.Names.REMOTE_PURGE,
-                RemoteStorePathType.FIXED // TODO - The path type needs to be obtained from RemoteStoreShardShallowCopySnapshot
+                remoteStoreShardShallowCopySnapshot.getRemoteStorePathStrategy()
             );
         }
     }
@@ -2690,6 +2690,7 @@ public void snapshotRemoteStoreIndexShard(
             // now create and write the commit point
             logger.trace("[{}] [{}] writing shard snapshot file", shardId, snapshotId);
             try {
+                RemoteStorePathStrategy pathStrategy = store.indexSettings().getRemoteStorePathStrategy();
                 REMOTE_STORE_SHARD_SHALLOW_COPY_SNAPSHOT_FORMAT.write(
                     new RemoteStoreShardShallowCopySnapshot(
                         snapshotId.getName(),
@@ -2703,7 +2704,9 @@ public void snapshotRemoteStoreIndexShard(
                         store.indexSettings().getUUID(),
                         store.indexSettings().getRemoteStoreRepository(),
                         this.basePath().toString(),
-                        fileNames
+                        fileNames,
+                        pathStrategy.getType(),
+                        pathStrategy.getHashAlgorithm()
                     ),
                     shardContainer,
                     snapshotId.getUUID(),
diff --git a/server/src/main/java/org/opensearch/script/DerivedFieldScript.java b/server/src/main/java/org/opensearch/script/DerivedFieldScript.java
index 7f5b991950ec6..e9988ec5aeef2 100644
--- a/server/src/main/java/org/opensearch/script/DerivedFieldScript.java
+++ b/server/src/main/java/org/opensearch/script/DerivedFieldScript.java
@@ -9,14 +9,17 @@
 package org.opensearch.script;
 
 import org.apache.lucene.index.LeafReaderContext;
-import org.opensearch.common.logging.DeprecationLogger;
+import org.opensearch.common.collect.Tuple;
 import org.opensearch.index.fielddata.ScriptDocValues;
 import org.opensearch.search.lookup.LeafSearchLookup;
 import org.opensearch.search.lookup.SearchLookup;
 import org.opensearch.search.lookup.SourceLookup;
 
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
 
@@ -30,7 +33,7 @@ public abstract class DerivedFieldScript {
 
     public static final String[] PARAMETERS = {};
     public static final ScriptContext<Factory> CONTEXT = new ScriptContext<>("derived_field", Factory.class);
-    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(DynamicMap.class);
+    private static final int MAX_BYTE_SIZE = 1024 * 1024; // Maximum allowed byte size (1 MB)
 
     private static final Map<String, Function<Object, Object>> PARAMS_FUNCTIONS = Map.of(
         "doc",
@@ -49,16 +52,27 @@ public abstract class DerivedFieldScript {
      */
     private final LeafSearchLookup leafLookup;
 
+    /**
+     * The field values emitted from the script.
+     */
+    private List<Object> emittedValues;
+
+    private int totalByteSize;
+
     public DerivedFieldScript(Map<String, Object> params, SearchLookup lookup, LeafReaderContext leafContext) {
         Map<String, Object> parameters = new HashMap<>(params);
         this.leafLookup = lookup.getLeafSearchLookup(leafContext);
         parameters.putAll(leafLookup.asMap());
         this.params = new DynamicMap(parameters, PARAMS_FUNCTIONS);
+        this.emittedValues = new ArrayList<>();
+        this.totalByteSize = 0;
     }
 
-    protected DerivedFieldScript() {
-        params = null;
-        leafLookup = null;
+    public DerivedFieldScript() {
+        this.params = null;
+        this.leafLookup = null;
+        this.emittedValues = new ArrayList<>();
+        this.totalByteSize = 0;
     }
 
     /**
@@ -75,14 +89,54 @@ public Map<String, ScriptDocValues<?>> getDoc() {
         return leafLookup.doc();
     }
 
+    /**
+     * Return the emitted values from the script execution.
+     */
+    public List<Object> getEmittedValues() {
+        return emittedValues;
+    }
+
     /**
      * Set the current document to run the script on next.
+     * Clears the emittedValues as well since they should be scoped per document.
      */
     public void setDocument(int docid) {
+        this.emittedValues = new ArrayList<>();
+        this.totalByteSize = 0;
         leafLookup.setDocument(docid);
     }
 
-    public abstract Object execute();
+    public void addEmittedValue(Object o) {
+        int byteSize = getObjectByteSize(o);
+        int newTotalByteSize = totalByteSize + byteSize;
+        if (newTotalByteSize <= MAX_BYTE_SIZE) {
+            emittedValues.add(o);
+            totalByteSize = newTotalByteSize;
+        } else {
+            throw new IllegalStateException("Exceeded maximum allowed byte size for emitted values");
+        }
+    }
+
+    private int getObjectByteSize(Object obj) {
+        if (obj instanceof String) {
+            return ((String) obj).getBytes(StandardCharsets.UTF_8).length;
+        } else if (obj instanceof Integer) {
+            return Integer.BYTES;
+        } else if (obj instanceof Long) {
+            return Long.BYTES;
+        } else if (obj instanceof Double) {
+            return Double.BYTES;
+        } else if (obj instanceof Boolean) {
+            return Byte.BYTES; // Assuming 1 byte for boolean
+        } else if (obj instanceof Tuple) {
+            // Assuming each element in the tuple is a double for GeoPoint case
+            return Double.BYTES * 2;
+        } else {
+            throw new IllegalArgumentException("Unsupported object type passed in emit()");
+        }
+    }
+
+    public void execute() {}
 
     /**
      * A factory to construct {@link DerivedFieldScript} instances.
@@ -95,7 +149,6 @@ public interface LeafFactory {
 
     /**
      * A factory to construct stateful {@link DerivedFieldScript} factories for a specific index.
-     *
      * @opensearch.internal
      */
     public interface Factory extends ScriptFactory {
diff --git a/server/src/main/java/org/opensearch/script/ScriptEmitValues.java b/server/src/main/java/org/opensearch/script/ScriptEmitValues.java
new file mode 100644
index 0000000000000..5d12f36442179
--- /dev/null
+++ b/server/src/main/java/org/opensearch/script/ScriptEmitValues.java
@@ -0,0 +1,63 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.script;
+
+import org.opensearch.common.collect.Tuple;
+
+/**
+ * Values that can be emitted in a derived field script context.
+ * <p>
+ * The emit function can be called multiple times within a script definition
+ * so the function will handle collecting the values over the script execution.
+ */
+public final class ScriptEmitValues {
+
+    /**
+     * Takes in a single value and emits it
+     * Could be a long, double, String, etc.
+     */
+    public static final class EmitSingle {
+
+        private final DerivedFieldScript derivedFieldScript;
+
+        public EmitSingle(DerivedFieldScript derivedFieldScript) {
+            this.derivedFieldScript = derivedFieldScript;
+        }
+
+        // TODO: Keeping this generic for the time being due to limitations with
+        // binding methods with the same name and arity.
+        // Ideally, we should have an emit signature per derived field type and try to scope
+        // that to the respective script execution so the other emits aren't allowed.
+        // One way to do this could be to create implementations of the DerivedFieldScript.LeafFactory
+        // per field type where they each define their own emit() method and then the engine that executes
+        // it can have custom compilation logic to perform class bindings on that emit implementation.
+        public void emit(Object val) {
+            derivedFieldScript.addEmittedValue(val);
+        }
+
+    }
+
+    /**
+     * Emits a GeoPoint value
+     */
+    public static final class GeoPoint {
+
+        private final DerivedFieldScript derivedFieldScript;
+
+        public GeoPoint(DerivedFieldScript derivedFieldScript) {
+            this.derivedFieldScript = derivedFieldScript;
+        }
+
+        public void emit(double lat, double lon) {
+            derivedFieldScript.addEmittedValue(new Tuple<>(lat, lon));
+        }
+
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/snapshots/RestoreService.java b/server/src/main/java/org/opensearch/snapshots/RestoreService.java
index da2a36cbb0701..ff393ecf19a99 100644
--- a/server/src/main/java/org/opensearch/snapshots/RestoreService.java
+++ b/server/src/main/java/org/opensearch/snapshots/RestoreService.java
@@ -451,7 +451,7 @@ public ClusterState execute(ClusterState currentState) {
                                             .put(snapshotIndexMetadata.getSettings())
                                             .put(IndexMetadata.SETTING_INDEX_UUID, UUIDs.randomBase64UUID())
                                     );
-                                    createIndexService.addRemoteStorePathTypeInCustomData(indexMdBuilder, false);
+                                    createIndexService.addRemoteStorePathStrategyInCustomData(indexMdBuilder, false);
                                     shardLimitValidator.validateShardLimit(
                                         renamedIndexName,
                                         snapshotIndexMetadata.getSettings(),
diff --git a/server/src/main/java/org/opensearch/transport/Header.java b/server/src/main/java/org/opensearch/transport/Header.java
index 57c1da6f46aec..ac30df8dda02c 100644
--- a/server/src/main/java/org/opensearch/transport/Header.java
+++ b/server/src/main/java/org/opensearch/transport/Header.java
@@ -75,11 +75,11 @@ public int getNetworkMessageSize() {
         return networkMessageSize;
     }
 
-    Version getVersion() {
+    public Version getVersion() {
         return version;
     }
 
-    long getRequestId() {
+    public long getRequestId() {
         return requestId;
     }
 
@@ -87,7 +87,7 @@ byte getStatus() {
         return status;
     }
 
-    boolean isRequest() {
+    public boolean isRequest() {
         return TransportStatus.isRequest(status);
     }
 
@@ -99,7 +99,7 @@ boolean isError() {
         return TransportStatus.isError(status);
     }
 
-    boolean isHandshake() {
+    public boolean isHandshake() {
         return TransportStatus.isHandshake(status);
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/InboundBytesHandler.java b/server/src/main/java/org/opensearch/transport/InboundBytesHandler.java
new file mode 100644
index 0000000000000..276891212e43f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/InboundBytesHandler.java
@@ -0,0 +1,32 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.transport;
+
+import org.opensearch.common.bytes.ReleasableBytesReference;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.function.BiConsumer;
+
+/**
+ * Interface for handling inbound bytes. Can be implemented by different transport protocols.
+ */
+public interface InboundBytesHandler extends Closeable {
+
+    public void doHandleBytes(
+        TcpChannel channel,
+        ReleasableBytesReference reference,
+        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler
+    ) throws IOException;
+
+    public boolean canHandleBytes(ReleasableBytesReference reference);
+
+    @Override
+    void close();
+}
diff --git a/server/src/main/java/org/opensearch/transport/InboundDecoder.java b/server/src/main/java/org/opensearch/transport/InboundDecoder.java
index 82fc09a985446..d6b7a98e876b3 100644
--- a/server/src/main/java/org/opensearch/transport/InboundDecoder.java
+++ b/server/src/main/java/org/opensearch/transport/InboundDecoder.java
@@ -50,8 +50,8 @@
  */
 public class InboundDecoder implements Releasable {
 
-    static final Object PING = new Object();
-    static final Object END_CONTENT = new Object();
+    public static final Object PING = new Object();
+    public static final Object END_CONTENT = new Object();
 
     private final Version version;
     private final PageCacheRecycler recycler;
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index a8315c3cae4e0..6492900c49a0e 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -32,35 +32,14 @@
 
 package org.opensearch.transport;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.apache.lucene.util.BytesRef;
-import org.opensearch.Version;
 import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.concurrent.AbstractRunnable;
-import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.core.common.io.stream.ByteBufferStreamInput;
-import org.opensearch.core.common.io.stream.NamedWriteableAwareStreamInput;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
-import org.opensearch.core.common.io.stream.StreamInput;
-import org.opensearch.core.common.transport.TransportAddress;
-import org.opensearch.core.transport.TransportResponse;
-import org.opensearch.telemetry.tracing.Span;
-import org.opensearch.telemetry.tracing.SpanBuilder;
-import org.opensearch.telemetry.tracing.SpanScope;
 import org.opensearch.telemetry.tracing.Tracer;
-import org.opensearch.telemetry.tracing.channels.TraceableTcpTransportChannel;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.nativeprotocol.NativeInboundMessage;
 
-import java.io.EOFException;
 import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.nio.ByteBuffer;
-import java.util.Collection;
-import java.util.Collections;
 import java.util.Map;
-import java.util.stream.Collectors;
 
 /**
  * Handler for inbound data
@@ -69,21 +48,13 @@
  */
 public class InboundHandler {
 
-    private static final Logger logger = LogManager.getLogger(InboundHandler.class);
-
     private final ThreadPool threadPool;
-    private final OutboundHandler outboundHandler;
-    private final NamedWriteableRegistry namedWriteableRegistry;
-    private final TransportHandshaker handshaker;
-    private final TransportKeepAlive keepAlive;
-    private final Transport.ResponseHandlers responseHandlers;
-    private final Transport.RequestHandlers requestHandlers;
 
     private volatile TransportMessageListener messageListener = TransportMessageListener.NOOP_LISTENER;
 
     private volatile long slowLogThresholdMs = Long.MAX_VALUE;
 
-    private final Tracer tracer;
+    private final Map<String, ProtocolMessageHandler> protocolMessageHandlers;
 
     InboundHandler(
         ThreadPool threadPool,
@@ -96,13 +67,19 @@ public class InboundHandler {
         Tracer tracer
     ) {
         this.threadPool = threadPool;
-        this.outboundHandler = outboundHandler;
-        this.namedWriteableRegistry = namedWriteableRegistry;
-        this.handshaker = handshaker;
-        this.keepAlive = keepAlive;
-        this.requestHandlers = requestHandlers;
-        this.responseHandlers = responseHandlers;
-        this.tracer = tracer;
+        this.protocolMessageHandlers = Map.of(
+            NativeInboundMessage.NATIVE_PROTOCOL,
+            new NativeMessageHandler(
+                threadPool,
+                outboundHandler,
+                namedWriteableRegistry,
+                handshaker,
+                requestHandlers,
+                responseHandlers,
+                tracer,
+                keepAlive
+            )
+        );
     }
 
     void setMessageListener(TransportMessageListener listener) {
@@ -117,377 +94,17 @@ void setSlowLogThreshold(TimeValue slowLogThreshold) {
         this.slowLogThresholdMs = slowLogThreshold.getMillis();
     }
 
-    void inboundMessage(TcpChannel channel, InboundMessage message) throws Exception {
+    void inboundMessage(TcpChannel channel, ProtocolInboundMessage message) throws Exception {
         final long startTime = threadPool.relativeTimeInMillis();
         channel.getChannelStats().markAccessed(startTime);
-        TransportLogger.logInboundMessage(channel, message);
-        if (message.isPing()) {
-            keepAlive.receiveKeepAlive(channel);
-        } else {
-            messageReceived(channel, message, startTime);
-        }
-    }
-
-    // Empty stream constant to avoid instantiating a new stream for empty messages.
-    private static final StreamInput EMPTY_STREAM_INPUT = new ByteBufferStreamInput(ByteBuffer.wrap(BytesRef.EMPTY_BYTES));
-
-    private void messageReceived(TcpChannel channel, InboundMessage message, long startTime) throws IOException {
-        final InetSocketAddress remoteAddress = channel.getRemoteAddress();
-        final Header header = message.getHeader();
-        assert header.needsToReadVariableHeader() == false;
-        ThreadContext threadContext = threadPool.getThreadContext();
-        try (ThreadContext.StoredContext existing = threadContext.stashContext()) {
-            // Place the context with the headers from the message
-            threadContext.setHeaders(header.getHeaders());
-            threadContext.putTransient("_remote_address", remoteAddress);
-            if (header.isRequest()) {
-                handleRequest(channel, header, message);
-            } else {
-                // Responses do not support short circuiting currently
-                assert message.isShortCircuit() == false;
-                final TransportResponseHandler<?> handler;
-                long requestId = header.getRequestId();
-                if (header.isHandshake()) {
-                    handler = handshaker.removeHandlerForHandshake(requestId);
-                } else {
-                    TransportResponseHandler<? extends TransportResponse> theHandler = responseHandlers.onResponseReceived(
-                        requestId,
-                        messageListener
-                    );
-                    if (theHandler == null && header.isError()) {
-                        handler = handshaker.removeHandlerForHandshake(requestId);
-                    } else {
-                        handler = theHandler;
-                    }
-                }
-                // ignore if its null, the service logs it
-                if (handler != null) {
-                    final StreamInput streamInput;
-                    if (message.getContentLength() > 0 || header.getVersion().equals(Version.CURRENT) == false) {
-                        streamInput = namedWriteableStream(message.openOrGetStreamInput());
-                        assertRemoteVersion(streamInput, header.getVersion());
-                        if (header.isError()) {
-                            handlerResponseError(requestId, streamInput, handler);
-                        } else {
-                            handleResponse(requestId, remoteAddress, streamInput, handler);
-                        }
-                    } else {
-                        assert header.isError() == false;
-                        handleResponse(requestId, remoteAddress, EMPTY_STREAM_INPUT, handler);
-                    }
-                }
-
-            }
-        } finally {
-            final long took = threadPool.relativeTimeInMillis() - startTime;
-            final long logThreshold = slowLogThresholdMs;
-            if (logThreshold > 0 && took > logThreshold) {
-                logger.warn(
-                    "handling inbound transport message [{}] took [{}ms] which is above the warn threshold of [{}ms]",
-                    message,
-                    took,
-                    logThreshold
-                );
-            }
-        }
-    }
-
-    private Map<String, Collection<String>> extractHeaders(Map<String, String> headers) {
-        return headers.entrySet().stream().collect(Collectors.toMap(e -> e.getKey(), e -> Collections.singleton(e.getValue())));
-    }
-
-    private <T extends TransportRequest> void handleRequest(TcpChannel channel, Header header, InboundMessage message) throws IOException {
-        final String action = header.getActionName();
-        final long requestId = header.getRequestId();
-        final Version version = header.getVersion();
-        final Map<String, Collection<String>> headers = extractHeaders(header.getHeaders().v1());
-        Span span = tracer.startSpan(SpanBuilder.from(action, channel), headers);
-        try (SpanScope spanScope = tracer.withSpanInScope(span)) {
-            if (header.isHandshake()) {
-                messageListener.onRequestReceived(requestId, action);
-                // Cannot short circuit handshakes
-                assert message.isShortCircuit() == false;
-                final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
-                assertRemoteVersion(stream, header.getVersion());
-                final TcpTransportChannel transportChannel = new TcpTransportChannel(
-                    outboundHandler,
-                    channel,
-                    action,
-                    requestId,
-                    version,
-                    header.getFeatures(),
-                    header.isCompressed(),
-                    header.isHandshake(),
-                    message.takeBreakerReleaseControl()
-                );
-                TransportChannel traceableTransportChannel = TraceableTcpTransportChannel.create(transportChannel, span, tracer);
-                try {
-                    handshaker.handleHandshake(traceableTransportChannel, requestId, stream);
-                } catch (Exception e) {
-                    if (Version.CURRENT.isCompatible(header.getVersion())) {
-                        sendErrorResponse(action, traceableTransportChannel, e);
-                    } else {
-                        logger.warn(
-                            new ParameterizedMessage(
-                                "could not send error response to handshake received on [{}] using wire format version [{}], closing channel",
-                                channel,
-                                header.getVersion()
-                            ),
-                            e
-                        );
-                        channel.close();
-                    }
-                }
-            } else {
-                final TcpTransportChannel transportChannel = new TcpTransportChannel(
-                    outboundHandler,
-                    channel,
-                    action,
-                    requestId,
-                    version,
-                    header.getFeatures(),
-                    header.isCompressed(),
-                    header.isHandshake(),
-                    message.takeBreakerReleaseControl()
-                );
-                TransportChannel traceableTransportChannel = TraceableTcpTransportChannel.create(transportChannel, span, tracer);
-                try {
-                    messageListener.onRequestReceived(requestId, action);
-                    if (message.isShortCircuit()) {
-                        sendErrorResponse(action, traceableTransportChannel, message.getException());
-                    } else {
-                        final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
-                        assertRemoteVersion(stream, header.getVersion());
-                        final RequestHandlerRegistry<T> reg = requestHandlers.getHandler(action);
-                        assert reg != null;
-
-                        final T request = newRequest(requestId, action, stream, reg);
-                        request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
-                        checkStreamIsFullyConsumed(requestId, action, stream);
-
-                        final String executor = reg.getExecutor();
-                        if (ThreadPool.Names.SAME.equals(executor)) {
-                            try {
-                                reg.processMessageReceived(request, traceableTransportChannel);
-                            } catch (Exception e) {
-                                sendErrorResponse(reg.getAction(), traceableTransportChannel, e);
-                            }
-                        } else {
-                            threadPool.executor(executor).execute(new RequestHandler<>(reg, request, traceableTransportChannel));
-                        }
-                    }
-                } catch (Exception e) {
-                    sendErrorResponse(action, traceableTransportChannel, e);
-                }
-            }
-        } catch (Exception e) {
-            span.setError(e);
-            span.endSpan();
-            throw e;
-        }
-    }
-
-    /**
-     * Creates new request instance out of input stream. Throws IllegalStateException if the end of
-     * the stream was reached before the request is fully deserialized from the stream.
-     * @param <T> transport request type
-     * @param requestId request identifier
-     * @param action action name
-     * @param stream stream
-     * @param reg request handler registry
-     * @return new request instance
-     * @throws IOException IOException
-     * @throws IllegalStateException IllegalStateException
-     */
-    private <T extends TransportRequest> T newRequest(
-        final long requestId,
-        final String action,
-        final StreamInput stream,
-        final RequestHandlerRegistry<T> reg
-    ) throws IOException {
-        try {
-            return reg.newRequest(stream);
-        } catch (final EOFException e) {
-            // Another favor of (de)serialization issues is when stream contains less bytes than
-            // the request handler needs to deserialize the payload.
-            throw new IllegalStateException(
-                "Message fully read (request) but more data is expected for requestId ["
-                    + requestId
-                    + "], action ["
-                    + action
-                    + "]; resetting",
-                e
-            );
-        }
-    }
-
-    /**
-     * Checks if the stream is fully consumed and throws the exceptions if that is not the case.
-     * @param requestId request identifier
-     * @param action action name
-     * @param stream stream
-     * @throws IOException IOException
-     */
-    private void checkStreamIsFullyConsumed(final long requestId, final String action, final StreamInput stream) throws IOException {
-        // in case we throw an exception, i.e. when the limit is hit, we don't want to verify
-        final int nextByte = stream.read();
-
-        // calling read() is useful to make sure the message is fully read, even if there some kind of EOS marker
-        if (nextByte != -1) {
-            throw new IllegalStateException(
-                "Message not fully read (request) for requestId ["
-                    + requestId
-                    + "], action ["
-                    + action
-                    + "], available ["
-                    + stream.available()
-                    + "]; resetting"
-            );
-        }
-    }
-
-    /**
-     * Checks if the stream is fully consumed and throws the exceptions if that is not the case.
-     * @param requestId request identifier
-     * @param handler response handler
-     * @param stream stream
-     * @param error "true" if response represents error, "false" otherwise
-     * @throws IOException IOException
-     */
-    private void checkStreamIsFullyConsumed(
-        final long requestId,
-        final TransportResponseHandler<?> handler,
-        final StreamInput stream,
-        final boolean error
-    ) throws IOException {
-        if (stream != EMPTY_STREAM_INPUT) {
-            // Check the entire message has been read
-            final int nextByte = stream.read();
-            // calling read() is useful to make sure the message is fully read, even if there is an EOS marker
-            if (nextByte != -1) {
-                throw new IllegalStateException(
-                    "Message not fully read (response) for requestId ["
-                        + requestId
-                        + "], handler ["
-                        + handler
-                        + "], error ["
-                        + error
-                        + "]; resetting"
-                );
-            }
-        }
-    }
-
-    private static void sendErrorResponse(String actionName, TransportChannel transportChannel, Exception e) {
-        try {
-            transportChannel.sendResponse(e);
-        } catch (Exception inner) {
-            inner.addSuppressed(e);
-            logger.warn(() -> new ParameterizedMessage("Failed to send error message back to client for action [{}]", actionName), inner);
-        }
-    }
-
-    private <T extends TransportResponse> void handleResponse(
-        final long requestId,
-        InetSocketAddress remoteAddress,
-        final StreamInput stream,
-        final TransportResponseHandler<T> handler
-    ) {
-        final T response;
-        try {
-            response = handler.read(stream);
-            response.remoteAddress(new TransportAddress(remoteAddress));
-            checkStreamIsFullyConsumed(requestId, handler, stream, false);
-        } catch (Exception e) {
-            final Exception serializationException = new TransportSerializationException(
-                "Failed to deserialize response from handler [" + handler + "]",
-                e
-            );
-            logger.warn(new ParameterizedMessage("Failed to deserialize response from [{}]", remoteAddress), serializationException);
-            handleException(handler, serializationException);
-            return;
-        }
-        final String executor = handler.executor();
-        if (ThreadPool.Names.SAME.equals(executor)) {
-            doHandleResponse(handler, response);
-        } else {
-            threadPool.executor(executor).execute(() -> doHandleResponse(handler, response));
-        }
+        messageReceivedFromPipeline(channel, message, startTime);
     }
 
-    private <T extends TransportResponse> void doHandleResponse(TransportResponseHandler<T> handler, T response) {
-        try {
-            handler.handleResponse(response);
-        } catch (Exception e) {
-            handleException(handler, new ResponseHandlerFailureTransportException(e));
-        }
-    }
-
-    private void handlerResponseError(final long requestId, StreamInput stream, final TransportResponseHandler<?> handler) {
-        Exception error;
-        try {
-            error = stream.readException();
-            checkStreamIsFullyConsumed(requestId, handler, stream, true);
-        } catch (Exception e) {
-            error = new TransportSerializationException(
-                "Failed to deserialize exception response from stream for handler [" + handler + "]",
-                e
-            );
-        }
-        handleException(handler, error);
-    }
-
-    private void handleException(final TransportResponseHandler<?> handler, Throwable error) {
-        if (!(error instanceof RemoteTransportException)) {
-            error = new RemoteTransportException(error.getMessage(), error);
-        }
-        final RemoteTransportException rtx = (RemoteTransportException) error;
-        threadPool.executor(handler.executor()).execute(() -> {
-            try {
-                handler.handleException(rtx);
-            } catch (Exception e) {
-                logger.error(() -> new ParameterizedMessage("failed to handle exception response [{}]", handler), e);
-            }
-        });
-    }
-
-    private StreamInput namedWriteableStream(StreamInput delegate) {
-        return new NamedWriteableAwareStreamInput(delegate, namedWriteableRegistry);
-    }
-
-    static void assertRemoteVersion(StreamInput in, Version version) {
-        assert version.equals(in.getVersion()) : "Stream version [" + in.getVersion() + "] does not match version [" + version + "]";
-    }
-
-    /**
-     * Internal request handler
-     *
-     * @opensearch.internal
-     */
-    private static class RequestHandler<T extends TransportRequest> extends AbstractRunnable {
-        private final RequestHandlerRegistry<T> reg;
-        private final T request;
-        private final TransportChannel transportChannel;
-
-        RequestHandler(RequestHandlerRegistry<T> reg, T request, TransportChannel transportChannel) {
-            this.reg = reg;
-            this.request = request;
-            this.transportChannel = transportChannel;
-        }
-
-        @Override
-        protected void doRun() throws Exception {
-            reg.processMessageReceived(request, transportChannel);
-        }
-
-        @Override
-        public boolean isForceExecution() {
-            return reg.isForceExecution();
-        }
-
-        @Override
-        public void onFailure(Exception e) {
-            sendErrorResponse(reg.getAction(), transportChannel, e);
+    private void messageReceivedFromPipeline(TcpChannel channel, ProtocolInboundMessage message, long startTime) throws IOException {
+        ProtocolMessageHandler protocolMessageHandler = protocolMessageHandlers.get(message.getProtocol());
+        if (protocolMessageHandler == null) {
+            throw new IllegalStateException("No protocol message handler found for protocol: " + message.getProtocol());
         }
+        protocolMessageHandler.messageReceived(channel, message, startTime, slowLogThresholdMs, messageListener);
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/InboundMessage.java b/server/src/main/java/org/opensearch/transport/InboundMessage.java
index 71c4d6973505d..5c68257557061 100644
--- a/server/src/main/java/org/opensearch/transport/InboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/InboundMessage.java
@@ -32,105 +32,77 @@
 
 package org.opensearch.transport;
 
-import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.annotation.DeprecatedApi;
 import org.opensearch.common.bytes.ReleasableBytesReference;
 import org.opensearch.common.lease.Releasable;
-import org.opensearch.common.lease.Releasables;
-import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.transport.nativeprotocol.NativeInboundMessage;
 
 import java.io.IOException;
 
 /**
  * Inbound data as a message
- *
+ * This api is deprecated, please use {@link org.opensearch.transport.nativeprotocol.NativeInboundMessage} instead.
  * @opensearch.api
  */
-@PublicApi(since = "1.0.0")
-public class InboundMessage implements Releasable {
+@DeprecatedApi(since = "2.14.0")
+public class InboundMessage implements Releasable, ProtocolInboundMessage {
 
-    private final Header header;
-    private final ReleasableBytesReference content;
-    private final Exception exception;
-    private final boolean isPing;
-    private Releasable breakerRelease;
-    private StreamInput streamInput;
+    private final NativeInboundMessage nativeInboundMessage;
 
     public InboundMessage(Header header, ReleasableBytesReference content, Releasable breakerRelease) {
-        this.header = header;
-        this.content = content;
-        this.breakerRelease = breakerRelease;
-        this.exception = null;
-        this.isPing = false;
+        this.nativeInboundMessage = new NativeInboundMessage(header, content, breakerRelease);
     }
 
     public InboundMessage(Header header, Exception exception) {
-        this.header = header;
-        this.content = null;
-        this.breakerRelease = null;
-        this.exception = exception;
-        this.isPing = false;
+        this.nativeInboundMessage = new NativeInboundMessage(header, exception);
     }
 
     public InboundMessage(Header header, boolean isPing) {
-        this.header = header;
-        this.content = null;
-        this.breakerRelease = null;
-        this.exception = null;
-        this.isPing = isPing;
+        this.nativeInboundMessage = new NativeInboundMessage(header, isPing);
     }
 
     public Header getHeader() {
-        return header;
+        return this.nativeInboundMessage.getHeader();
     }
 
     public int getContentLength() {
-        if (content == null) {
-            return 0;
-        } else {
-            return content.length();
-        }
+        return this.nativeInboundMessage.getContentLength();
     }
 
     public Exception getException() {
-        return exception;
+        return this.nativeInboundMessage.getException();
     }
 
     public boolean isPing() {
-        return isPing;
+        return this.nativeInboundMessage.isPing();
     }
 
     public boolean isShortCircuit() {
-        return exception != null;
+        return this.nativeInboundMessage.getException() != null;
     }
 
     public Releasable takeBreakerReleaseControl() {
-        final Releasable toReturn = breakerRelease;
-        breakerRelease = null;
-        if (toReturn != null) {
-            return toReturn;
-        } else {
-            return () -> {};
-        }
+        return this.nativeInboundMessage.takeBreakerReleaseControl();
     }
 
     public StreamInput openOrGetStreamInput() throws IOException {
-        assert isPing == false && content != null;
-        if (streamInput == null) {
-            streamInput = content.streamInput();
-            streamInput.setVersion(header.getVersion());
-        }
-        return streamInput;
+        return this.nativeInboundMessage.openOrGetStreamInput();
     }
 
     @Override
     public void close() {
-        IOUtils.closeWhileHandlingException(streamInput);
-        Releasables.closeWhileHandlingException(content, breakerRelease);
+        this.nativeInboundMessage.close();
     }
 
     @Override
     public String toString() {
-        return "InboundMessage{" + header + "}";
+        return this.nativeInboundMessage.toString();
     }
+
+    @Override
+    public String getProtocol() {
+        return this.nativeInboundMessage.getProtocol();
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/transport/InboundPipeline.java b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
index dd4690e5e6abf..5cee3bb975223 100644
--- a/server/src/main/java/org/opensearch/transport/InboundPipeline.java
+++ b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
@@ -38,11 +38,11 @@
 import org.opensearch.common.lease.Releasables;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.core.common.breaker.CircuitBreaker;
-import org.opensearch.core.common.bytes.CompositeBytesReference;
+import org.opensearch.transport.nativeprotocol.NativeInboundBytesHandler;
 
 import java.io.IOException;
 import java.util.ArrayDeque;
-import java.util.ArrayList;
+import java.util.List;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 import java.util.function.LongSupplier;
@@ -55,17 +55,16 @@
  */
 public class InboundPipeline implements Releasable {
 
-    private static final ThreadLocal<ArrayList<Object>> fragmentList = ThreadLocal.withInitial(ArrayList::new);
-    private static final InboundMessage PING_MESSAGE = new InboundMessage(null, true);
-
     private final LongSupplier relativeTimeInMillis;
     private final StatsTracker statsTracker;
     private final InboundDecoder decoder;
     private final InboundAggregator aggregator;
-    private final BiConsumer<TcpChannel, InboundMessage> messageHandler;
     private Exception uncaughtException;
     private final ArrayDeque<ReleasableBytesReference> pending = new ArrayDeque<>(2);
     private boolean isClosed = false;
+    private final BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler;
+    private final List<InboundBytesHandler> protocolBytesHandlers;
+    private InboundBytesHandler currentHandler;
 
     public InboundPipeline(
         Version version,
@@ -74,7 +73,7 @@ public InboundPipeline(
         LongSupplier relativeTimeInMillis,
         Supplier<CircuitBreaker> circuitBreaker,
         Function<String, RequestHandlerRegistry<TransportRequest>> registryFunction,
-        BiConsumer<TcpChannel, InboundMessage> messageHandler
+        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler
     ) {
         this(
             statsTracker,
@@ -90,18 +89,23 @@ public InboundPipeline(
         LongSupplier relativeTimeInMillis,
         InboundDecoder decoder,
         InboundAggregator aggregator,
-        BiConsumer<TcpChannel, InboundMessage> messageHandler
+        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler
     ) {
         this.relativeTimeInMillis = relativeTimeInMillis;
         this.statsTracker = statsTracker;
         this.decoder = decoder;
         this.aggregator = aggregator;
+        this.protocolBytesHandlers = List.of(new NativeInboundBytesHandler(pending, decoder, aggregator, statsTracker));
         this.messageHandler = messageHandler;
     }
 
     @Override
     public void close() {
         isClosed = true;
+        if (currentHandler != null) {
+            currentHandler.close();
+            currentHandler = null;
+        }
         Releasables.closeWhileHandlingException(decoder, aggregator);
         Releasables.closeWhileHandlingException(pending);
         pending.clear();
@@ -124,95 +128,21 @@ public void doHandleBytes(TcpChannel channel, ReleasableBytesReference reference
         statsTracker.markBytesRead(reference.length());
         pending.add(reference.retain());
 
-        final ArrayList<Object> fragments = fragmentList.get();
-        boolean continueHandling = true;
-
-        while (continueHandling && isClosed == false) {
-            boolean continueDecoding = true;
-            while (continueDecoding && pending.isEmpty() == false) {
-                try (ReleasableBytesReference toDecode = getPendingBytes()) {
-                    final int bytesDecoded = decoder.decode(toDecode, fragments::add);
-                    if (bytesDecoded != 0) {
-                        releasePendingBytes(bytesDecoded);
-                        if (fragments.isEmpty() == false && endOfMessage(fragments.get(fragments.size() - 1))) {
-                            continueDecoding = false;
-                        }
-                    } else {
-                        continueDecoding = false;
-                    }
-                }
-            }
-
-            if (fragments.isEmpty()) {
-                continueHandling = false;
-            } else {
-                try {
-                    forwardFragments(channel, fragments);
-                } finally {
-                    for (Object fragment : fragments) {
-                        if (fragment instanceof ReleasableBytesReference) {
-                            ((ReleasableBytesReference) fragment).close();
-                        }
-                    }
-                    fragments.clear();
-                }
-            }
-        }
-    }
-
-    private void forwardFragments(TcpChannel channel, ArrayList<Object> fragments) throws IOException {
-        for (Object fragment : fragments) {
-            if (fragment instanceof Header) {
-                assert aggregator.isAggregating() == false;
-                aggregator.headerReceived((Header) fragment);
-            } else if (fragment == InboundDecoder.PING) {
-                assert aggregator.isAggregating() == false;
-                messageHandler.accept(channel, PING_MESSAGE);
-            } else if (fragment == InboundDecoder.END_CONTENT) {
-                assert aggregator.isAggregating();
-                try (InboundMessage aggregated = aggregator.finishAggregation()) {
-                    statsTracker.markMessageReceived();
-                    messageHandler.accept(channel, aggregated);
+        // If we don't have a current handler, we should try to find one based on the protocol of the incoming bytes.
+        if (currentHandler == null) {
+            for (InboundBytesHandler handler : protocolBytesHandlers) {
+                if (handler.canHandleBytes(reference)) {
+                    currentHandler = handler;
+                    break;
                 }
-            } else {
-                assert aggregator.isAggregating();
-                assert fragment instanceof ReleasableBytesReference;
-                aggregator.aggregate((ReleasableBytesReference) fragment);
             }
         }
-    }
 
-    private boolean endOfMessage(Object fragment) {
-        return fragment == InboundDecoder.PING || fragment == InboundDecoder.END_CONTENT || fragment instanceof Exception;
-    }
-
-    private ReleasableBytesReference getPendingBytes() {
-        if (pending.size() == 1) {
-            return pending.peekFirst().retain();
+        // If we have a current handler determined based on protocol, we should continue to use it for the fragmented bytes.
+        if (currentHandler != null) {
+            currentHandler.doHandleBytes(channel, reference, messageHandler);
         } else {
-            final ReleasableBytesReference[] bytesReferences = new ReleasableBytesReference[pending.size()];
-            int index = 0;
-            for (ReleasableBytesReference pendingReference : pending) {
-                bytesReferences[index] = pendingReference.retain();
-                ++index;
-            }
-            final Releasable releasable = () -> Releasables.closeWhileHandlingException(bytesReferences);
-            return new ReleasableBytesReference(CompositeBytesReference.of(bytesReferences), releasable);
-        }
-    }
-
-    private void releasePendingBytes(int bytesConsumed) {
-        int bytesToRelease = bytesConsumed;
-        while (bytesToRelease != 0) {
-            try (ReleasableBytesReference reference = pending.pollFirst()) {
-                assert reference != null;
-                if (bytesToRelease < reference.length()) {
-                    pending.addFirst(reference.retainedSlice(bytesToRelease, reference.length() - bytesToRelease));
-                    bytesToRelease -= bytesToRelease;
-                } else {
-                    bytesToRelease -= reference.length();
-                }
-            }
+            throw new IllegalStateException("No bytes handler found for the incoming transport protocol");
         }
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/NativeMessageHandler.java b/server/src/main/java/org/opensearch/transport/NativeMessageHandler.java
new file mode 100644
index 0000000000000..861b95a8098f2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/NativeMessageHandler.java
@@ -0,0 +1,494 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.transport;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.apache.lucene.util.BytesRef;
+import org.opensearch.Version;
+import org.opensearch.common.util.concurrent.AbstractRunnable;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.core.common.io.stream.ByteBufferStreamInput;
+import org.opensearch.core.common.io.stream.NamedWriteableAwareStreamInput;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.transport.TransportAddress;
+import org.opensearch.core.transport.TransportResponse;
+import org.opensearch.telemetry.tracing.Span;
+import org.opensearch.telemetry.tracing.SpanBuilder;
+import org.opensearch.telemetry.tracing.SpanScope;
+import org.opensearch.telemetry.tracing.Tracer;
+import org.opensearch.telemetry.tracing.channels.TraceableTcpTransportChannel;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * Native handler for inbound data
+ *
+ * @opensearch.internal
+ */
+public class NativeMessageHandler implements ProtocolMessageHandler {
+
+    private static final Logger logger = LogManager.getLogger(NativeMessageHandler.class);
+
+    private final ThreadPool threadPool;
+    private final OutboundHandler outboundHandler;
+    private final NamedWriteableRegistry namedWriteableRegistry;
+    private final TransportHandshaker handshaker;
+    private final TransportKeepAlive keepAlive;
+    private final Transport.ResponseHandlers responseHandlers;
+    private final Transport.RequestHandlers requestHandlers;
+
+    private final Tracer tracer;
+
+    NativeMessageHandler(
+        ThreadPool threadPool,
+        OutboundHandler outboundHandler,
+        NamedWriteableRegistry namedWriteableRegistry,
+        TransportHandshaker handshaker,
+        Transport.RequestHandlers requestHandlers,
+        Transport.ResponseHandlers responseHandlers,
+        Tracer tracer,
+        TransportKeepAlive keepAlive
+    ) {
+        this.threadPool = threadPool;
+        this.outboundHandler = outboundHandler;
+        this.namedWriteableRegistry = namedWriteableRegistry;
+        this.handshaker = handshaker;
+        this.requestHandlers = requestHandlers;
+        this.responseHandlers = responseHandlers;
+        this.tracer = tracer;
+        this.keepAlive = keepAlive;
+    }
+
+    // Empty stream constant to avoid instantiating a new stream for empty messages.
+    private static final StreamInput EMPTY_STREAM_INPUT = new ByteBufferStreamInput(ByteBuffer.wrap(BytesRef.EMPTY_BYTES));
+
+    @Override
+    public void messageReceived(
+        TcpChannel channel,
+        ProtocolInboundMessage message,
+        long startTime,
+        long slowLogThresholdMs,
+        TransportMessageListener messageListener
+    ) throws IOException {
+        InboundMessage inboundMessage = (InboundMessage) message;
+        TransportLogger.logInboundMessage(channel, inboundMessage);
+        if (inboundMessage.isPing()) {
+            keepAlive.receiveKeepAlive(channel);
+        } else {
+            handleMessage(channel, inboundMessage, startTime, slowLogThresholdMs, messageListener);
+        }
+    }
+
+    private void handleMessage(
+        TcpChannel channel,
+        InboundMessage message,
+        long startTime,
+        long slowLogThresholdMs,
+        TransportMessageListener messageListener
+    ) throws IOException {
+        final InetSocketAddress remoteAddress = channel.getRemoteAddress();
+        final Header header = message.getHeader();
+        assert header.needsToReadVariableHeader() == false;
+        ThreadContext threadContext = threadPool.getThreadContext();
+        try (ThreadContext.StoredContext existing = threadContext.stashContext()) {
+            // Place the context with the headers from the message
+            threadContext.setHeaders(header.getHeaders());
+            threadContext.putTransient("_remote_address", remoteAddress);
+            if (header.isRequest()) {
+                handleRequest(channel, header, message, messageListener);
+            } else {
+                // Responses do not support short circuiting currently
+                assert message.isShortCircuit() == false;
+                final TransportResponseHandler<?> handler;
+                long requestId = header.getRequestId();
+                if (header.isHandshake()) {
+                    handler = handshaker.removeHandlerForHandshake(requestId);
+                } else {
+                    TransportResponseHandler<? extends TransportResponse> theHandler = responseHandlers.onResponseReceived(
+                        requestId,
+                        messageListener
+                    );
+                    if (theHandler == null && header.isError()) {
+                        handler = handshaker.removeHandlerForHandshake(requestId);
+                    } else {
+                        handler = theHandler;
+                    }
+                }
+                // ignore if its null, the service logs it
+                if (handler != null) {
+                    final StreamInput streamInput;
+                    if (message.getContentLength() > 0 || header.getVersion().equals(Version.CURRENT) == false) {
+                        streamInput = namedWriteableStream(message.openOrGetStreamInput());
+                        assertRemoteVersion(streamInput, header.getVersion());
+                        if (header.isError()) {
+                            handlerResponseError(requestId, streamInput, handler);
+                        } else {
+                            handleResponse(requestId, remoteAddress, streamInput, handler);
+                        }
+                    } else {
+                        assert header.isError() == false;
+                        handleResponse(requestId, remoteAddress, EMPTY_STREAM_INPUT, handler);
+                    }
+                }
+
+            }
+        } finally {
+            final long took = threadPool.relativeTimeInMillis() - startTime;
+            final long logThreshold = slowLogThresholdMs;
+            if (logThreshold > 0 && took > logThreshold) {
+                logger.warn(
+                    "handling inbound transport message [{}] took [{}ms] which is above the warn threshold of [{}ms]",
+                    message,
+                    took,
+                    logThreshold
+                );
+            }
+        }
+    }
+
+    private Map<String, Collection<String>> extractHeaders(Map<String, String> headers) {
+        return headers.entrySet().stream().collect(Collectors.toMap(e -> e.getKey(), e -> Collections.singleton(e.getValue())));
+    }
+
+    private <T extends TransportRequest> void handleRequest(
+        TcpChannel channel,
+        Header header,
+        InboundMessage message,
+        TransportMessageListener messageListener
+    ) throws IOException {
+        final String action = header.getActionName();
+        final long requestId = header.getRequestId();
+        final Version version = header.getVersion();
+        final Map<String, Collection<String>> headers = extractHeaders(header.getHeaders().v1());
+        Span span = tracer.startSpan(SpanBuilder.from(action, channel), headers);
+        try (SpanScope spanScope = tracer.withSpanInScope(span)) {
+            if (header.isHandshake()) {
+                messageListener.onRequestReceived(requestId, action);
+                // Cannot short circuit handshakes
+                assert message.isShortCircuit() == false;
+                final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
+                assertRemoteVersion(stream, header.getVersion());
+                final TcpTransportChannel transportChannel = new TcpTransportChannel(
+                    outboundHandler,
+                    channel,
+                    action,
+                    requestId,
+                    version,
+                    header.getFeatures(),
+                    header.isCompressed(),
+                    header.isHandshake(),
+                    message.takeBreakerReleaseControl()
+                );
+                TransportChannel traceableTransportChannel = TraceableTcpTransportChannel.create(transportChannel, span, tracer);
+                try {
+                    handshaker.handleHandshake(traceableTransportChannel, requestId, stream);
+                } catch (Exception e) {
+                    if (Version.CURRENT.isCompatible(header.getVersion())) {
+                        sendErrorResponse(action, traceableTransportChannel, e);
+                    } else {
+                        logger.warn(
+                            new ParameterizedMessage(
+                                "could not send error response to handshake received on [{}] using wire format version [{}], closing channel",
+                                channel,
+                                header.getVersion()
+                            ),
+                            e
+                        );
+                        channel.close();
+                    }
+                }
+            } else {
+                final TcpTransportChannel transportChannel = new TcpTransportChannel(
+                    outboundHandler,
+                    channel,
+                    action,
+                    requestId,
+                    version,
+                    header.getFeatures(),
+                    header.isCompressed(),
+                    header.isHandshake(),
+                    message.takeBreakerReleaseControl()
+                );
+                TransportChannel traceableTransportChannel = TraceableTcpTransportChannel.create(transportChannel, span, tracer);
+                try {
+                    messageListener.onRequestReceived(requestId, action);
+                    if (message.isShortCircuit()) {
+                        sendErrorResponse(action, traceableTransportChannel, message.getException());
+                    } else {
+                        final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
+                        assertRemoteVersion(stream, header.getVersion());
+                        final RequestHandlerRegistry<T> reg = requestHandlers.getHandler(action);
+                        assert reg != null;
+
+                        final T request = newRequest(requestId, action, stream, reg);
+                        request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
+                        checkStreamIsFullyConsumed(requestId, action, stream);
+
+                        final String executor = reg.getExecutor();
+                        if (ThreadPool.Names.SAME.equals(executor)) {
+                            try {
+                                reg.processMessageReceived(request, traceableTransportChannel);
+                            } catch (Exception e) {
+                                sendErrorResponse(reg.getAction(), traceableTransportChannel, e);
+                            }
+                        } else {
+                            threadPool.executor(executor).execute(new RequestHandler<>(reg, request, traceableTransportChannel));
+                        }
+                    }
+                } catch (Exception e) {
+                    sendErrorResponse(action, traceableTransportChannel, e);
+                }
+            }
+        } catch (Exception e) {
+            span.setError(e);
+            span.endSpan();
+            throw e;
+        }
+    }
+
+    /**
+     * Creates new request instance out of input stream. Throws IllegalStateException if the end of
+     * the stream was reached before the request is fully deserialized from the stream.
+     * @param <T> transport request type
+     * @param requestId request identifier
+     * @param action action name
+     * @param stream stream
+     * @param reg request handler registry
+     * @return new request instance
+     * @throws IOException IOException
+     * @throws IllegalStateException IllegalStateException
+     */
+    private <T extends TransportRequest> T newRequest(
+        final long requestId,
+        final String action,
+        final StreamInput stream,
+        final RequestHandlerRegistry<T> reg
+    ) throws IOException {
+        try {
+            return reg.newRequest(stream);
+        } catch (final EOFException e) {
+            // Another favor of (de)serialization issues is when stream contains less bytes than
+            // the request handler needs to deserialize the payload.
+            throw new IllegalStateException(
+                "Message fully read (request) but more data is expected for requestId ["
+                    + requestId
+                    + "], action ["
+                    + action
+                    + "]; resetting",
+                e
+            );
+        }
+    }
+
+    /**
+     * Checks if the stream is fully consumed and throws the exceptions if that is not the case.
+     * @param requestId request identifier
+     * @param action action name
+     * @param stream stream
+     * @throws IOException IOException
+     */
+    private void checkStreamIsFullyConsumed(final long requestId, final String action, final StreamInput stream) throws IOException {
+        // in case we throw an exception, i.e. when the limit is hit, we don't want to verify
+        final int nextByte = stream.read();
+
+        // calling read() is useful to make sure the message is fully read, even if there some kind of EOS marker
+        if (nextByte != -1) {
+            throw new IllegalStateException(
+                "Message not fully read (request) for requestId ["
+                    + requestId
+                    + "], action ["
+                    + action
+                    + "], available ["
+                    + stream.available()
+                    + "]; resetting"
+            );
+        }
+    }
+
+    /**
+     * Checks if the stream is fully consumed and throws the exceptions if that is not the case.
+     * @param requestId request identifier
+     * @param handler response handler
+     * @param stream stream
+     * @param error "true" if response represents error, "false" otherwise
+     * @throws IOException IOException
+     */
+    private void checkStreamIsFullyConsumed(
+        final long requestId,
+        final TransportResponseHandler<?> handler,
+        final StreamInput stream,
+        final boolean error
+    ) throws IOException {
+        if (stream != EMPTY_STREAM_INPUT) {
+            // Check the entire message has been read
+            final int nextByte = stream.read();
+            // calling read() is useful to make sure the message is fully read, even if there is an EOS marker
+            if (nextByte != -1) {
+                throw new IllegalStateException(
+                    "Message not fully read (response) for requestId ["
+                        + requestId
+                        + "], handler ["
+                        + handler
+                        + "], error ["
+                        + error
+                        + "]; resetting"
+                );
+            }
+        }
+    }
+
+    private static void sendErrorResponse(String actionName, TransportChannel transportChannel, Exception e) {
+        try {
+            transportChannel.sendResponse(e);
+        } catch (Exception inner) {
+            inner.addSuppressed(e);
+            logger.warn(() -> new ParameterizedMessage("Failed to send error message back to client for action [{}]", actionName), inner);
+        }
+    }
+
+    private <T extends TransportResponse> void handleResponse(
+        final long requestId,
+        InetSocketAddress remoteAddress,
+        final StreamInput stream,
+        final TransportResponseHandler<T> handler
+    ) {
+        final T response;
+        try {
+            response = handler.read(stream);
+            response.remoteAddress(new TransportAddress(remoteAddress));
+            checkStreamIsFullyConsumed(requestId, handler, stream, false);
+        } catch (Exception e) {
+            final Exception serializationException = new TransportSerializationException(
+                "Failed to deserialize response from handler [" + handler + "]",
+                e
+            );
+            logger.warn(new ParameterizedMessage("Failed to deserialize response from [{}]", remoteAddress), serializationException);
+            handleException(handler, serializationException);
+            return;
+        }
+        final String executor = handler.executor();
+        if (ThreadPool.Names.SAME.equals(executor)) {
+            doHandleResponse(handler, response);
+        } else {
+            threadPool.executor(executor).execute(() -> doHandleResponse(handler, response));
+        }
+    }
+
+    private <T extends TransportResponse> void doHandleResponse(TransportResponseHandler<T> handler, T response) {
+        try {
+            handler.handleResponse(response);
+        } catch (Exception e) {
+            handleException(handler, new ResponseHandlerFailureTransportException(e));
+        }
+    }
+
+    private void handlerResponseError(final long requestId, StreamInput stream, final TransportResponseHandler<?> handler) {
+        Exception error;
+        try {
+            error = stream.readException();
+            checkStreamIsFullyConsumed(requestId, handler, stream, true);
+        } catch (Exception e) {
+            error = new TransportSerializationException(
+                "Failed to deserialize exception response from stream for handler [" + handler + "]",
+                e
+            );
+        }
+        handleException(handler, error);
+    }
+
+    private void handleException(final TransportResponseHandler<?> handler, Throwable error) {
+        if (!(error instanceof RemoteTransportException)) {
+            error = new RemoteTransportException(error.getMessage(), error);
+        }
+        final RemoteTransportException rtx = (RemoteTransportException) error;
+        threadPool.executor(handler.executor()).execute(() -> {
+            try {
+                handler.handleException(rtx);
+            } catch (Exception e) {
+                logger.error(() -> new ParameterizedMessage("failed to handle exception response [{}]", handler), e);
+            }
+        });
+    }
+
+    private StreamInput namedWriteableStream(StreamInput delegate) {
+        return new NamedWriteableAwareStreamInput(delegate, namedWriteableRegistry);
+    }
+
+    static void assertRemoteVersion(StreamInput in, Version version) {
+        assert version.equals(in.getVersion()) : "Stream version [" + in.getVersion() + "] does not match version [" + version + "]";
+    }
+
+    /**
+     * Internal request handler
+     *
+     * @opensearch.internal
+     */
+    private static class RequestHandler<T extends TransportRequest> extends AbstractRunnable {
+        private final RequestHandlerRegistry<T> reg;
+        private final T request;
+        private final TransportChannel transportChannel;
+
+        RequestHandler(RequestHandlerRegistry<T> reg, T request, TransportChannel transportChannel) {
+            this.reg = reg;
+            this.request = request;
+            this.transportChannel = transportChannel;
+        }
+
+        @Override
+        protected void doRun() throws Exception {
+            reg.processMessageReceived(request, transportChannel);
+        }
+
+        @Override
+        public boolean isForceExecution() {
+            return reg.isForceExecution();
+        }
+
+        @Override
+        public void onFailure(Exception e) {
+            sendErrorResponse(reg.getAction(), transportChannel, e);
+        }
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtocolInboundMessage.java b/server/src/main/java/org/opensearch/transport/ProtocolInboundMessage.java
new file mode 100644
index 0000000000000..43c2d5ffe4c96
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtocolInboundMessage.java
@@ -0,0 +1,27 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.transport;
+
+import org.opensearch.common.annotation.PublicApi;
+
+/**
+ * Base class for inbound data as a message.
+ * Different implementations are used for different protocols.
+ *
+ * @opensearch.internal
+ */
+@PublicApi(since = "2.14.0")
+public interface ProtocolInboundMessage {
+
+    /**
+     * @return the protocol used to encode this message
+     */
+    public String getProtocol();
+
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtocolMessageHandler.java b/server/src/main/java/org/opensearch/transport/ProtocolMessageHandler.java
new file mode 100644
index 0000000000000..714d91d1e74c7
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtocolMessageHandler.java
@@ -0,0 +1,27 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.transport;
+
+import java.io.IOException;
+
+/**
+ * Interface for message handlers based on transport protocol.
+ *
+ * @opensearch.internal
+ */
+public interface ProtocolMessageHandler {
+
+    public void messageReceived(
+        TcpChannel channel,
+        ProtocolInboundMessage message,
+        long startTime,
+        long slowLogThresholdMs,
+        TransportMessageListener messageListener
+    ) throws IOException;
+}
diff --git a/server/src/main/java/org/opensearch/transport/TcpTransport.java b/server/src/main/java/org/opensearch/transport/TcpTransport.java
index 7d45152089f37..e32bba5e836d3 100644
--- a/server/src/main/java/org/opensearch/transport/TcpTransport.java
+++ b/server/src/main/java/org/opensearch/transport/TcpTransport.java
@@ -762,12 +762,24 @@ protected void serverAcceptedChannel(TcpChannel channel) {
     protected abstract void stopInternal();
 
     /**
+     * @deprecated use {@link #inboundMessage(TcpChannel, ProtocolInboundMessage)}
      * Handles inbound message that has been decoded.
      *
      * @param channel the channel the message is from
      * @param message the message
      */
+    @Deprecated(since = "2.14.0", forRemoval = true)
     public void inboundMessage(TcpChannel channel, InboundMessage message) {
+        inboundMessage(channel, (ProtocolInboundMessage) message);
+    }
+
+    /**
+     * Handles inbound message that has been decoded.
+     *
+     * @param channel the channel the message is from
+     * @param message the message
+     */
+    public void inboundMessage(TcpChannel channel, ProtocolInboundMessage message) {
         try {
             inboundHandler.inboundMessage(channel, message);
         } catch (Exception e) {
diff --git a/server/src/main/java/org/opensearch/transport/nativeprotocol/NativeInboundBytesHandler.java b/server/src/main/java/org/opensearch/transport/nativeprotocol/NativeInboundBytesHandler.java
new file mode 100644
index 0000000000000..a8a4c0da7ec0f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/nativeprotocol/NativeInboundBytesHandler.java
@@ -0,0 +1,167 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.transport.nativeprotocol;
+
+import org.opensearch.common.bytes.ReleasableBytesReference;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
+import org.opensearch.core.common.bytes.CompositeBytesReference;
+import org.opensearch.transport.Header;
+import org.opensearch.transport.InboundAggregator;
+import org.opensearch.transport.InboundBytesHandler;
+import org.opensearch.transport.InboundDecoder;
+import org.opensearch.transport.InboundMessage;
+import org.opensearch.transport.ProtocolInboundMessage;
+import org.opensearch.transport.StatsTracker;
+import org.opensearch.transport.TcpChannel;
+
+import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.function.BiConsumer;
+
+/**
+ * Handler for inbound bytes for the native protocol.
+ */
+public class NativeInboundBytesHandler implements InboundBytesHandler {
+
+    private static final ThreadLocal<ArrayList<Object>> fragmentList = ThreadLocal.withInitial(ArrayList::new);
+    private static final InboundMessage PING_MESSAGE = new InboundMessage(null, true);
+
+    private final ArrayDeque<ReleasableBytesReference> pending;
+    private final InboundDecoder decoder;
+    private final InboundAggregator aggregator;
+    private final StatsTracker statsTracker;
+    private boolean isClosed = false;
+
+    public NativeInboundBytesHandler(
+        ArrayDeque<ReleasableBytesReference> pending,
+        InboundDecoder decoder,
+        InboundAggregator aggregator,
+        StatsTracker statsTracker
+    ) {
+        this.pending = pending;
+        this.decoder = decoder;
+        this.aggregator = aggregator;
+        this.statsTracker = statsTracker;
+    }
+
+    @Override
+    public void close() {
+        isClosed = true;
+    }
+
+    @Override
+    public boolean canHandleBytes(ReleasableBytesReference reference) {
+        return true;
+    }
+
+    @Override
+    public void doHandleBytes(
+        TcpChannel channel,
+        ReleasableBytesReference reference,
+        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler
+    ) throws IOException {
+        final ArrayList<Object> fragments = fragmentList.get();
+        boolean continueHandling = true;
+
+        while (continueHandling && isClosed == false) {
+            boolean continueDecoding = true;
+            while (continueDecoding && pending.isEmpty() == false) {
+                try (ReleasableBytesReference toDecode = getPendingBytes()) {
+                    final int bytesDecoded = decoder.decode(toDecode, fragments::add);
+                    if (bytesDecoded != 0) {
+                        releasePendingBytes(bytesDecoded);
+                        if (fragments.isEmpty() == false && endOfMessage(fragments.get(fragments.size() - 1))) {
+                            continueDecoding = false;
+                        }
+                    } else {
+                        continueDecoding = false;
+                    }
+                }
+            }
+
+            if (fragments.isEmpty()) {
+                continueHandling = false;
+            } else {
+                try {
+                    forwardFragments(channel, fragments, messageHandler);
+                } finally {
+                    for (Object fragment : fragments) {
+                        if (fragment instanceof ReleasableBytesReference) {
+                            ((ReleasableBytesReference) fragment).close();
+                        }
+                    }
+                    fragments.clear();
+                }
+            }
+        }
+    }
+
+    private ReleasableBytesReference getPendingBytes() {
+        if (pending.size() == 1) {
+            return pending.peekFirst().retain();
+        } else {
+            final ReleasableBytesReference[] bytesReferences = new ReleasableBytesReference[pending.size()];
+            int index = 0;
+            for (ReleasableBytesReference pendingReference : pending) {
+                bytesReferences[index] = pendingReference.retain();
+                ++index;
+            }
+            final Releasable releasable = () -> Releasables.closeWhileHandlingException(bytesReferences);
+            return new ReleasableBytesReference(CompositeBytesReference.of(bytesReferences), releasable);
+        }
+    }
+
+    private void releasePendingBytes(int bytesConsumed) {
+        int bytesToRelease = bytesConsumed;
+        while (bytesToRelease != 0) {
+            try (ReleasableBytesReference reference = pending.pollFirst()) {
+                assert reference != null;
+                if (bytesToRelease < reference.length()) {
+                    pending.addFirst(reference.retainedSlice(bytesToRelease, reference.length() - bytesToRelease));
+                    bytesToRelease -= bytesToRelease;
+                } else {
+                    bytesToRelease -= reference.length();
+                }
+            }
+        }
+    }
+
+    private boolean endOfMessage(Object fragment) {
+        return fragment == InboundDecoder.PING || fragment == InboundDecoder.END_CONTENT || fragment instanceof Exception;
+    }
+
+    private void forwardFragments(
+        TcpChannel channel,
+        ArrayList<Object> fragments,
+        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler
+    ) throws IOException {
+        for (Object fragment : fragments) {
+            if (fragment instanceof Header) {
+                assert aggregator.isAggregating() == false;
+                aggregator.headerReceived((Header) fragment);
+            } else if (fragment == InboundDecoder.PING) {
+                assert aggregator.isAggregating() == false;
+                messageHandler.accept(channel, PING_MESSAGE);
+            } else if (fragment == InboundDecoder.END_CONTENT) {
+                assert aggregator.isAggregating();
+                try (InboundMessage aggregated = aggregator.finishAggregation()) {
+                    statsTracker.markMessageReceived();
+                    messageHandler.accept(channel, aggregated);
+                }
+            } else {
+                assert aggregator.isAggregating();
+                assert fragment instanceof ReleasableBytesReference;
+                aggregator.aggregate((ReleasableBytesReference) fragment);
+            }
+        }
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/transport/nativeprotocol/NativeInboundMessage.java b/server/src/main/java/org/opensearch/transport/nativeprotocol/NativeInboundMessage.java
new file mode 100644
index 0000000000000..1143f129b6319
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/nativeprotocol/NativeInboundMessage.java
@@ -0,0 +1,149 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.transport.nativeprotocol;
+
+import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.bytes.ReleasableBytesReference;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.transport.Header;
+import org.opensearch.transport.ProtocolInboundMessage;
+
+import java.io.IOException;
+
+/**
+ * Inbound data as a message
+ *
+ * @opensearch.api
+ */
+@PublicApi(since = "2.14.0")
+public class NativeInboundMessage implements Releasable, ProtocolInboundMessage {
+
+    /**
+     * The protocol used to encode this message
+     */
+    public static String NATIVE_PROTOCOL = "native";
+
+    private final Header header;
+    private final ReleasableBytesReference content;
+    private final Exception exception;
+    private final boolean isPing;
+    private Releasable breakerRelease;
+    private StreamInput streamInput;
+
+    public NativeInboundMessage(Header header, ReleasableBytesReference content, Releasable breakerRelease) {
+        this.header = header;
+        this.content = content;
+        this.breakerRelease = breakerRelease;
+        this.exception = null;
+        this.isPing = false;
+    }
+
+    public NativeInboundMessage(Header header, Exception exception) {
+        this.header = header;
+        this.content = null;
+        this.breakerRelease = null;
+        this.exception = exception;
+        this.isPing = false;
+    }
+
+    public NativeInboundMessage(Header header, boolean isPing) {
+        this.header = header;
+        this.content = null;
+        this.breakerRelease = null;
+        this.exception = null;
+        this.isPing = isPing;
+    }
+
+    @Override
+    public String getProtocol() {
+        return NATIVE_PROTOCOL;
+    }
+
+    public Header getHeader() {
+        return header;
+    }
+
+    public int getContentLength() {
+        if (content == null) {
+            return 0;
+        } else {
+            return content.length();
+        }
+    }
+
+    public Exception getException() {
+        return exception;
+    }
+
+    public boolean isPing() {
+        return isPing;
+    }
+
+    public boolean isShortCircuit() {
+        return exception != null;
+    }
+
+    public Releasable takeBreakerReleaseControl() {
+        final Releasable toReturn = breakerRelease;
+        breakerRelease = null;
+        if (toReturn != null) {
+            return toReturn;
+        } else {
+            return () -> {};
+        }
+    }
+
+    public StreamInput openOrGetStreamInput() throws IOException {
+        assert isPing == false && content != null;
+        if (streamInput == null) {
+            streamInput = content.streamInput();
+            streamInput.setVersion(header.getVersion());
+        }
+        return streamInput;
+    }
+
+    @Override
+    public void close() {
+        IOUtils.closeWhileHandlingException(streamInput);
+        Releasables.closeWhileHandlingException(content, breakerRelease);
+    }
+
+    @Override
+    public String toString() {
+        return "InboundMessage{" + header + "}";
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/transport/nativeprotocol/package-info.java b/server/src/main/java/org/opensearch/transport/nativeprotocol/package-info.java
new file mode 100644
index 0000000000000..84f6d7d0ec5c2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/nativeprotocol/package-info.java
@@ -0,0 +1,10 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/** Native transport protocol package. */
+package org.opensearch.transport.nativeprotocol;
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/close/TransportVerifyShardBeforeCloseActionTests.java b/server/src/test/java/org/opensearch/action/admin/indices/close/TransportVerifyShardBeforeCloseActionTests.java
index ef26bc225b0c7..5ca5f53f180be 100644
--- a/server/src/test/java/org/opensearch/action/admin/indices/close/TransportVerifyShardBeforeCloseActionTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/indices/close/TransportVerifyShardBeforeCloseActionTests.java
@@ -82,6 +82,7 @@
 import org.mockito.ArgumentCaptor;
 
 import static org.opensearch.action.support.replication.ClusterStateCreationUtils.state;
+import static org.opensearch.index.remote.RemoteStoreTestsHelper.createIndexSettings;
 import static org.opensearch.test.ClusterServiceUtils.createClusterService;
 import static org.opensearch.test.ClusterServiceUtils.setState;
 import static org.hamcrest.Matchers.arrayWithSize;
@@ -332,15 +333,15 @@ public void testUnavailableShardsMarkedAsStale() throws Exception {
     public void testGetReplicationModeWithRemoteTranslog() {
         TransportVerifyShardBeforeCloseAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(true);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(true));
         assertEquals(ReplicationMode.NO_REPLICATION, action.getReplicationMode(indexShard));
     }
 
     public void testGetReplicationModeWithLocalTranslog() {
         TransportVerifyShardBeforeCloseAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(true);
-        assertEquals(ReplicationMode.NO_REPLICATION, action.getReplicationMode(indexShard));
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(false));
+        assertEquals(ReplicationMode.FULL_REPLICATION, action.getReplicationMode(indexShard));
     }
 
     private TransportVerifyShardBeforeCloseAction createAction() {
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/flush/TransportShardFlushActionTests.java b/server/src/test/java/org/opensearch/action/admin/indices/flush/TransportShardFlushActionTests.java
index 09215088bd04b..c9d3a6c4c7605 100644
--- a/server/src/test/java/org/opensearch/action/admin/indices/flush/TransportShardFlushActionTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/indices/flush/TransportShardFlushActionTests.java
@@ -20,6 +20,7 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportService;
 
+import static org.opensearch.index.remote.RemoteStoreTestsHelper.createIndexSettings;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -28,14 +29,14 @@ public class TransportShardFlushActionTests extends OpenSearchTestCase {
     public void testGetReplicationModeWithRemoteTranslog() {
         TransportShardFlushAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(true);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(true));
         assertEquals(ReplicationMode.NO_REPLICATION, action.getReplicationMode(indexShard));
     }
 
     public void testGetReplicationModeWithLocalTranslog() {
         TransportShardFlushAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(false);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(false));
         assertEquals(ReplicationMode.FULL_REPLICATION, action.getReplicationMode(indexShard));
     }
 
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/readonly/TransportVerifyShardIndexBlockActionTests.java b/server/src/test/java/org/opensearch/action/admin/indices/readonly/TransportVerifyShardIndexBlockActionTests.java
index 8c4a6c023f9a5..90498d6d35700 100644
--- a/server/src/test/java/org/opensearch/action/admin/indices/readonly/TransportVerifyShardIndexBlockActionTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/indices/readonly/TransportVerifyShardIndexBlockActionTests.java
@@ -20,6 +20,7 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportService;
 
+import static org.opensearch.index.remote.RemoteStoreTestsHelper.createIndexSettings;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -28,14 +29,14 @@ public class TransportVerifyShardIndexBlockActionTests extends OpenSearchTestCas
     public void testGetReplicationModeWithRemoteTranslog() {
         TransportVerifyShardIndexBlockAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(true);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(true));
         assertEquals(ReplicationMode.NO_REPLICATION, action.getReplicationMode(indexShard));
     }
 
     public void testGetReplicationModeWithLocalTranslog() {
         TransportVerifyShardIndexBlockAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(false);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(false));
         assertEquals(ReplicationMode.FULL_REPLICATION, action.getReplicationMode(indexShard));
     }
 
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/refresh/TransportShardRefreshActionTests.java b/server/src/test/java/org/opensearch/action/admin/indices/refresh/TransportShardRefreshActionTests.java
index b2eee904bad38..bc0b7e5cf14b2 100644
--- a/server/src/test/java/org/opensearch/action/admin/indices/refresh/TransportShardRefreshActionTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/indices/refresh/TransportShardRefreshActionTests.java
@@ -20,6 +20,7 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportService;
 
+import static org.opensearch.index.remote.RemoteStoreTestsHelper.createIndexSettings;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -28,14 +29,14 @@ public class TransportShardRefreshActionTests extends OpenSearchTestCase {
     public void testGetReplicationModeWithRemoteTranslog() {
         TransportShardRefreshAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(true);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(true));
         assertEquals(ReplicationMode.NO_REPLICATION, action.getReplicationMode(indexShard));
     }
 
     public void testGetReplicationModeWithLocalTranslog() {
         TransportShardRefreshAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(false);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(false));
         assertEquals(ReplicationMode.FULL_REPLICATION, action.getReplicationMode(indexShard));
     }
 
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/shrink/TransportResizeActionTests.java b/server/src/test/java/org/opensearch/action/admin/indices/shrink/TransportResizeActionTests.java
index 848df5f8e4979..5bab2ceca0988 100644
--- a/server/src/test/java/org/opensearch/action/admin/indices/shrink/TransportResizeActionTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/indices/shrink/TransportResizeActionTests.java
@@ -51,10 +51,13 @@
 import org.opensearch.cluster.routing.allocation.allocator.BalancedShardsAllocator;
 import org.opensearch.cluster.routing.allocation.decider.AllocationDeciders;
 import org.opensearch.cluster.routing.allocation.decider.MaxRetryAllocationDecider;
+import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.index.shard.DocsStats;
 import org.opensearch.index.store.StoreStats;
+import org.opensearch.node.remotestore.RemoteStoreNodeService;
 import org.opensearch.snapshots.EmptySnapshotsInfoService;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.gateway.TestGatewayAllocator;
@@ -65,7 +68,12 @@
 import java.util.Set;
 
 import static java.util.Collections.emptyMap;
-import static org.hamcrest.Matchers.equalTo;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REMOTE_STORE_ENABLED;
+import static org.opensearch.common.util.FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL;
+import static org.opensearch.node.remotestore.RemoteStoreNodeService.CompatibilityMode;
+import static org.opensearch.node.remotestore.RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING;
+import static org.opensearch.node.remotestore.RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING;
+import static org.hamcrest.CoreMatchers.equalTo;
 
 public class TransportResizeActionTests extends OpenSearchTestCase {
 
@@ -95,6 +103,19 @@ private ClusterState createClusterState(String name, int numShards, int numRepli
         return clusterState;
     }
 
+    private ClusterSettings createClusterSettings(
+        CompatibilityMode compatibilityMode,
+        RemoteStoreNodeService.Direction migrationDirection
+    ) {
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        clusterSettings.applySettings(
+            (Settings.builder()
+                .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), compatibilityMode)
+                .put(MIGRATION_DIRECTION_SETTING.getKey(), migrationDirection)).build()
+        );
+        return clusterSettings;
+    }
+
     public void testErrorCondition() {
         ClusterState state = createClusterState(
             "source",
@@ -102,6 +123,7 @@ public void testErrorCondition() {
             randomIntBetween(0, 10),
             Settings.builder().put("index.blocks.write", true).build()
         );
+        ClusterSettings clusterSettings = createClusterSettings(CompatibilityMode.STRICT, RemoteStoreNodeService.Direction.NONE);
         assertTrue(
             expectThrows(
                 IllegalStateException.class,
@@ -110,6 +132,7 @@ public void testErrorCondition() {
                     state,
                     (i) -> new DocsStats(Integer.MAX_VALUE, between(1, 1000), between(1, 100)),
                     new StoreStats(between(1, 10000), between(1, 10000)),
+                    clusterSettings,
                     "source",
                     "target"
                 )
@@ -125,6 +148,7 @@ public void testErrorCondition() {
                 clusterState,
                 (i) -> i == 2 || i == 3 ? new DocsStats(Integer.MAX_VALUE / 2, between(1, 1000), between(1, 10000)) : null,
                 new StoreStats(between(1, 10000), between(1, 10000)),
+                clusterSettings,
                 "source",
                 "target"
             );
@@ -144,6 +168,7 @@ public void testErrorCondition() {
                 clusterState,
                 (i) -> new DocsStats(between(10, 1000), between(1, 10), between(1, 10000)),
                 new StoreStats(between(1, 10000), between(1, 10000)),
+                clusterSettings,
                 "source",
                 "target"
             );
@@ -173,6 +198,7 @@ public void testErrorCondition() {
             clusterState,
             (i) -> new DocsStats(between(1, 1000), between(1, 1000), between(0, 10000)),
             new StoreStats(between(1, 10000), between(1, 10000)),
+            clusterSettings,
             "source",
             "target"
         );
@@ -189,7 +215,7 @@ public void testPassNumRoutingShards() {
             EmptyClusterInfoService.INSTANCE,
             EmptySnapshotsInfoService.INSTANCE
         );
-
+        ClusterSettings clusterSettings = createClusterSettings(CompatibilityMode.STRICT, RemoteStoreNodeService.Direction.NONE);
         RoutingTable routingTable = service.reroute(clusterState, "reroute").routingTable();
         clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
         // now we start the shard
@@ -204,6 +230,7 @@ public void testPassNumRoutingShards() {
             clusterState,
             null,
             new StoreStats(between(1, 10000), between(1, 10000)),
+            clusterSettings,
             "source",
             "target"
         );
@@ -217,6 +244,7 @@ public void testPassNumRoutingShards() {
             clusterState,
             null,
             new StoreStats(between(1, 10000), between(1, 10000)),
+            clusterSettings,
             "source",
             "target"
         );
@@ -235,6 +263,7 @@ public void testPassNumRoutingShardsAndFail() {
             EmptySnapshotsInfoService.INSTANCE
         );
 
+        ClusterSettings clusterSettings = createClusterSettings(CompatibilityMode.STRICT, RemoteStoreNodeService.Direction.NONE);
         RoutingTable routingTable = service.reroute(clusterState, "reroute").routingTable();
         clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
         // now we start the shard
@@ -249,6 +278,7 @@ public void testPassNumRoutingShardsAndFail() {
             clusterState,
             null,
             new StoreStats(between(1, 10000), between(1, 10000)),
+            clusterSettings,
             "source",
             "target"
         );
@@ -265,6 +295,7 @@ public void testPassNumRoutingShardsAndFail() {
                 finalState,
                 null,
                 new StoreStats(between(1, 10000), between(1, 10000)),
+                clusterSettings,
                 "source",
                 "target"
             )
@@ -286,6 +317,7 @@ public void testShrinkIndexSettings() {
             EmptySnapshotsInfoService.INSTANCE
         );
 
+        ClusterSettings clusterSettings = createClusterSettings(CompatibilityMode.STRICT, RemoteStoreNodeService.Direction.NONE);
         RoutingTable routingTable = service.reroute(clusterState, "reroute").routingTable();
         clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
         // now we start the shard
@@ -301,6 +333,7 @@ public void testShrinkIndexSettings() {
             clusterState,
             (i) -> stats,
             new StoreStats(between(1, 10000), between(1, 10000)),
+            clusterSettings,
             indexName,
             "target"
         );
@@ -325,6 +358,8 @@ public void testShrinkWithMaxShardSize() {
             EmptyClusterInfoService.INSTANCE,
             EmptySnapshotsInfoService.INSTANCE
         );
+
+        ClusterSettings clusterSettings = createClusterSettings(CompatibilityMode.STRICT, RemoteStoreNodeService.Direction.NONE);
         RoutingTable routingTable = service.reroute(clusterState, "reroute").routingTable();
         clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
         // now we start the shard
@@ -345,6 +380,7 @@ public void testShrinkWithMaxShardSize() {
             clusterState,
             (i) -> stats,
             new StoreStats(100, between(1, 10000)),
+            clusterSettings,
             indexName,
             "target"
         );
@@ -366,6 +402,7 @@ public void testShrinkWithMaxShardSize() {
             clusterState,
             (i) -> stats,
             new StoreStats(100, between(1, 10000)),
+            clusterSettings,
             indexName,
             "target"
         );
@@ -387,6 +424,7 @@ public void testShrinkWithMaxShardSize() {
             clusterState,
             (i) -> stats,
             new StoreStats(100, between(1, 10000)),
+            clusterSettings,
             indexName,
             "target"
         );
@@ -477,6 +515,7 @@ public void testIndexBlocks() {
             createClusterState(indexName, 10, 0, 40, Settings.builder().put("index.blocks.read_only", true).build())
         ).nodes(DiscoveryNodes.builder().add(newNode("node1"))).build();
 
+        ClusterSettings clusterSettings = createClusterSettings(CompatibilityMode.STRICT, RemoteStoreNodeService.Direction.NONE);
         // Target index will be blocked by [index.blocks.read_only=true] copied from the source index
         ResizeRequest resizeRequest = new ResizeRequest("target", indexName);
         ResizeType resizeType;
@@ -500,6 +539,7 @@ public void testIndexBlocks() {
                 finalState,
                 null,
                 new StoreStats(between(1, 10000), between(1, 10000)),
+                clusterSettings,
                 indexName,
                 "target"
             )
@@ -551,6 +591,7 @@ public void testIndexBlocks() {
             clusterState,
             (i) -> stats,
             new StoreStats(100, between(1, 10000)),
+            clusterSettings,
             indexName,
             "target"
         );
@@ -561,6 +602,127 @@ public void testIndexBlocks() {
         assertEquals(request.waitForActiveShards(), activeShardCount);
     }
 
+    public void testResizeFailuresDuringMigration() {
+        // We will keep all other settings correct for resize request,
+        // So we only need to test for the failures due to cluster setting validation while migration
+        final Settings directionEnabledNodeSettings = Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
+        FeatureFlags.initializeFeatureFlags(directionEnabledNodeSettings);
+        boolean isRemoteStoreEnabled = randomBoolean();
+        CompatibilityMode compatibilityMode = randomFrom(CompatibilityMode.values());
+        RemoteStoreNodeService.Direction migrationDirection = randomFrom(RemoteStoreNodeService.Direction.values());
+        // If not mixed mode, then migration direction is NONE.
+        if (!compatibilityMode.equals(CompatibilityMode.MIXED)) {
+            migrationDirection = RemoteStoreNodeService.Direction.NONE;
+        }
+        ClusterSettings clusterSettings = createClusterSettings(compatibilityMode, migrationDirection);
+
+        ClusterState clusterState = ClusterState.builder(
+            createClusterState(
+                "source",
+                10,
+                0,
+                40,
+                Settings.builder().put("index.blocks.write", true).put(SETTING_REMOTE_STORE_ENABLED, isRemoteStoreEnabled).build()
+            )
+        ).nodes(DiscoveryNodes.builder().add(newNode("node1"))).build();
+        AllocationService service = new AllocationService(
+            new AllocationDeciders(Collections.singleton(new MaxRetryAllocationDecider())),
+            new TestGatewayAllocator(),
+            new BalancedShardsAllocator(Settings.EMPTY),
+            EmptyClusterInfoService.INSTANCE,
+            EmptySnapshotsInfoService.INSTANCE
+        );
+
+        RoutingTable routingTable = service.reroute(clusterState, "reroute").routingTable();
+        clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
+        // now we start the shard
+        routingTable = OpenSearchAllocationTestCase.startInitializingShardsAndReroute(service, clusterState, "source").routingTable();
+        clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
+        DocsStats stats = new DocsStats(between(0, (IndexWriter.MAX_DOCS) / 10), between(1, 1000), between(1, 10000));
+        ResizeRequest resizeRequest = new ResizeRequest("target", "source");
+        ResizeType resizeType;
+        int expectedShardsNum;
+        String cause;
+        switch (randomIntBetween(0, 2)) {
+            case 0:
+                resizeType = ResizeType.SHRINK;
+                expectedShardsNum = 5;
+                cause = "shrink_index";
+                break;
+            case 1:
+                resizeType = ResizeType.SPLIT;
+                expectedShardsNum = 20;
+                cause = "split_index";
+                break;
+            default:
+                resizeType = ResizeType.CLONE;
+                expectedShardsNum = 10;
+                cause = "clone_index";
+        }
+        resizeRequest.setResizeType(resizeType);
+        resizeRequest.getTargetIndexRequest()
+            .settings(Settings.builder().put("index.number_of_shards", expectedShardsNum).put("index.blocks.read_only", false).build());
+        final ActiveShardCount activeShardCount = randomBoolean() ? ActiveShardCount.ALL : ActiveShardCount.ONE;
+        resizeRequest.setWaitForActiveShards(activeShardCount);
+
+        if (compatibilityMode == CompatibilityMode.MIXED) {
+            if ((migrationDirection == RemoteStoreNodeService.Direction.REMOTE_STORE && isRemoteStoreEnabled == false)
+                || migrationDirection == RemoteStoreNodeService.Direction.DOCREP && isRemoteStoreEnabled == true) {
+                ClusterState finalState = clusterState;
+                IllegalStateException ise = expectThrows(
+                    IllegalStateException.class,
+                    () -> TransportResizeAction.prepareCreateIndexRequest(
+                        resizeRequest,
+                        finalState,
+                        (i) -> stats,
+                        new StoreStats(between(1, 10000), between(1, 10000)),
+                        clusterSettings,
+                        "source",
+                        "target"
+                    )
+                );
+                assertEquals(
+                    ise.getMessage(),
+                    "Index "
+                        + resizeType
+                        + " is not allowed as remote migration mode is mixed"
+                        + " and index is remote store "
+                        + (isRemoteStoreEnabled ? "enabled" : "disabled")
+                );
+            } else {
+                CreateIndexClusterStateUpdateRequest request = TransportResizeAction.prepareCreateIndexRequest(
+                    resizeRequest,
+                    clusterState,
+                    (i) -> stats,
+                    new StoreStats(100, between(1, 10000)),
+                    clusterSettings,
+                    "source",
+                    "target"
+                );
+                assertNotNull(request.recoverFrom());
+                assertEquals("source", request.recoverFrom().getName());
+                assertEquals(String.valueOf(expectedShardsNum), request.settings().get("index.number_of_shards"));
+                assertEquals(cause, request.cause());
+                assertEquals(request.waitForActiveShards(), activeShardCount);
+            }
+        } else {
+            CreateIndexClusterStateUpdateRequest request = TransportResizeAction.prepareCreateIndexRequest(
+                resizeRequest,
+                clusterState,
+                (i) -> stats,
+                new StoreStats(100, between(1, 10000)),
+                clusterSettings,
+                "source",
+                "target"
+            );
+            assertNotNull(request.recoverFrom());
+            assertEquals("source", request.recoverFrom().getName());
+            assertEquals(String.valueOf(expectedShardsNum), request.settings().get("index.number_of_shards"));
+            assertEquals(cause, request.cause());
+            assertEquals(request.waitForActiveShards(), activeShardCount);
+        }
+    }
+
     private DiscoveryNode newNode(String nodeId) {
         final Set<DiscoveryNodeRole> roles = Collections.unmodifiableSet(
             new HashSet<>(Arrays.asList(DiscoveryNodeRole.CLUSTER_MANAGER_ROLE, DiscoveryNodeRole.DATA_ROLE))
diff --git a/server/src/test/java/org/opensearch/action/bulk/BulkRequestParserTests.java b/server/src/test/java/org/opensearch/action/bulk/BulkRequestParserTests.java
index 4f07c098b0869..9625475607911 100644
--- a/server/src/test/java/org/opensearch/action/bulk/BulkRequestParserTests.java
+++ b/server/src/test/java/org/opensearch/action/bulk/BulkRequestParserTests.java
@@ -112,6 +112,13 @@ public void testUpdateRequest() throws IOException {
         parser.parse(request, "foo", null, null, null, true, false, MediaTypeRegistry.JSON, req -> fail(), updateRequest -> {
             assertFalse(updateRequest.isRequireAlias());
         }, req -> fail());
+
+        request = new BytesArray(
+            "{ \"update\":{ \"_id\": \"bar\", \"require_alias\": false, \"pipeline\": \"testPipeline\" } }\n{\"upsert\": {\"x\": 1}}\n"
+        );
+        parser.parse(request, "foo", null, null, null, true, false, MediaTypeRegistry.JSON, req -> fail(), updateRequest -> {
+            assertEquals(updateRequest.upsertRequest().getPipeline(), "testPipeline");
+        }, req -> fail());
     }
 
     public void testBarfOnLackOfTrailingNewline() {
diff --git a/server/src/test/java/org/opensearch/action/bulk/TransportShardBulkActionTests.java b/server/src/test/java/org/opensearch/action/bulk/TransportShardBulkActionTests.java
index 65b555649b2d0..6331861c3dcb9 100644
--- a/server/src/test/java/org/opensearch/action/bulk/TransportShardBulkActionTests.java
+++ b/server/src/test/java/org/opensearch/action/bulk/TransportShardBulkActionTests.java
@@ -107,6 +107,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.LongSupplier;
 
+import static org.opensearch.index.remote.RemoteStoreTestsHelper.createIndexSettings;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.hamcrest.CoreMatchers.not;
@@ -1237,14 +1238,14 @@ public void testHandlePrimaryTermValidationRequestSuccess() {
     public void testGetReplicationModeWithRemoteTranslog() {
         TransportShardBulkAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(true);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(true));
         assertEquals(ReplicationMode.PRIMARY_TERM_VALIDATION, action.getReplicationMode(indexShard));
     }
 
     public void testGetReplicationModeWithLocalTranslog() {
         TransportShardBulkAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(false);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(false));
         assertEquals(ReplicationMode.FULL_REPLICATION, action.getReplicationMode(indexShard));
     }
 
diff --git a/server/src/test/java/org/opensearch/action/resync/TransportResyncReplicationActionTests.java b/server/src/test/java/org/opensearch/action/resync/TransportResyncReplicationActionTests.java
index da87a0a967f53..a2fefd6278321 100644
--- a/server/src/test/java/org/opensearch/action/resync/TransportResyncReplicationActionTests.java
+++ b/server/src/test/java/org/opensearch/action/resync/TransportResyncReplicationActionTests.java
@@ -84,6 +84,7 @@
 import static java.util.Collections.emptyList;
 import static java.util.Collections.emptyMap;
 import static org.opensearch.action.support.replication.ClusterStateCreationUtils.state;
+import static org.opensearch.index.remote.RemoteStoreTestsHelper.createIndexSettings;
 import static org.opensearch.test.ClusterServiceUtils.createClusterService;
 import static org.opensearch.test.ClusterServiceUtils.setState;
 import static org.opensearch.transport.TransportService.NOOP_TRANSPORT_INTERCEPTOR;
@@ -233,14 +234,14 @@ public void testResyncDoesNotBlockOnPrimaryAction() throws Exception {
     public void testGetReplicationModeWithRemoteTranslog() {
         final TransportResyncReplicationAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(true);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(true));
         assertEquals(ReplicationMode.NO_REPLICATION, action.getReplicationMode(indexShard));
     }
 
     public void testGetReplicationModeWithLocalTranslog() {
         final TransportResyncReplicationAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(false);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(false));
         assertEquals(ReplicationMode.FULL_REPLICATION, action.getReplicationMode(indexShard));
     }
 
diff --git a/server/src/test/java/org/opensearch/action/support/replication/ReplicationModeAwareProxyTests.java b/server/src/test/java/org/opensearch/action/support/replication/ReplicationModeAwareProxyTests.java
new file mode 100644
index 0000000000000..626c2f74f09c4
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/support/replication/ReplicationModeAwareProxyTests.java
@@ -0,0 +1,216 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.support.replication;
+
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.AllocationId;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.ShardRoutingState;
+import org.opensearch.cluster.routing.TestShardRouting;
+import org.opensearch.core.index.Index;
+import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.shard.IndexShardTestUtils;
+import org.opensearch.test.OpenSearchTestCase;
+
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+public class ReplicationModeAwareProxyTests extends OpenSearchTestCase {
+
+    /*
+    Replication action running on the same primary copy from which it originates.
+    Action should not run and proxy should return ReplicationMode.NO_REPLICATION
+     */
+    public void testDetermineReplicationModeTargetRoutingCurrentPrimary() {
+        ShardRouting targetRouting = TestShardRouting.newShardRouting(
+            new ShardId(new Index("test_index", "_na_"), 0),
+            "dummy-node",
+            null,
+            true,
+            ShardRoutingState.STARTED,
+            AllocationId.newInitializing("abc")
+        );
+        ShardRouting primaryRouting = TestShardRouting.newShardRouting(
+            new ShardId(new Index("test_index", "_na_"), 0),
+            "dummy-node",
+            null,
+            true,
+            ShardRoutingState.STARTED,
+            AllocationId.newInitializing("abc")
+        );
+        final ReplicationModeAwareProxy replicationModeAwareProxy = new ReplicationModeAwareProxy(
+            ReplicationMode.NO_REPLICATION,
+            DiscoveryNodes.builder().add(IndexShardTestUtils.getFakeRemoteEnabledNode("dummy-node")).build(),
+            mock(TransportReplicationAction.ReplicasProxy.class),
+            mock(TransportReplicationAction.ReplicasProxy.class),
+            randomBoolean()
+        );
+        assertEquals(ReplicationMode.NO_REPLICATION, replicationModeAwareProxy.determineReplicationMode(targetRouting, primaryRouting));
+    }
+
+    /*
+     Replication action originating from failing primary to replica being promoted to primary
+     Action should run and proxy should return ReplicationMode.FULL_REPLICATION
+     */
+    public void testDetermineReplicationModeTargetRoutingRelocatingPrimary() {
+        AllocationId primaryId = AllocationId.newRelocation(AllocationId.newInitializing());
+        AllocationId relocationTargetId = AllocationId.newTargetRelocation(primaryId);
+        ShardRouting targetRouting = TestShardRouting.newShardRouting(
+            new ShardId(new Index("test_index", "_na_"), 0),
+            "dummy-node-2",
+            null,
+            true,
+            ShardRoutingState.INITIALIZING,
+            relocationTargetId
+        );
+        ShardRouting primaryRouting = TestShardRouting.newShardRouting(
+            new ShardId(new Index("test_index", "_na_"), 0),
+            "dummy-node",
+            "dummy-node-2",
+            true,
+            ShardRoutingState.RELOCATING,
+            primaryId
+        );
+        final ReplicationModeAwareProxy replicationModeAwareProxy = new ReplicationModeAwareProxy(
+            ReplicationMode.NO_REPLICATION,
+            DiscoveryNodes.builder()
+                .add(IndexShardTestUtils.getFakeRemoteEnabledNode(targetRouting.currentNodeId()))
+                .add(IndexShardTestUtils.getFakeRemoteEnabledNode(primaryRouting.currentNodeId()))
+                .build(),
+            mock(TransportReplicationAction.ReplicasProxy.class),
+            mock(TransportReplicationAction.ReplicasProxy.class),
+            randomBoolean()
+        );
+        assertEquals(ReplicationMode.FULL_REPLICATION, replicationModeAwareProxy.determineReplicationMode(targetRouting, primaryRouting));
+    }
+
+    /*
+     Replication action originating from remote enabled primary to docrep replica during remote store migration
+     Action should run and proxy should return ReplicationMode.FULL_REPLICATION
+     */
+    public void testDetermineReplicationModeTargetRoutingDocrepShard() {
+        ShardRouting primaryRouting = TestShardRouting.newShardRouting(
+            new ShardId(new Index("test_index", "_na_"), 0),
+            "dummy-node",
+            true,
+            ShardRoutingState.STARTED
+        );
+        ShardRouting targetRouting = TestShardRouting.newShardRouting(
+            new ShardId(new Index("test_index", "_na_"), 0),
+            "dummy-node-2",
+            false,
+            ShardRoutingState.STARTED
+        );
+        final ReplicationModeAwareProxy replicationModeAwareProxy = new ReplicationModeAwareProxy(
+            ReplicationMode.NO_REPLICATION,
+            DiscoveryNodes.builder()
+                .add(IndexShardTestUtils.getFakeRemoteEnabledNode(primaryRouting.currentNodeId()))
+                .add(IndexShardTestUtils.getFakeDiscoNode(targetRouting.currentNodeId()))
+                .build(),
+            mock(TransportReplicationAction.ReplicasProxy.class),
+            mock(TransportReplicationAction.ReplicasProxy.class),
+            false
+        );
+        assertEquals(ReplicationMode.FULL_REPLICATION, replicationModeAwareProxy.determineReplicationMode(targetRouting, primaryRouting));
+    }
+
+    /*
+     Replication action originating from remote enabled primary to remote replica during remote store migration
+     Action should not run and proxy should return ReplicationMode.NO_REPLICATION
+     */
+    public void testDetermineReplicationModeTargetRoutingRemoteShard() {
+        ShardRouting primaryRouting = TestShardRouting.newShardRouting(
+            new ShardId(new Index("test_index", "_na_"), 0),
+            "dummy-node",
+            false,
+            ShardRoutingState.STARTED
+        );
+        ShardRouting targetRouting = TestShardRouting.newShardRouting(
+            new ShardId(new Index("test_index", "_na_"), 0),
+            "dummy-node-2",
+            true,
+            ShardRoutingState.STARTED
+        );
+        final ReplicationModeAwareProxy replicationModeAwareProxy = new ReplicationModeAwareProxy(
+            ReplicationMode.NO_REPLICATION,
+            DiscoveryNodes.builder()
+                .add(IndexShardTestUtils.getFakeRemoteEnabledNode(targetRouting.currentNodeId()))
+                .add(IndexShardTestUtils.getFakeRemoteEnabledNode(primaryRouting.currentNodeId()))
+                .build(),
+            mock(TransportReplicationAction.ReplicasProxy.class),
+            mock(TransportReplicationAction.ReplicasProxy.class),
+            false
+        );
+        assertEquals(ReplicationMode.NO_REPLICATION, replicationModeAwareProxy.determineReplicationMode(targetRouting, primaryRouting));
+    }
+
+    /*
+     Replication action originating from remote enabled primary to remote enabled replica during remote store migration
+     with an explicit replication mode specified
+     Action should run and proxy should return the overridden Replication Mode
+     */
+    public void testDetermineReplicationWithExplicitOverrideTargetRoutingRemoteShard() {
+        ReplicationMode replicationModeOverride = ReplicationMode.PRIMARY_TERM_VALIDATION;
+        ShardRouting primaryRouting = TestShardRouting.newShardRouting(
+            new ShardId(new Index("test_index", "_na_"), 0),
+            "dummy-node",
+            false,
+            ShardRoutingState.STARTED
+        );
+        ShardRouting targetRouting = TestShardRouting.newShardRouting(
+            new ShardId(new Index("test_index", "_na_"), 0),
+            "dummy-node-2",
+            true,
+            ShardRoutingState.STARTED
+        );
+        final ReplicationModeAwareProxy replicationModeAwareProxy = new ReplicationModeAwareProxy(
+            replicationModeOverride,
+            DiscoveryNodes.builder()
+                .add(IndexShardTestUtils.getFakeRemoteEnabledNode(targetRouting.currentNodeId()))
+                .add(IndexShardTestUtils.getFakeRemoteEnabledNode(primaryRouting.currentNodeId()))
+                .build(),
+            mock(TransportReplicationAction.ReplicasProxy.class),
+            mock(TransportReplicationAction.ReplicasProxy.class),
+            false
+        );
+        assertEquals(replicationModeOverride, replicationModeAwareProxy.determineReplicationMode(targetRouting, primaryRouting));
+    }
+
+    /*
+     Replication action originating from remote enabled primary with remote enabled index settings enabled
+     Action should not query the DiscoveryNodes object
+     */
+    public void testDetermineReplicationWithRemoteIndexSettingsEnabled() {
+        DiscoveryNodes mockDiscoveryNodes = mock(DiscoveryNodes.class);
+        ShardRouting primaryRouting = TestShardRouting.newShardRouting(
+            new ShardId(new Index("test_index", "_na_"), 0),
+            "dummy-node",
+            false,
+            ShardRoutingState.STARTED
+        );
+        ShardRouting targetRouting = TestShardRouting.newShardRouting(
+            new ShardId(new Index("test_index", "_na_"), 0),
+            "dummy-node-2",
+            true,
+            ShardRoutingState.STARTED
+        );
+        final ReplicationModeAwareProxy replicationModeAwareProxy = new ReplicationModeAwareProxy(
+            ReplicationMode.NO_REPLICATION,
+            mockDiscoveryNodes,
+            mock(TransportReplicationAction.ReplicasProxy.class),
+            mock(TransportReplicationAction.ReplicasProxy.class),
+            true
+        );
+        replicationModeAwareProxy.determineReplicationMode(targetRouting, primaryRouting);
+        // Verify no interactions with the DiscoveryNodes object
+        verify(mockDiscoveryNodes, never()).get(anyString());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java b/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java
index 6b54623b03164..ec5fc1d19e40d 100644
--- a/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java
+++ b/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java
@@ -48,6 +48,7 @@
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.ShardRoutingState;
+import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
 import org.opensearch.common.util.set.Sets;
@@ -59,6 +60,7 @@
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.shard.IndexShardNotStartedException;
 import org.opensearch.index.shard.IndexShardState;
+import org.opensearch.index.shard.IndexShardTestUtils;
 import org.opensearch.index.shard.ReplicationGroup;
 import org.opensearch.node.NodeClosedException;
 import org.opensearch.test.OpenSearchTestCase;
@@ -239,7 +241,13 @@ public void testReplicationWithRemoteTranslogEnabled() throws Exception {
             listener,
             replicasProxy,
             0,
-            new ReplicationModeAwareProxy<>(ReplicationMode.NO_REPLICATION, replicasProxy, replicasProxy)
+            new ReplicationModeAwareProxy<>(
+                ReplicationMode.NO_REPLICATION,
+                buildRemoteStoreEnabledDiscoveryNodes(routingTable),
+                replicasProxy,
+                replicasProxy,
+                true
+            )
         );
         op.execute();
         assertTrue("request was not processed on primary", request.processedOnPrimary.get());
@@ -304,7 +312,13 @@ public void testPrimaryToPrimaryReplicationWithRemoteTranslogEnabled() throws Ex
             listener,
             replicasProxy,
             0,
-            new ReplicationModeAwareProxy<>(ReplicationMode.NO_REPLICATION, replicasProxy, replicasProxy)
+            new ReplicationModeAwareProxy<>(
+                ReplicationMode.NO_REPLICATION,
+                buildRemoteStoreEnabledDiscoveryNodes(routingTable),
+                replicasProxy,
+                replicasProxy,
+                true
+            )
         );
         op.execute();
         assertTrue("request was not processed on primary", request.processedOnPrimary.get());
@@ -380,6 +394,144 @@ public void testForceReplicationWithRemoteTranslogEnabled() throws Exception {
         assertEquals(activeIds.size() + initializingIds.size(), shardInfo.getTotal());
     }
 
+    public void testReplicationInDualModeWithDocrepReplica() throws Exception {
+        Set<AllocationId> initializingIds = new HashSet<>();
+        IntStream.range(0, randomIntBetween(2, 5)).forEach(x -> initializingIds.add(AllocationId.newInitializing()));
+        Set<AllocationId> activeIds = new HashSet<>();
+        IntStream.range(0, randomIntBetween(2, 5)).forEach(x -> activeIds.add(AllocationId.newInitializing()));
+
+        AllocationId primaryId = activeIds.iterator().next();
+
+        ShardId shardId = new ShardId("test", "_na_", 0);
+        IndexShardRoutingTable.Builder builder = new IndexShardRoutingTable.Builder(shardId);
+        final ShardRouting primaryShard = newShardRouting(
+            shardId,
+            nodeIdFromAllocationId(primaryId),
+            null,
+            true,
+            ShardRoutingState.STARTED,
+            primaryId
+        );
+        initializingIds.forEach(aId -> {
+            ShardRouting routing = newShardRouting(shardId, nodeIdFromAllocationId(aId), null, false, ShardRoutingState.INITIALIZING, aId);
+            builder.addShard(routing);
+        });
+        activeIds.stream().filter(aId -> !aId.equals(primaryId)).forEach(aId -> {
+            ShardRouting routing = newShardRouting(shardId, nodeIdFromAllocationId(aId), null, false, ShardRoutingState.STARTED, aId);
+            builder.addShard(routing);
+        });
+        builder.addShard(primaryShard);
+        IndexShardRoutingTable routingTable = builder.build();
+
+        Set<String> inSyncAllocationIds = activeIds.stream().map(AllocationId::getId).collect(Collectors.toSet());
+        ReplicationGroup replicationGroup = new ReplicationGroup(routingTable, inSyncAllocationIds, inSyncAllocationIds, 0);
+        List<ShardRouting> replicationTargets = replicationGroup.getReplicationTargets();
+        assertEquals(inSyncAllocationIds.size(), replicationTargets.size());
+        assertTrue(
+            replicationTargets.stream().map(sh -> sh.allocationId().getId()).collect(Collectors.toSet()).containsAll(inSyncAllocationIds)
+        );
+
+        Request request = new Request(shardId);
+        PlainActionFuture<TestPrimary.Result> listener = new PlainActionFuture<>();
+        Map<ShardRouting, Exception> simulatedFailures = new HashMap<>();
+        TestReplicaProxy replicasProxy = new TestReplicaProxy(simulatedFailures);
+        TestPrimary primary = new TestPrimary(primaryShard, () -> replicationGroup, threadPool);
+        final TestReplicationOperation op = new TestReplicationOperation(
+            request,
+            primary,
+            listener,
+            replicasProxy,
+            0,
+            new ReplicationModeAwareProxy<>(
+                ReplicationMode.NO_REPLICATION,
+                buildDiscoveryNodes(routingTable),
+                replicasProxy,
+                replicasProxy,
+                false
+            )
+        );
+        op.execute();
+        assertTrue("request was not processed on primary", request.processedOnPrimary.get());
+        // During dual replication, except for primary, replication action should be executed on all the replicas
+        assertEquals(activeIds.size() - 1, request.processedOnReplicas.size());
+        assertEquals(0, replicasProxy.failedReplicas.size());
+        assertEquals(0, replicasProxy.markedAsStaleCopies.size());
+        assertTrue("post replication operations not run on primary", request.runPostReplicationActionsOnPrimary.get());
+        assertTrue("listener is not marked as done", listener.isDone());
+
+        ShardInfo shardInfo = listener.actionGet().getShardInfo();
+        // All initializing and active shards are set to docrep
+        assertEquals(initializingIds.size() + activeIds.size(), shardInfo.getTotal());
+    }
+
+    public void testReplicationInDualModeWithMixedReplicasSomeInDocrepOthersOnRemote() throws Exception {
+        Set<AllocationId> initializingIds = new HashSet<>();
+        IntStream.range(0, randomIntBetween(2, 5)).forEach(x -> initializingIds.add(AllocationId.newInitializing()));
+        Set<AllocationId> activeIds = new HashSet<>();
+        IntStream.range(0, randomIntBetween(2, 5)).forEach(x -> activeIds.add(AllocationId.newInitializing()));
+
+        AllocationId primaryId = activeIds.iterator().next();
+
+        ShardId shardId = new ShardId("test", "_na_", 0);
+        IndexShardRoutingTable.Builder builder = new IndexShardRoutingTable.Builder(shardId);
+        final ShardRouting primaryShard = newShardRouting(
+            shardId,
+            nodeIdFromAllocationId(primaryId),
+            null,
+            true,
+            ShardRoutingState.STARTED,
+            primaryId
+        );
+        initializingIds.forEach(aId -> {
+            ShardRouting routing = newShardRouting(shardId, nodeIdFromAllocationId(aId), null, false, ShardRoutingState.INITIALIZING, aId);
+            builder.addShard(routing);
+        });
+        activeIds.stream().filter(aId -> !aId.equals(primaryId)).forEach(aId -> {
+            ShardRouting routing = newShardRouting(shardId, nodeIdFromAllocationId(aId), null, false, ShardRoutingState.STARTED, aId);
+            builder.addShard(routing);
+        });
+        builder.addShard(primaryShard);
+        IndexShardRoutingTable routingTable = builder.build();
+
+        Set<String> inSyncAllocationIds = activeIds.stream().map(AllocationId::getId).collect(Collectors.toSet());
+        ReplicationGroup replicationGroup = new ReplicationGroup(routingTable, inSyncAllocationIds, inSyncAllocationIds, 0);
+        List<ShardRouting> replicationTargets = replicationGroup.getReplicationTargets();
+        assertEquals(inSyncAllocationIds.size(), replicationTargets.size());
+        assertTrue(
+            replicationTargets.stream().map(sh -> sh.allocationId().getId()).collect(Collectors.toSet()).containsAll(inSyncAllocationIds)
+        );
+
+        Request request = new Request(shardId);
+        PlainActionFuture<TestPrimary.Result> listener = new PlainActionFuture<>();
+        Map<ShardRouting, Exception> simulatedFailures = new HashMap<>();
+        TestReplicaProxy replicasProxy = new TestReplicaProxy(simulatedFailures);
+        TestPrimary primary = new TestPrimary(primaryShard, () -> replicationGroup, threadPool);
+        // Generating data nodes in mixed mode wherein some of the allocated replicas
+        // are in docrep nodes whereas others are on remote enabled ones
+        Tuple<Integer, DiscoveryNodes> discoveryNodesDetails = buildMixedModeDiscoveryNodes(routingTable);
+        int docRepNodes = discoveryNodesDetails.v1();
+        final TestReplicationOperation op = new TestReplicationOperation(
+            request,
+            primary,
+            listener,
+            replicasProxy,
+            0,
+            new ReplicationModeAwareProxy<>(ReplicationMode.NO_REPLICATION, discoveryNodesDetails.v2(), replicasProxy, replicasProxy, false)
+        );
+        op.execute();
+        assertTrue("request was not processed on primary", request.processedOnPrimary.get());
+        // Only docrep nodes should have the request fanned out to
+        assertEquals(docRepNodes, request.processedOnReplicas.size());
+        assertEquals(0, replicasProxy.failedReplicas.size());
+        assertEquals(0, replicasProxy.markedAsStaleCopies.size());
+        assertTrue("post replication operations not run on primary", request.runPostReplicationActionsOnPrimary.get());
+        assertTrue("listener is not marked as done", listener.isDone());
+
+        ShardInfo shardInfo = listener.actionGet().getShardInfo();
+        // Listener should be invoked for initializing Ids, primary and the operations on docrep nodes
+        assertEquals(1 + docRepNodes + initializingIds.size(), shardInfo.getTotal());
+    }
+
     static String nodeIdFromAllocationId(final AllocationId allocationId) {
         return "n-" + allocationId.getId().substring(0, 8);
     }
@@ -816,6 +968,46 @@ private Set<ShardRouting> getExpectedReplicas(ShardId shardId, ClusterState stat
         return expectedReplicas;
     }
 
+    private DiscoveryNodes buildRemoteStoreEnabledDiscoveryNodes(IndexShardRoutingTable routingTable) {
+        DiscoveryNodes.Builder builder = DiscoveryNodes.builder();
+        for (ShardRouting shardRouting : routingTable) {
+            builder.add(IndexShardTestUtils.getFakeRemoteEnabledNode(shardRouting.currentNodeId()));
+        }
+        return builder.build();
+    }
+
+    private DiscoveryNodes buildDiscoveryNodes(IndexShardRoutingTable routingTable) {
+        DiscoveryNodes.Builder builder = DiscoveryNodes.builder();
+        for (ShardRouting shardRouting : routingTable) {
+            if (shardRouting.primary()) {
+                builder.add(IndexShardTestUtils.getFakeRemoteEnabledNode(shardRouting.currentNodeId()));
+            } else {
+                builder.add(IndexShardTestUtils.getFakeDiscoNode(shardRouting.currentNodeId()));
+            }
+        }
+        return builder.build();
+    }
+
+    private Tuple<Integer, DiscoveryNodes> buildMixedModeDiscoveryNodes(IndexShardRoutingTable routingTable) {
+        int docrepNodes = 0;
+        DiscoveryNodes.Builder builder = DiscoveryNodes.builder();
+        for (ShardRouting shardRouting : routingTable) {
+            if (shardRouting.primary()) {
+                builder.add(IndexShardTestUtils.getFakeRemoteEnabledNode(shardRouting.currentNodeId()));
+            } else {
+                // Only add docrep nodes for allocationIds that are active
+                // since the test cases creates replication group with active allocationIds only
+                if (shardRouting.active() && randomBoolean()) {
+                    builder.add(IndexShardTestUtils.getFakeDiscoNode(shardRouting.currentNodeId()));
+                    docrepNodes += 1;
+                } else {
+                    builder.add(IndexShardTestUtils.getFakeRemoteEnabledNode(shardRouting.currentNodeId()));
+                }
+            }
+        }
+        return new Tuple<>(docrepNodes, builder.build());
+    }
+
     public static class Request extends ReplicationRequest<Request> {
         public AtomicBoolean processedOnPrimary = new AtomicBoolean();
         public AtomicBoolean runPostReplicationActionsOnPrimary = new AtomicBoolean();
diff --git a/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationActionTests.java b/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationActionTests.java
index dad0fa0efd3ec..4a18778cc0b2b 100644
--- a/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationActionTests.java
+++ b/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationActionTests.java
@@ -78,6 +78,7 @@
 import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.index.IndexNotFoundException;
 import org.opensearch.index.IndexService;
+import org.opensearch.index.remote.RemoteStoreTestsHelper;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.shard.IndexShardClosedException;
 import org.opensearch.index.shard.IndexShardState;
@@ -1589,9 +1590,15 @@ private IndexService mockIndexService(final IndexMetadata indexMetadata, Cluster
 
     @SuppressWarnings("unchecked")
     private IndexShard mockIndexShard(ShardId shardId, ClusterService clusterService) {
+        return mockIndexShard(shardId, clusterService, false);
+    }
+
+    @SuppressWarnings("unchecked")
+    private IndexShard mockIndexShard(ShardId shardId, ClusterService clusterService, boolean remote) {
         final IndexShard indexShard = mock(IndexShard.class);
         when(indexShard.shardId()).thenReturn(shardId);
         when(indexShard.state()).thenReturn(IndexShardState.STARTED);
+        when(indexShard.indexSettings()).thenReturn(RemoteStoreTestsHelper.createIndexSettings(remote));
         doAnswer(invocation -> {
             ActionListener<Releasable> callback = (ActionListener<Releasable>) invocation.getArguments()[0];
             if (isPrimaryMode.get()) {
diff --git a/server/src/test/java/org/opensearch/cluster/metadata/MetadataCreateIndexServiceTests.java b/server/src/test/java/org/opensearch/cluster/metadata/MetadataCreateIndexServiceTests.java
index cf4de32890a2a..fa71b77648d35 100644
--- a/server/src/test/java/org/opensearch/cluster/metadata/MetadataCreateIndexServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/metadata/MetadataCreateIndexServiceTests.java
@@ -71,7 +71,8 @@
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.query.QueryShardContext;
-import org.opensearch.index.remote.RemoteStorePathType;
+import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
 import org.opensearch.index.translog.Translog;
 import org.opensearch.indices.IndexCreationException;
 import org.opensearch.indices.IndicesService;
@@ -1587,32 +1588,35 @@ public void testBuildIndexMetadata() {
      */
     public void testRemoteCustomData() {
         // Case 1 - Remote store is not enabled
-        IndexMetadata indexMetadata = testRemoteCustomData(false, randomFrom(RemoteStorePathType.values()));
+        IndexMetadata indexMetadata = testRemoteCustomData(false, randomFrom(PathType.values()));
         assertNull(indexMetadata.getCustomData(IndexMetadata.REMOTE_STORE_CUSTOM_KEY));
 
         // Case 2 - cluster.remote_store.index.path.prefix.optimised=fixed (default value)
-        indexMetadata = testRemoteCustomData(true, RemoteStorePathType.FIXED);
+        indexMetadata = testRemoteCustomData(true, PathType.FIXED);
+        Map<String, String> remoteCustomData = indexMetadata.getCustomData(IndexMetadata.REMOTE_STORE_CUSTOM_KEY);
+        validateRemoteCustomData(remoteCustomData, PathType.NAME, PathType.FIXED.name());
+        assertNull(remoteCustomData.get(PathHashAlgorithm.NAME));
+
+        // Case 3 - cluster.remote_store.index.path.prefix.optimised=hashed_prefix
+        indexMetadata = testRemoteCustomData(true, PathType.HASHED_PREFIX);
         validateRemoteCustomData(
             indexMetadata.getCustomData(IndexMetadata.REMOTE_STORE_CUSTOM_KEY),
-            RemoteStorePathType.NAME,
-            RemoteStorePathType.FIXED.toString()
+            PathType.NAME,
+            PathType.HASHED_PREFIX.toString()
         );
-
-        // Case 3 - cluster.remote_store.index.path.prefix.optimised=hashed_prefix
-        indexMetadata = testRemoteCustomData(true, RemoteStorePathType.HASHED_PREFIX);
         validateRemoteCustomData(
             indexMetadata.getCustomData(IndexMetadata.REMOTE_STORE_CUSTOM_KEY),
-            RemoteStorePathType.NAME,
-            RemoteStorePathType.HASHED_PREFIX.toString()
+            PathHashAlgorithm.NAME,
+            PathHashAlgorithm.FNV_1A.name()
         );
     }
 
-    private IndexMetadata testRemoteCustomData(boolean remoteStoreEnabled, RemoteStorePathType remoteStorePathType) {
+    private IndexMetadata testRemoteCustomData(boolean remoteStoreEnabled, PathType pathType) {
         Settings.Builder settingsBuilder = Settings.builder();
         if (remoteStoreEnabled) {
             settingsBuilder.put(NODE_ATTRIBUTES.getKey() + REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, "test");
         }
-        settingsBuilder.put(IndicesService.CLUSTER_REMOTE_STORE_PATH_PREFIX_TYPE_SETTING.getKey(), remoteStorePathType.toString());
+        settingsBuilder.put(IndicesService.CLUSTER_REMOTE_STORE_PATH_PREFIX_TYPE_SETTING.getKey(), pathType.toString());
         Settings settings = settingsBuilder.build();
 
         ClusterService clusterService = mock(ClusterService.class);
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/BalanceConfigurationTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/BalanceConfigurationTests.java
index 62dce9c4edeb5..11cbe89645657 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/BalanceConfigurationTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/BalanceConfigurationTests.java
@@ -72,6 +72,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
+import static org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_CREATION_DATE;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_REPLICAS;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SHARDS;
@@ -140,10 +141,14 @@ public void testIndexBalance() {
     }
 
     private Settings.Builder getSettingsBuilderForPrimaryBalance() {
-        return getSettingsBuilderForPrimaryBalance(true);
+        return getSettingsBuilderForPrimaryBalance(true, false);
     }
 
-    private Settings.Builder getSettingsBuilderForPrimaryBalance(boolean preferPrimaryBalance) {
+    private Settings.Builder getSettingsBuilderForPrimaryReBalance() {
+        return getSettingsBuilderForPrimaryBalance(true, true);
+    }
+
+    private Settings.Builder getSettingsBuilderForPrimaryBalance(boolean preferPrimaryBalance, boolean preferPrimaryRebalance) {
         final float indexBalance = 0.55f;
         final float shardBalance = 0.45f;
         final float balanceThreshold = 1.0f;
@@ -155,6 +160,7 @@ private Settings.Builder getSettingsBuilderForPrimaryBalance(boolean preferPrima
         );
         settings.put(BalancedShardsAllocator.INDEX_BALANCE_FACTOR_SETTING.getKey(), indexBalance);
         settings.put(BalancedShardsAllocator.PREFER_PRIMARY_SHARD_BALANCE.getKey(), preferPrimaryBalance);
+        settings.put(BalancedShardsAllocator.PREFER_PRIMARY_SHARD_REBALANCE.getKey(), preferPrimaryRebalance);
         settings.put(BalancedShardsAllocator.SHARD_BALANCE_FACTOR_SETTING.getKey(), shardBalance);
         settings.put(BalancedShardsAllocator.THRESHOLD_SETTING.getKey(), balanceThreshold);
         return settings;
@@ -201,7 +207,7 @@ public void testPrimaryBalanceWithoutPreferPrimaryBalanceSetting() {
         int balanceFailed = 0;
 
         AllocationService strategy = createAllocationService(
-            getSettingsBuilderForPrimaryBalance(false).build(),
+            getSettingsBuilderForPrimaryBalance(false, false).build(),
             new TestGatewayAllocator()
         );
         for (int i = 0; i < numberOfRuns; i++) {
@@ -244,6 +250,60 @@ public void testPrimaryBalanceWithPreferPrimaryBalanceSetting() {
         assertTrue(balanceFailed <= 1);
     }
 
+    /**
+     * This test verifies primary shard balance is attained  setting.
+     */
+    public void testPrimaryBalanceNotSolvedForNodeDropWithPreferPrimaryBalanceSetting() {
+        final int numberOfNodes = 4;
+        final int numberOfIndices = 4;
+        final int numberOfShards = 4;
+        final int numberOfReplicas = 1;
+        final int numberOfRuns = 5;
+        final float buffer = 0.10f;
+        int balanceFailed = 0;
+
+        AllocationService strategy = createAllocationService(getSettingsBuilderForPrimaryBalance().build(), new TestGatewayAllocator());
+        for (int i = 0; i < numberOfRuns; i++) {
+            ClusterState clusterState = initCluster(strategy, numberOfIndices, numberOfNodes, numberOfShards, numberOfReplicas);
+            clusterState = removeOneNode(clusterState, strategy);
+            logger.info(ShardAllocations.printShardDistribution(clusterState));
+            try {
+                verifyPrimaryBalance(clusterState, buffer);
+            } catch (AssertionError | Exception e) {
+                balanceFailed++;
+                logger.info("Unexpected assertion failure");
+            }
+        }
+        assertTrue(balanceFailed >= 4);
+    }
+
+    /**
+     * This test verifies primary shard balance is attained with PREFER_PRIMARY_SHARD_BALANCE setting.
+     */
+    public void testPrimaryBalanceSolvedWithPreferPrimaryRebalanceSetting() {
+        final int numberOfNodes = 4;
+        final int numberOfIndices = 4;
+        final int numberOfShards = 4;
+        final int numberOfReplicas = 1;
+        final int numberOfRuns = 5;
+        final float buffer = 0.10f;
+        int balanceFailed = 0;
+
+        AllocationService strategy = createAllocationService(getSettingsBuilderForPrimaryReBalance().build(), new TestGatewayAllocator());
+        for (int i = 0; i < numberOfRuns; i++) {
+            ClusterState clusterState = initCluster(strategy, numberOfIndices, numberOfNodes, numberOfShards, numberOfReplicas);
+            clusterState = removeOneNode(clusterState, strategy);
+            logger.info(ShardAllocations.printShardDistribution(clusterState));
+            try {
+                verifyPrimaryBalance(clusterState, buffer);
+            } catch (Exception e) {
+                balanceFailed++;
+                logger.info("Unexpected assertion failure");
+            }
+        }
+        assertTrue(balanceFailed <= 1);
+    }
+
     /**
      * This test verifies the allocation logic when nodes breach multiple constraints and ensure node breaching min
      * constraints chosen for allocation.
@@ -367,8 +427,7 @@ public void testPrimaryBalanceWithContrainstBreaching() {
      */
     public void testGlobalPrimaryBalance() throws Exception {
         AllocationService strategy = createAllocationService(getSettingsBuilderForPrimaryBalance().build(), new TestGatewayAllocator());
-        ClusterState clusterState = ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
-            .build();
+        ClusterState clusterState = ClusterState.builder(CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).build();
         clusterState = addNode(clusterState, strategy);
         clusterState = addNode(clusterState, strategy);
 
@@ -377,7 +436,30 @@ public void testGlobalPrimaryBalance() throws Exception {
         clusterState = addIndex(clusterState, strategy, "test-index3", 1, 1);
 
         logger.info(ShardAllocations.printShardDistribution(clusterState));
-        verifyPrimaryBalance(clusterState);
+        verifyPrimaryBalance(clusterState, 0.0f);
+    }
+
+    /**
+     * This test verifies global balance by creating indices iteratively and verify primary shards do not pile up on one
+     * @throws Exception generic exception
+     */
+    public void testGlobalPrimaryBalanceWithNodeDrops() throws Exception {
+        final float buffer = 0.10f;
+        AllocationService strategy = createAllocationService(getSettingsBuilderForPrimaryReBalance().build(), new TestGatewayAllocator());
+        ClusterState clusterState = ClusterState.builder(CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).build();
+        clusterState = addNodes(clusterState, strategy, 5);
+
+        clusterState = addIndices(clusterState, strategy, 5, 1, 8);
+
+        logger.info(ShardAllocations.printShardDistribution(clusterState));
+        verifyPrimaryBalance(clusterState, buffer);
+
+        clusterState = removeOneNode(clusterState, strategy);
+
+        clusterState = applyAllocationUntilNoChange(clusterState, strategy);
+
+        logger.info(ShardAllocations.printShardDistribution(clusterState));
+        verifyPrimaryBalance(clusterState, buffer);
     }
 
     /**
@@ -537,7 +619,7 @@ private void verifyPerIndexPrimaryBalance(ClusterState currentState) {
         }
     }
 
-    private void verifyPrimaryBalance(ClusterState clusterState) throws Exception {
+    private void verifySkewedPrimaryBalance(ClusterState clusterState, int delta) throws Exception {
         assertBusy(() -> {
             RoutingNodes nodes = clusterState.getRoutingNodes();
             int totalPrimaryShards = 0;
@@ -545,13 +627,36 @@ private void verifyPrimaryBalance(ClusterState clusterState) throws Exception {
                 totalPrimaryShards += index.primaryShardsActive();
             }
             final int avgPrimaryShardsPerNode = (int) Math.ceil(totalPrimaryShards * 1f / clusterState.getRoutingNodes().size());
+            int maxPrimaryShardOnNode = Integer.MIN_VALUE;
+            int minPrimaryShardOnNode = Integer.MAX_VALUE;
             for (RoutingNode node : nodes) {
                 final int primaryCount = node.shardsWithState(STARTED)
                     .stream()
                     .filter(ShardRouting::primary)
                     .collect(Collectors.toList())
                     .size();
-                assertTrue(primaryCount <= avgPrimaryShardsPerNode);
+                maxPrimaryShardOnNode = Math.max(maxPrimaryShardOnNode, primaryCount);
+                minPrimaryShardOnNode = Math.min(minPrimaryShardOnNode, primaryCount);
+            }
+            assertTrue(maxPrimaryShardOnNode - minPrimaryShardOnNode < delta);
+        }, 60, TimeUnit.SECONDS);
+    }
+
+    private void verifyPrimaryBalance(ClusterState clusterState, float buffer) throws Exception {
+        assertBusy(() -> {
+            RoutingNodes nodes = clusterState.getRoutingNodes();
+            int totalPrimaryShards = 0;
+            for (final IndexRoutingTable index : clusterState.getRoutingTable().indicesRouting().values()) {
+                totalPrimaryShards += index.primaryShardsActive();
+            }
+            final int avgPrimaryShardsPerNode = (int) Math.ceil(totalPrimaryShards * 1f / clusterState.getRoutingNodes().size());
+            for (RoutingNode node : nodes) {
+                final int primaryCount = node.shardsWithState(STARTED)
+                    .stream()
+                    .filter(ShardRouting::primary)
+                    .collect(Collectors.toList())
+                    .size();
+                assertTrue(primaryCount <= (avgPrimaryShardsPerNode * (1 + buffer)));
             }
         }, 60, TimeUnit.SECONDS);
     }
@@ -567,8 +672,8 @@ public void testShardBalance() {
             ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE_SETTING.getKey(),
             ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()
         );
-        settings.put(BalancedShardsAllocator.INDEX_BALANCE_FACTOR_SETTING.getKey(), indexBalance);
         settings.put(BalancedShardsAllocator.SHARD_BALANCE_FACTOR_SETTING.getKey(), shardBalance);
+        settings.put(BalancedShardsAllocator.INDEX_BALANCE_FACTOR_SETTING.getKey(), indexBalance);
         settings.put(BalancedShardsAllocator.THRESHOLD_SETTING.getKey(), balanceThreshold);
 
         AllocationService strategy = createAllocationService(settings.build(), new TestGatewayAllocator());
@@ -634,6 +739,34 @@ private ClusterState addIndex(
         return applyAllocationUntilNoChange(clusterState, strategy);
     }
 
+    private ClusterState addIndices(
+        ClusterState clusterState,
+        AllocationService strategy,
+        int numberOfShards,
+        int numberOfReplicas,
+        int numberOfIndices
+    ) {
+        Metadata.Builder metadataBuilder = Metadata.builder(clusterState.getMetadata());
+        RoutingTable.Builder routingTableBuilder = RoutingTable.builder(clusterState.routingTable());
+
+        for (int i = 0; i < numberOfIndices; i++) {
+            IndexMetadata.Builder index = IndexMetadata.builder("test" + i)
+                .settings(settings(Version.CURRENT))
+                .numberOfShards(numberOfShards)
+                .numberOfReplicas(numberOfReplicas);
+
+            metadataBuilder = metadataBuilder.put(index);
+            routingTableBuilder.addAsNew(index.build());
+        }
+
+        clusterState = ClusterState.builder(clusterState)
+            .metadata(metadataBuilder.build())
+            .routingTable(routingTableBuilder.build())
+            .build();
+        clusterState = strategy.reroute(clusterState, "indices-created");
+        return applyAllocationUntilNoChange(clusterState, strategy);
+    }
+
     private ClusterState initCluster(
         AllocationService strategy,
         int numberOfIndices,
@@ -664,7 +797,7 @@ private ClusterState initCluster(
         for (int i = 0; i < numberOfNodes; i++) {
             nodes.add(newNode("node" + i));
         }
-        ClusterState clusterState = ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+        ClusterState clusterState = ClusterState.builder(CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
             .nodes(nodes)
             .metadata(metadata)
             .routingTable(initialRoutingTable)
@@ -673,6 +806,17 @@ private ClusterState initCluster(
         return applyAllocationUntilNoChange(clusterState, strategy);
     }
 
+    private ClusterState addNodes(ClusterState clusterState, AllocationService strategy, int numberOfNodes) {
+        logger.info("now, start [{}] more node, check that rebalancing will happen because we set it to always", numberOfNodes);
+        DiscoveryNodes.Builder nodes = DiscoveryNodes.builder(clusterState.nodes());
+        for (int i = 0; i < numberOfNodes; i++) {
+            nodes.add(newNode("node" + (clusterState.nodes().getSize() + i)));
+        }
+        clusterState = ClusterState.builder(clusterState).nodes(nodes.build()).build();
+        clusterState = strategy.reroute(clusterState, "reroute");
+        return applyStartedShardsUntilNoChange(clusterState, strategy);
+    }
+
     private ClusterState addNode(ClusterState clusterState, AllocationService strategy) {
         logger.info("now, start 1 more node, check that rebalancing will happen because we set it to always");
         clusterState = ClusterState.builder(clusterState)
@@ -918,7 +1062,7 @@ public ShardAllocationDecision decideShardAllocation(ShardRouting shard, Routing
             nodes.add(node);
         }
 
-        ClusterState clusterState = ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+        ClusterState clusterState = ClusterState.builder(CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
             .nodes(nodes)
             .metadata(metadata)
             .routingTable(routingTable)
diff --git a/server/src/test/java/org/opensearch/cluster/structure/RoutingIteratorTests.java b/server/src/test/java/org/opensearch/cluster/structure/RoutingIteratorTests.java
index 86adfc1279d9a..190ad3283dcfc 100644
--- a/server/src/test/java/org/opensearch/cluster/structure/RoutingIteratorTests.java
+++ b/server/src/test/java/org/opensearch/cluster/structure/RoutingIteratorTests.java
@@ -700,9 +700,18 @@ public void testWeightedRoutingWithDifferentWeights() {
                 .shard(0)
                 .activeInitializingShardsWeightedIt(weightedRouting, clusterState.nodes(), 1, false, null);
             assertEquals(1, shardIterator.size());
-            shardRouting = shardIterator.nextOrNull();
-            assertNotNull(shardRouting);
-            assertFalse(Arrays.asList("node2", "node1").contains(shardRouting.currentNodeId()));
+            assertEquals("node3", shardIterator.nextOrNull().currentNodeId());
+
+            weights = Map.of("zone1", -1.0, "zone2", 0.0, "zone3", 1.0);
+            weightedRouting = new WeightedRouting("zone", weights);
+            shardIterator = clusterState.routingTable()
+                .index("test")
+                .shard(0)
+                .activeInitializingShardsWeightedIt(weightedRouting, clusterState.nodes(), 1, true, null);
+            assertEquals(3, shardIterator.size());
+            assertEquals("node3", shardIterator.nextOrNull().currentNodeId());
+            assertNotEquals("node3", shardIterator.nextOrNull().currentNodeId());
+            assertNotEquals("node3", shardIterator.nextOrNull().currentNodeId());
 
             weights = Map.of("zone1", 3.0, "zone2", 2.0, "zone3", 0.0);
             weightedRouting = new WeightedRouting("zone", weights);
@@ -711,8 +720,138 @@ public void testWeightedRoutingWithDifferentWeights() {
                 .shard(0)
                 .activeInitializingShardsWeightedIt(weightedRouting, clusterState.nodes(), 1, true, null);
             assertEquals(3, shardIterator.size());
-            shardRouting = shardIterator.nextOrNull();
-            assertNotNull(shardRouting);
+            assertNotEquals("node3", shardIterator.nextOrNull().currentNodeId());
+            assertNotEquals("node3", shardIterator.nextOrNull().currentNodeId());
+            assertEquals("node3", shardIterator.nextOrNull().currentNodeId());
+        } finally {
+            terminate(threadPool);
+        }
+    }
+
+    public void testWeightedRoutingWithInitializingShards() {
+        TestThreadPool threadPool = null;
+        try {
+            Settings.Builder settings = Settings.builder()
+                .put("cluster.routing.allocation.node_concurrent_recoveries", 10)
+                .put("cluster.routing.allocation.awareness.attributes", "zone");
+            AllocationService strategy = createAllocationService(settings.build());
+
+            Metadata metadata = Metadata.builder()
+                .put(IndexMetadata.builder("test").settings(settings(Version.CURRENT)).numberOfShards(1).numberOfReplicas(2))
+                .build();
+
+            RoutingTable routingTable = RoutingTable.builder().addAsNew(metadata.index("test")).build();
+
+            ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+                .metadata(metadata)
+                .routingTable(routingTable)
+                .build();
+
+            threadPool = new TestThreadPool("testThatOnlyNodesSupport");
+            ClusterService clusterService = ClusterServiceUtils.createClusterService(threadPool);
+
+            Map<String, String> node1Attributes = new HashMap<>();
+            node1Attributes.put("zone", "zone1");
+            Map<String, String> node2Attributes = new HashMap<>();
+            node2Attributes.put("zone", "zone2");
+            Map<String, String> node3Attributes = new HashMap<>();
+            node3Attributes.put("zone", "zone3");
+
+            DiscoveryNodes nodes = DiscoveryNodes.builder()
+                .add(newNode("node1", unmodifiableMap(node1Attributes)))
+                .add(newNode("node2", unmodifiableMap(node2Attributes)))
+                .add(newNode("node3", unmodifiableMap(node3Attributes)))
+                .localNodeId("node1")
+                .build();
+            clusterState = ClusterState.builder(clusterState).nodes(nodes).build();
+            clusterState = strategy.reroute(clusterState, "reroute");
+
+            // Making the first shard as active
+            clusterState = startInitializingShardsAndReroute(strategy, clusterState);
+            // Making the second shard as active
+            clusterState = startRandomInitializingShard(clusterState, strategy);
+
+            String[] startedNodes = new String[2];
+            String[] startedZones = new String[2];
+            String initializingNode = null;
+            String initializingZone = null;
+            int i = 0;
+            for (ShardRouting shard : clusterState.routingTable().allShards()) {
+                if (shard.initializing()) {
+                    initializingNode = shard.currentNodeId();
+                    initializingZone = nodes.resolveNode(shard.currentNodeId()).getAttributes().get("zone");
+
+                } else {
+                    startedNodes[i] = shard.currentNodeId();
+                    startedZones[i++] = nodes.resolveNode(shard.currentNodeId()).getAttributes().get("zone");
+                }
+            }
+
+            Map<String, Double> weights = Map.of(startedZones[0], 1.0, initializingZone, 1.0, startedZones[1], 0.0);
+            WeightedRouting weightedRouting = new WeightedRouting("zone", weights);
+
+            // With fail open enabled set to false, we expect 2 shard routing, first one started, followed by initializing
+            ShardIterator shardIterator = clusterState.routingTable()
+                .index("test")
+                .shard(0)
+                .activeInitializingShardsWeightedIt(weightedRouting, clusterState.nodes(), 1, false, null);
+
+            assertEquals(2, shardIterator.size());
+            assertEquals(startedNodes[0], shardIterator.nextOrNull().currentNodeId());
+            assertEquals(initializingNode, shardIterator.nextOrNull().currentNodeId());
+
+            // With fail open enabled set to true, we expect 3 shard routing, first one started, followed by initializing, third one started
+            // with zero weight
+            shardIterator = clusterState.routingTable()
+                .index("test")
+                .shard(0)
+                .activeInitializingShardsWeightedIt(weightedRouting, clusterState.nodes(), 1, true, null);
+
+            assertEquals(3, shardIterator.size());
+            assertEquals(startedNodes[0], shardIterator.nextOrNull().currentNodeId());
+            assertEquals(initializingNode, shardIterator.nextOrNull().currentNodeId());
+            assertEquals(startedNodes[1], shardIterator.nextOrNull().currentNodeId());
+
+            weights = Map.of(initializingZone, 1.0, startedZones[0], 0.0, startedZones[1], 0.0);
+            weightedRouting = new WeightedRouting("zone", weights);
+
+            // only initializing shard has weight with fail open true
+            shardIterator = clusterState.routingTable()
+                .index("test")
+                .shard(0)
+                .activeInitializingShardsWeightedIt(weightedRouting, clusterState.nodes(), 1, false, null);
+            assertEquals(1, shardIterator.size());
+            assertEquals(initializingNode, shardIterator.nextOrNull().currentNodeId());
+
+            // only initializing shard has weight with fail open false
+            shardIterator = clusterState.routingTable()
+                .index("test")
+                .shard(0)
+                .activeInitializingShardsWeightedIt(weightedRouting, clusterState.nodes(), 1, true, null);
+            assertEquals(3, shardIterator.size());
+            assertEquals(initializingNode, shardIterator.nextOrNull().currentNodeId());
+            assertNotEquals(initializingNode, shardIterator.nextOrNull().currentNodeId());
+            assertNotEquals(initializingNode, shardIterator.nextOrNull().currentNodeId());
+
+            weights = Map.of(initializingZone, 0.0, startedZones[0], 1.0, startedZones[1], 0.0);
+            weightedRouting = new WeightedRouting("zone", weights);
+
+            shardIterator = clusterState.routingTable()
+                .index("test")
+                .shard(0)
+                .activeInitializingShardsWeightedIt(weightedRouting, clusterState.nodes(), 1, false, null);
+            assertEquals(1, shardIterator.size());
+            assertEquals(startedNodes[0], shardIterator.nextOrNull().currentNodeId());
+
+            shardIterator = clusterState.routingTable()
+                .index("test")
+                .shard(0)
+                .activeInitializingShardsWeightedIt(weightedRouting, clusterState.nodes(), 1, true, null);
+            assertEquals(3, shardIterator.size());
+            assertEquals(startedNodes[0], shardIterator.nextOrNull().currentNodeId());
+            assertEquals(startedNodes[1], shardIterator.nextOrNull().currentNodeId());
+            assertEquals(initializingNode, shardIterator.nextOrNull().currentNodeId());
+
         } finally {
             terminate(threadPool);
         }
diff --git a/server/src/test/java/org/opensearch/common/blobstore/AsyncMultiStreamEncryptedBlobContainerTests.java b/server/src/test/java/org/opensearch/common/blobstore/AsyncMultiStreamEncryptedBlobContainerTests.java
index 1780819390052..aee4ae40d16a5 100644
--- a/server/src/test/java/org/opensearch/common/blobstore/AsyncMultiStreamEncryptedBlobContainerTests.java
+++ b/server/src/test/java/org/opensearch/common/blobstore/AsyncMultiStreamEncryptedBlobContainerTests.java
@@ -57,7 +57,7 @@ public void testReadBlobAsync() throws Exception {
         final ListenerTestUtils.CountingCompletionListener<ReadContext> completionListener =
             new ListenerTestUtils.CountingCompletionListener<>();
         final CompletableFuture<InputStreamContainer> streamContainerFuture = CompletableFuture.completedFuture(inputStreamContainer);
-        final ReadContext readContext = new ReadContext(size, List.of(() -> streamContainerFuture), null);
+        final ReadContext readContext = new ReadContext.Builder(size, List.of(() -> streamContainerFuture)).build();
 
         Mockito.doAnswer(invocation -> {
             ActionListener<ReadContext> readContextActionListener = invocation.getArgument(1);
@@ -103,7 +103,7 @@ public void testReadBlobAsyncException() throws Exception {
         final ListenerTestUtils.CountingCompletionListener<ReadContext> completionListener =
             new ListenerTestUtils.CountingCompletionListener<>();
         final CompletableFuture<InputStreamContainer> streamContainerFuture = CompletableFuture.completedFuture(inputStreamContainer);
-        final ReadContext readContext = new ReadContext(size, List.of(() -> streamContainerFuture), null);
+        final ReadContext readContext = new ReadContext.Builder(size, List.of(() -> streamContainerFuture)).build();
 
         Mockito.doAnswer(invocation -> {
             ActionListener<ReadContext> readContextActionListener = invocation.getArgument(1);
diff --git a/server/src/test/java/org/opensearch/common/blobstore/stream/read/listener/ReadContextListenerTests.java b/server/src/test/java/org/opensearch/common/blobstore/stream/read/listener/ReadContextListenerTests.java
index 0163c2275e7f4..c47874f3ba294 100644
--- a/server/src/test/java/org/opensearch/common/blobstore/stream/read/listener/ReadContextListenerTests.java
+++ b/server/src/test/java/org/opensearch/common/blobstore/stream/read/listener/ReadContextListenerTests.java
@@ -78,7 +78,7 @@ public void testReadContextListener() throws InterruptedException, IOException {
             UnaryOperator.identity(),
             MAX_CONCURRENT_STREAMS
         );
-        ReadContext readContext = new ReadContext((long) PART_SIZE * NUMBER_OF_PARTS, blobPartStreams, null);
+        ReadContext readContext = new ReadContext.Builder((long) PART_SIZE * NUMBER_OF_PARTS, blobPartStreams).build();
         readContextListener.onResponse(readContext);
 
         countDownLatch.await();
@@ -125,7 +125,7 @@ public int available() {
                 threadPool.generic()
             )
         );
-        ReadContext readContext = new ReadContext((long) (PART_SIZE + 1) * NUMBER_OF_PARTS, blobPartStreams, null);
+        ReadContext readContext = new ReadContext.Builder((long) (PART_SIZE + 1) * NUMBER_OF_PARTS, blobPartStreams).build();
         readContextListener.onResponse(readContext);
 
         countDownLatch.await();
@@ -178,7 +178,7 @@ public int read(byte[] b) throws IOException {
                 threadPool.generic()
             )
         );
-        ReadContext readContext = new ReadContext((long) (PART_SIZE + 1) * NUMBER_OF_PARTS + 1, blobPartStreams, null);
+        ReadContext readContext = new ReadContext.Builder((long) (PART_SIZE + 1) * NUMBER_OF_PARTS + 1, blobPartStreams).build();
         readContextListener.onResponse(readContext);
 
         countDownLatch.await();
@@ -203,7 +203,7 @@ public void testWriteToTempFile_alreadyExists_replacesFile() throws Exception {
             UnaryOperator.identity(),
             MAX_CONCURRENT_STREAMS
         );
-        ReadContext readContext = new ReadContext((long) (PART_SIZE + 1) * NUMBER_OF_PARTS, blobPartStreams, null);
+        ReadContext readContext = new ReadContext.Builder((long) (PART_SIZE + 1) * NUMBER_OF_PARTS, blobPartStreams).build();
         readContextListener.onResponse(readContext);
 
         countDownLatch.await();
diff --git a/server/src/test/java/org/opensearch/common/hashing/FNV1aTests.java b/server/src/test/java/org/opensearch/common/hashing/FNV1aTests.java
new file mode 100644
index 0000000000000..8d41211f10134
--- /dev/null
+++ b/server/src/test/java/org/opensearch/common/hashing/FNV1aTests.java
@@ -0,0 +1,48 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.hashing;
+
+import org.opensearch.common.hash.FNV1a;
+import org.opensearch.test.OpenSearchTestCase;
+
+public class FNV1aTests extends OpenSearchTestCase {
+
+    public void testHash32WithKnownValues() {
+        assertEquals(-1114940029532279145L, FNV1a.hash32("1sH3kJO5TyeskNekv2YTbA0segmentsdata"));
+        assertEquals(-5313793557685118702L, FNV1a.hash32("1sH3kJO5TyeskNekv2YTbA0segmentsmetadata"));
+        assertEquals(-4776941653547780179L, FNV1a.hash32("1sH3kJO5TyeskNekv2YTbA0translogdata"));
+        assertEquals(7773876801598345624L, FNV1a.hash32("1sH3kJO5TyeskNekv2YTbA0translogmetadata"));
+        assertEquals(3174284101845744576L, FNV1a.hash32("1sH3kJO5TyeskNekv2YTbA0segmentslock_files"));
+        assertEquals(875447599647258598L, FNV1a.hash32("hell"));
+        assertEquals(1460560186469985451L, FNV1a.hash32("hello"));
+        assertEquals(-4959477702557352110L, FNV1a.hash32("hello w"));
+        assertEquals(-777130915070571257L, FNV1a.hash32("hello wo"));
+        assertEquals(-7887204531510399185L, FNV1a.hash32("hello wor"));
+        assertEquals(-782004333700192647L, FNV1a.hash32("hello worl"));
+        assertEquals(2168278929747165095L, FNV1a.hash32("hello world"));
+        assertEquals(2655121221658607504L, FNV1a.hash32("The quick brown fox jumps over the lazy dog"));
+    }
+
+    public void testHash64WithKnownValues() {
+        assertEquals(-8975854101357662761L, FNV1a.hash64("1sH3kJO5TyeskNekv2YTbA0segmentsdata"));
+        assertEquals(-4380291990281602606L, FNV1a.hash64("1sH3kJO5TyeskNekv2YTbA0segmentsmetadata"));
+        assertEquals(-4532418109365814419L, FNV1a.hash64("1sH3kJO5TyeskNekv2YTbA0translogdata"));
+        assertEquals(41331743556869080L, FNV1a.hash64("1sH3kJO5TyeskNekv2YTbA0translogmetadata"));
+        assertEquals(6170437157231275808L, FNV1a.hash64("1sH3kJO5TyeskNekv2YTbA0segmentslock_files"));
+        assertEquals(763638091547294502L, FNV1a.hash64("hell"));
+        assertEquals(-6615550055289275125L, FNV1a.hash64("hello"));
+        assertEquals(-8428874042178798254L, FNV1a.hash64("hello w"));
+        assertEquals(-6323438951910650201L, FNV1a.hash64("hello wo"));
+        assertEquals(7042426588567368687L, FNV1a.hash64("hello wor"));
+        assertEquals(7273314957493782425L, FNV1a.hash64("hello worl"));
+        assertEquals(8618312879776256743L, FNV1a.hash64("hello world"));
+        assertEquals(-866459186506731248L, FNV1a.hash64("The quick brown fox jumps over the lazy dog"));
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/IndexModuleTests.java b/server/src/test/java/org/opensearch/index/IndexModuleTests.java
index 82d7ab06f126b..4ce4936c047d9 100644
--- a/server/src/test/java/org/opensearch/index/IndexModuleTests.java
+++ b/server/src/test/java/org/opensearch/index/IndexModuleTests.java
@@ -237,7 +237,8 @@ private IndexService newIndexService(IndexModule module) throws IOException {
                     repositoriesServiceReference::get,
                     threadPool,
                     indexSettings.getRemoteStoreTranslogRepository(),
-                    new RemoteTranslogTransferTracker(shardRouting.shardId(), 10)
+                    new RemoteTranslogTransferTracker(shardRouting.shardId(), 10),
+                    DefaultRemoteStoreSettings.INSTANCE
                 );
             }
             return new InternalTranslogFactory();
diff --git a/server/src/test/java/org/opensearch/index/IndexSettingsTests.java b/server/src/test/java/org/opensearch/index/IndexSettingsTests.java
index e4ce879a5ec5e..474ec73d5fe61 100644
--- a/server/src/test/java/org/opensearch/index/IndexSettingsTests.java
+++ b/server/src/test/java/org/opensearch/index/IndexSettingsTests.java
@@ -1053,4 +1053,15 @@ public void testDefaultSearchPipeline() throws Exception {
         settings.updateIndexMetadata(metadata);
         assertEquals("foo", settings.getDefaultSearchPipeline());
     }
+
+    public void testIsOnRemoteNode() {
+        Version version = VersionUtils.getPreviousVersion();
+        Settings theSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, version)
+            .put(IndexMetadata.SETTING_INDEX_UUID, "0xdeadbeef")
+            .build();
+        Settings nodeSettings = Settings.builder().put("node.attr.remote_store.translog.repository", "my-repo-1").build();
+        IndexSettings settings = newIndexSettings(newIndexMeta("index", theSettings), nodeSettings);
+        assertTrue("Index should be on remote node", settings.isAssignedOnRemoteNode());
+    }
 }
diff --git a/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldMapperTests.java
new file mode 100644
index 0000000000000..65dd3b6447663
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldMapperTests.java
@@ -0,0 +1,114 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.index.IndexableField;
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.common.CheckedConsumer;
+import org.opensearch.common.compress.CompressedXContent;
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.IndexService;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.test.InternalSettingsPlugin;
+import org.opensearch.test.OpenSearchSingleNodeTestCase;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.util.Collection;
+
+import static org.hamcrest.Matchers.containsString;
+
+public class ConstantKeywordFieldMapperTests extends OpenSearchSingleNodeTestCase {
+
+    private IndexService indexService;
+    private DocumentMapperParser parser;
+
+    @Override
+    protected Collection<Class<? extends Plugin>> getPlugins() {
+        return pluginList(InternalSettingsPlugin.class);
+    }
+
+    @Before
+    public void setup() {
+        indexService = createIndex("test");
+        parser = indexService.mapperService().documentMapperParser();
+    }
+
+    public void testDefaultDisabledIndexMapper() throws Exception {
+
+        XContentBuilder mapping = XContentFactory.jsonBuilder()
+            .startObject()
+            .startObject("type")
+            .startObject("properties")
+            .startObject("field")
+            .field("type", "constant_keyword")
+            .field("value", "default_value")
+            .endObject()
+            .startObject("field2")
+            .field("type", "keyword")
+            .endObject();
+        mapping = mapping.endObject().endObject().endObject();
+        DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping.toString()));
+
+        MapperParsingException e = expectThrows(MapperParsingException.class, () -> mapper.parse(source(b -> {
+            b.field("field", "sdf");
+            b.field("field2", "szdfvsddf");
+        })));
+        assertThat(
+            e.getMessage(),
+            containsString(
+                "failed to parse field [field] of type [constant_keyword] in document with id '1'. Preview of field's value: 'sdf'"
+            )
+        );
+
+        final ParsedDocument doc = mapper.parse(source(b -> {
+            b.field("field", "default_value");
+            b.field("field2", "field_2_value");
+        }));
+
+        final IndexableField field = doc.rootDoc().getField("field");
+
+        // constantKeywordField should not be stored
+        assertNull(field);
+    }
+
+    public void testMissingDefaultIndexMapper() throws Exception {
+
+        final XContentBuilder mapping = XContentFactory.jsonBuilder()
+            .startObject()
+            .startObject("type")
+            .startObject("properties")
+            .startObject("field")
+            .field("type", "constant_keyword")
+            .endObject()
+            .startObject("field2")
+            .field("type", "keyword")
+            .endObject()
+            .endObject()
+            .endObject()
+            .endObject();
+
+        OpenSearchParseException e = expectThrows(
+            OpenSearchParseException.class,
+            () -> parser.parse("type", new CompressedXContent(mapping.toString()))
+        );
+        assertThat(e.getMessage(), containsString("Field [field] is missing required parameter [value]"));
+    }
+
+    private final SourceToParse source(CheckedConsumer<XContentBuilder, IOException> build) throws IOException {
+        XContentBuilder builder = JsonXContent.contentBuilder().startObject();
+        build.accept(builder);
+        builder.endObject();
+        return new SourceToParse("test", "1", BytesReference.bytes(builder), MediaTypeRegistry.JSON);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldTypeTests.java
new file mode 100644
index 0000000000000..235811539a299
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldTypeTests.java
@@ -0,0 +1,93 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.search.MatchAllDocsQuery;
+import org.apache.lucene.search.MatchNoDocsQuery;
+import org.opensearch.Version;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.regex.Regex;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.query.QueryShardContext;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+
+public class ConstantKeywordFieldTypeTests extends FieldTypeTestCase {
+
+    final ConstantKeywordFieldMapper.ConstantKeywordFieldType ft = new ConstantKeywordFieldMapper.ConstantKeywordFieldType(
+        "field",
+        "default"
+    );
+
+    public void testTermQuery() {
+        assertEquals(new MatchAllDocsQuery(), ft.termQuery("default", createContext()));
+        assertEquals(new MatchNoDocsQuery(), ft.termQuery("not_default", createContext()));
+    }
+
+    public void testTermsQuery() {
+        assertEquals(new MatchAllDocsQuery(), ft.termsQuery(Arrays.asList("default", "not_default"), createContext()));
+        assertEquals(new MatchNoDocsQuery(), ft.termsQuery(Arrays.asList("no_default", "not_default"), createContext()));
+        assertEquals(new MatchNoDocsQuery(), ft.termsQuery(List.of(), createContext()));
+    }
+
+    public void testInsensitiveTermQuery() {
+        assertEquals(new MatchAllDocsQuery(), ft.termQueryCaseInsensitive("defaUlt", createContext()));
+        assertEquals(new MatchNoDocsQuery(), ft.termQueryCaseInsensitive("not_defaUlt", createContext()));
+    }
+
+    public void testPrefixQuery() {
+        assertEquals(new MatchAllDocsQuery(), ft.prefixQuery("defau", null, createContext()));
+        assertEquals(new MatchNoDocsQuery(), ft.prefixQuery("not_default", null, createContext()));
+    }
+
+    public void testWildcardQuery() {
+        assertEquals(new MatchAllDocsQuery(), ft.wildcardQuery("defa*lt", null, createContext()));
+        assertEquals(new MatchNoDocsQuery(), ft.wildcardQuery("no_defa*lt", null, createContext()));
+        assertEquals(new MatchAllDocsQuery(), ft.wildcardQuery("defa*", null, createContext()));
+        assertEquals(new MatchAllDocsQuery(), ft.wildcardQuery("*ult", null, createContext()));
+
+    }
+
+    public void testExistsQuery() {
+        assertEquals(new MatchAllDocsQuery(), ft.existsQuery(createContext()));
+    }
+
+    private QueryShardContext createContext() {
+        IndexMetadata indexMetadata = IndexMetadata.builder("index")
+            .settings(Settings.builder().put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT))
+            .numberOfShards(1)
+            .numberOfReplicas(0)
+            .build();
+        IndexSettings indexSettings = new IndexSettings(indexMetadata, Settings.EMPTY);
+
+        Predicate<String> indexNameMatcher = pattern -> Regex.simpleMatch(pattern, "index");
+        return new QueryShardContext(
+            0,
+            indexSettings,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            xContentRegistry(),
+            writableRegistry(),
+            null,
+            null,
+            System::currentTimeMillis,
+            null,
+            indexNameMatcher,
+            () -> true,
+            null
+        );
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/mapper/DerivedFieldMapperQueryTests.java b/server/src/test/java/org/opensearch/index/mapper/DerivedFieldMapperQueryTests.java
new file mode 100644
index 0000000000000..bd6d7b88ade28
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/mapper/DerivedFieldMapperQueryTests.java
@@ -0,0 +1,279 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.document.TextField;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.TopDocs;
+import org.apache.lucene.store.Directory;
+import org.opensearch.common.lucene.Lucene;
+import org.opensearch.core.index.Index;
+import org.opensearch.index.query.QueryBuilders;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.script.DerivedFieldScript;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.mockito.Mockito;
+
+import static org.mockito.Mockito.when;
+
+public class DerivedFieldMapperQueryTests extends MapperServiceTestCase {
+
+    // First element is the document ingested, other elements corresponds to value returned against a given derived field script
+    // Raw Message, Request Succeeded (boolean), Timestamp (long), Client IP, Method, Request Size (double), Duration (long)
+    private static final Object[][] raw_requests = new Object[][] {
+        {
+            "40.135.0.0 GET /images/hm_bg.jpg?size=1.5KB HTTP/1.0 200 2024-03-20T08:30:45 1500",
+            true,
+            1710923445000L,
+            "40.135.0.0",
+            "GET",
+            1.5,
+            1500L },
+        {
+            "232.0.0.0 GET /images/hm_bg.jpg?size=2.3KB HTTP/1.0 400 2024-03-20T09:15:20 2300",
+            false,
+            1710926120000L,
+            "232.0.0.0",
+            "GET",
+            2.3,
+            2300L },
+        {
+            "26.1.0.0 DELETE /images/hm_bg.jpg?size=3.7KB HTTP/1.0 200 2024-03-20T10:05:55 3700",
+            true,
+            1710929155000L,
+            "26.1.0.0",
+            "DELETE",
+            3.7,
+            3700L },
+        {
+            "247.37.0.0 GET /french/splash_inet.html?size=4.1KB HTTP/1.0 400 2024-03-20T11:20:10 4100",
+            false,
+            1710933610000L,
+            "247.37.0.0",
+            "GET",
+            4.1,
+            4100L },
+        {
+            "247.37.0.0 DELETE /french/splash_inet.html?size=5.8KB HTTP/1.0 400 2024-03-20T12:45:30 5800",
+            false,
+            1710938730000L,
+            "247.37.0.0",
+            "DELETE",
+            5.8,
+            5800L },
+        {
+            "10.20.30.40 GET /path/to/resource?size=6.3KB HTTP/1.0 200 2024-03-20T13:10:15 6300",
+            true,
+            1710940215000L,
+            "10.20.30.40",
+            "GET",
+            6.3,
+            6300L },
+        {
+            "50.60.70.80 GET /path/to/resource?size=7.2KB HTTP/1.0 404 2024-03-20T14:20:50 7200",
+            false,
+            1710944450000L,
+            "50.60.70.80",
+            "GET",
+            7.2,
+            7200L },
+        {
+            "127.0.0.1 PUT /path/to/resource?size=8.9KB HTTP/1.0 500 2024-03-20T15:30:25 8900",
+            false,
+            1710948625000L,
+            "127.0.0.1",
+            "PUT",
+            8.9,
+            8900L },
+        {
+            "127.0.0.1 GET /path/to/resource?size=9.4KB HTTP/1.0 200 2024-03-20T16:40:15 9400",
+            true,
+            1710952815000L,
+            "127.0.0.1",
+            "GET",
+            9.4,
+            9400L },
+        {
+            "192.168.1.1 GET /path/to/resource?size=10.7KB HTTP/1.0 400 2024-03-20T17:50:40 10700",
+            false,
+            1710957040000L,
+            "192.168.1.1",
+            "GET",
+            10.7,
+            10700L } };
+
+    public void testAllPossibleQueriesOnDerivedFields() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("properties");
+            {
+                b.startObject("raw_message");
+                {
+                    b.field("type", "text");
+                }
+                b.endObject();
+            }
+            b.endObject();
+            b.startObject("derived");
+            {
+                b.startObject("request_succeeded");
+                {
+                    b.field("type", "boolean");
+                    b.field("script", "");
+                }
+                b.endObject();
+                b.startObject("@timestamp");
+                {
+                    b.field("type", "date");
+                    b.field("script", "");
+                }
+                b.endObject();
+                b.startObject("client_ip");
+                {
+                    b.field("type", "ip");
+                    b.field("script", "");
+                }
+                b.endObject();
+                b.startObject("method");
+                {
+                    b.field("type", "keyword");
+                    b.field("script", "");
+                }
+                b.endObject();
+                b.startObject("request_size");
+                {
+                    b.field("type", "double");
+                    b.field("script", "");
+                }
+                b.endObject();
+                b.startObject("duration");
+                {
+                    b.field("type", "long");
+                    b.field("script", "");
+                }
+                b.endObject();
+            }
+            b.endObject();
+        }));
+
+        List<Document> docs = new ArrayList<>();
+        for (Object[] request : raw_requests) {
+            Document document = new Document();
+            document.add(new TextField("raw_message", (String) request[0], Field.Store.YES));
+            docs.add(document);
+        }
+
+        int[] scriptIndex = { 1 };
+
+        // Mock DerivedFieldScript.Factory
+        DerivedFieldScript.Factory factory = (params, lookup) -> (DerivedFieldScript.LeafFactory) ctx -> new DerivedFieldScript(
+            params,
+            lookup,
+            ctx
+        ) {
+            int docId = 0;
+
+            @Override
+            public void setDocument(int docId) {
+                super.setDocument(docId);
+                this.docId = docId;
+            }
+
+            @Override
+            public void execute() {
+                addEmittedValue(raw_requests[docId][scriptIndex[0]]);
+            }
+        };
+
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.compile(Mockito.any(), Mockito.any())).thenReturn(factory);
+        when(queryShardContext.sourcePath("raw_message")).thenReturn(Set.of("raw_message"));
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+
+        // Index and Search
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            for (Document d : docs) {
+                iw.addDocument(d);
+            }
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+
+                IndexSearcher searcher = new IndexSearcher(reader);
+                Query query = QueryBuilders.termQuery("request_succeeded", "true").toQuery(queryShardContext);
+                TopDocs topDocs = searcher.search(query, 10);
+                assertEquals(4, topDocs.totalHits.value);
+
+                // IP Field Term Query
+                scriptIndex[0] = 3;
+                query = QueryBuilders.termQuery("client_ip", "192.168.0.0/16").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(1, topDocs.totalHits.value);
+
+                scriptIndex[0] = 4;
+                query = QueryBuilders.termsQuery("method", "DELETE", "PUT").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(3, topDocs.totalHits.value);
+
+                query = QueryBuilders.termsQuery("method", "delete").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(0, topDocs.totalHits.value);
+
+                query = QueryBuilders.termQuery("method", "delete").caseInsensitive(true).toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(2, topDocs.totalHits.value);
+
+                // Range queries of types - date, long and double
+                scriptIndex[0] = 2;
+                query = QueryBuilders.rangeQuery("@timestamp").from("2024-03-20T14:20:50").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(4, topDocs.totalHits.value);
+
+                scriptIndex[0] = 5;
+                query = QueryBuilders.rangeQuery("request_size").from("4.1").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(7, topDocs.totalHits.value);
+
+                scriptIndex[0] = 6;
+                query = QueryBuilders.rangeQuery("duration").from("5800").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(6, topDocs.totalHits.value);
+
+                scriptIndex[0] = 4;
+
+                // Prefix Query
+                query = QueryBuilders.prefixQuery("method", "DE").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(2, topDocs.totalHits.value);
+
+                scriptIndex[0] = 4;
+                query = QueryBuilders.wildcardQuery("method", "G*").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(7, topDocs.totalHits.value);
+
+                // Regexp Query
+                scriptIndex[0] = 4;
+                query = QueryBuilders.regexpQuery("method", ".*LET.*").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(2, topDocs.totalHits.value);
+            }
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/mapper/DerivedFieldMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/DerivedFieldMapperTests.java
new file mode 100644
index 0000000000000..e3e2b978369ff
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/mapper/DerivedFieldMapperTests.java
@@ -0,0 +1,117 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.opensearch.common.CheckedConsumer;
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.script.Script;
+
+import java.io.IOException;
+
+public class DerivedFieldMapperTests extends MapperTestCase {
+
+    protected boolean supportsOrIgnoresBoost() {
+        return false;
+    }
+
+    protected boolean supportsMeta() {
+        return false;
+    }
+
+    // Overriding fieldMapping to make it create derived mappings by default.
+    // This way, the parent tests are checking the right behavior for this Mapper.
+    @Override
+    protected final XContentBuilder fieldMapping(CheckedConsumer<XContentBuilder, IOException> buildField) throws IOException {
+        return fieldMapping(buildField, true);
+    }
+
+    // Overriding this to do nothing since derived fields are not written in the documents
+    @Override
+    protected void writeFieldValue(XContentBuilder builder) throws IOException {}
+
+    @Override
+    protected void minimalMapping(XContentBuilder b) throws IOException {
+        b.field("type", "keyword");
+    }
+
+    protected void registerParameters(ParameterChecker checker) throws IOException {
+        // TODO Any conflicts or updates to check for here? Parameters index, store, doc_values and boost are not
+        // supported for DerivedFieldMapper (we explicitly set these values on initialization)
+    }
+
+    // TODO: Can update this once the query implementation is completed
+    // This is also being left blank because the super assertExistsQuery is trying to parse
+    // an empty source and fails.
+    @Override
+    protected void assertExistsQuery(MapperService mapperService) {}
+
+    public void testSerialization() throws IOException {
+
+        DocumentMapper defaultMapper = createDocumentMapper(fieldMapping(this::minimalMapping));
+        Mapper mapper = defaultMapper.mappers().getMapper("field");
+        assertTrue(mapper instanceof DerivedFieldMapper);
+
+        XContentBuilder builder = XContentFactory.jsonBuilder().startObject();
+        mapper.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+        assertEquals("{\"field\":{\"type\":\"keyword\"}}", builder.toString());
+    }
+
+    public void testParsesScript() throws IOException {
+
+        String scriptString = "doc['test'].value";
+        DocumentMapper defaultMapper = createDocumentMapper(fieldMapping(b -> {
+            b.field("type", "keyword");
+            b.startObject("script");
+            b.field("source", scriptString);
+            b.endObject();
+        }));
+        Mapper mapper = defaultMapper.mappers().getMapper("field");
+        assertTrue(mapper instanceof DerivedFieldMapper);
+        DerivedFieldMapper derivedFieldMapper = (DerivedFieldMapper) mapper;
+        assertEquals(Script.parse(scriptString), derivedFieldMapper.getScript());
+
+        XContentBuilder builder = XContentFactory.jsonBuilder().startObject();
+        mapper.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+        assertEquals(
+            "{\"field\":{\"type\":\"keyword\",\"script\":{\"source\":\"doc['test'].value\",\"lang\":\"painless\"}}}",
+            builder.toString()
+        );
+    }
+
+    // TODO: Is there a case where we want to allow the field to be defined in both 'derived' and 'properties'?
+    // If the user wants to move a field they were testing as derived to be indexed, they should be able to update
+    // the mappings in index template to move the field from 'derived' to 'properties' and it should take affect
+    // during the next index rollover (so even in this case, the field is only defined in one or the other).
+    public void testFieldInDerivedAndProperties() throws IOException {
+        MapperParsingException ex = expectThrows(MapperParsingException.class, () -> createDocumentMapper(topMapping(b -> {
+            b.startObject("derived");
+            b.startObject("field");
+            b.field("type", "keyword");
+            b.endObject();
+            b.endObject();
+            b.startObject("properties");
+            b.startObject("field");
+            b.field("type", "keyword");
+            b.endObject();
+            b.endObject();
+        })));
+        // TODO: Do we want to handle this as a different error? As it stands, it fails as a merge conflict which makes sense.
+        // If it didn't fail here, it would hit the MapperParsingException for the field being defined more than once
+        // when MappingLookup is initialized
+        assertEquals("Failed to parse mapping [_doc]: mapper [field] cannot be changed from type [derived] to [keyword]", ex.getMessage());
+    }
+
+    // TODO TESTCASE: testWithFieldInSource() (derived field with that field present in source)
+    // This is more checking search behavior so may need to revisit this after query implementation
+
+}
diff --git a/server/src/test/java/org/opensearch/index/mapper/ObjectMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/ObjectMapperTests.java
index be947935dc4ea..b10a7d8155056 100644
--- a/server/src/test/java/org/opensearch/index/mapper/ObjectMapperTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/ObjectMapperTests.java
@@ -39,6 +39,7 @@
 import org.opensearch.index.mapper.MapperService.MergeReason;
 import org.opensearch.index.mapper.ObjectMapper.Dynamic;
 import org.opensearch.plugins.Plugin;
+import org.opensearch.script.Script;
 import org.opensearch.test.InternalSettingsPlugin;
 import org.opensearch.test.OpenSearchSingleNodeTestCase;
 
@@ -440,6 +441,52 @@ public void testEmptyName() throws Exception {
         assertThat(e.getMessage(), containsString("name cannot be empty string"));
     }
 
+    public void testDerivedFields() throws Exception {
+        String mapping = XContentFactory.jsonBuilder()
+            .startObject()
+            .startObject("tweet")
+            .startObject("derived")
+            .startObject("derived_field_name1")
+            .field("type", "boolean")
+            .endObject()
+            .startObject("derived_field_name2")
+            .field("type", "keyword")
+            .startObject("script")
+            .field("source", "doc['test'].value")
+            .endObject()
+            .endObject()
+            .endObject()
+            .startObject("properties")
+            .startObject("field_name")
+            .field("type", "date")
+            .endObject()
+            .endObject()
+            .endObject()
+            .endObject()
+            .toString();
+
+        DocumentMapper documentMapper = createIndex("test").mapperService()
+            .documentMapperParser()
+            .parse("tweet", new CompressedXContent(mapping));
+
+        Mapper mapper = documentMapper.root().getMapper("derived_field_name1");
+        assertTrue(mapper instanceof DerivedFieldMapper);
+        DerivedFieldMapper derivedFieldMapper = (DerivedFieldMapper) mapper;
+        assertEquals("boolean", derivedFieldMapper.getType());
+        assertNull(derivedFieldMapper.getScript());
+
+        mapper = documentMapper.root().getMapper("derived_field_name2");
+        assertTrue(mapper instanceof DerivedFieldMapper);
+        derivedFieldMapper = (DerivedFieldMapper) mapper;
+        assertEquals("keyword", derivedFieldMapper.getType());
+        assertEquals(Script.parse("doc['test'].value"), derivedFieldMapper.getScript());
+
+        // Check that field in properties was parsed correctly as well
+        mapper = documentMapper.root().getMapper("field_name");
+        assertNotNull(mapper);
+        assertEquals("date", mapper.typeName());
+    }
+
     @Override
     protected Collection<Class<? extends Plugin>> getPlugins() {
         return pluginList(InternalSettingsPlugin.class);
diff --git a/server/src/test/java/org/opensearch/index/query/DerivedFieldQueryTests.java b/server/src/test/java/org/opensearch/index/query/DerivedFieldQueryTests.java
index 18d117fa8c0f5..1bb303a874b9a 100644
--- a/server/src/test/java/org/opensearch/index/query/DerivedFieldQueryTests.java
+++ b/server/src/test/java/org/opensearch/index/query/DerivedFieldQueryTests.java
@@ -67,8 +67,8 @@ public void testDerivedField() throws IOException {
             when(searchLookup.getLeafSearchLookup(ctx)).thenReturn(leafLookup);
             return new DerivedFieldScript(params, lookup, ctx) {
                 @Override
-                public Object execute() {
-                    return raw_requests[sourceLookup.docId()][2];
+                public void execute() {
+                    addEmittedValue(raw_requests[sourceLookup.docId()][2]);
                 }
             };
         };
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteStorePathTypeTests.java b/server/src/test/java/org/opensearch/index/remote/RemoteStoreEnumsTests.java
similarity index 51%
rename from server/src/test/java/org/opensearch/index/remote/RemoteStorePathTypeTests.java
rename to server/src/test/java/org/opensearch/index/remote/RemoteStoreEnumsTests.java
index 0f108d1b45f5a..33008bee1a392 100644
--- a/server/src/test/java/org/opensearch/index/remote/RemoteStorePathTypeTests.java
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteStoreEnumsTests.java
@@ -9,44 +9,46 @@
 package org.opensearch.index.remote;
 
 import org.opensearch.common.blobstore.BlobPath;
-import org.opensearch.index.remote.RemoteStoreDataEnums.DataCategory;
-import org.opensearch.index.remote.RemoteStoreDataEnums.DataType;
+import org.opensearch.index.remote.RemoteStoreEnums.DataCategory;
+import org.opensearch.index.remote.RemoteStoreEnums.DataType;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.index.remote.RemoteStorePathStrategy.PathInput;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataCategory.SEGMENTS;
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataCategory.TRANSLOG;
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataType.DATA;
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataType.LOCK_FILES;
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataType.METADATA;
-import static org.opensearch.index.remote.RemoteStorePathType.FIXED;
-import static org.opensearch.index.remote.RemoteStorePathType.parseString;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataCategory.SEGMENTS;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataCategory.TRANSLOG;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataType.DATA;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataType.LOCK_FILES;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataType.METADATA;
+import static org.opensearch.index.remote.RemoteStoreEnums.PathType.FIXED;
+import static org.opensearch.index.remote.RemoteStoreEnums.PathType.parseString;
 
-public class RemoteStorePathTypeTests extends OpenSearchTestCase {
+public class RemoteStoreEnumsTests extends OpenSearchTestCase {
 
     private static final String SEPARATOR = "/";
 
     public void testParseString() {
         // Case 1 - Pass values from the enum.
         String typeString = FIXED.toString();
-        RemoteStorePathType type = parseString(randomFrom(typeString, typeString.toLowerCase(Locale.ROOT)));
+        PathType type = parseString(randomFrom(typeString, typeString.toLowerCase(Locale.ROOT)));
         assertEquals(FIXED, type);
 
-        typeString = RemoteStorePathType.HASHED_PREFIX.toString();
+        typeString = PathType.HASHED_PREFIX.toString();
         type = parseString(randomFrom(typeString, typeString.toLowerCase(Locale.ROOT)));
-        assertEquals(RemoteStorePathType.HASHED_PREFIX, type);
+        assertEquals(PathType.HASHED_PREFIX, type);
 
         // Case 2 - Pass random string
         String randomTypeString = randomAlphaOfLength(2);
         IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> parseString(randomTypeString));
-        assertEquals("Could not parse RemoteStorePathType for [" + randomTypeString + "]", ex.getMessage());
+        assertEquals("Could not parse PathType for [" + randomTypeString + "]", ex.getMessage());
 
         // Case 3 - Null string
         ex = assertThrows(IllegalArgumentException.class, () -> parseString(null));
-        assertEquals("Could not parse RemoteStorePathType for [null]", ex.getMessage());
+        assertEquals("Could not parse PathType for [null]", ex.getMessage());
     }
 
     public void testGeneratePathForFixedType() {
@@ -63,32 +65,74 @@ public void testGeneratePathForFixedType() {
 
         String basePath = getPath(pathList) + indexUUID + SEPARATOR + shardId + SEPARATOR;
         // Translog Data
-        BlobPath result = FIXED.path(blobPath, indexUUID, shardId, dataCategory, dataType);
+        PathInput pathInput = PathInput.builder()
+            .basePath(blobPath)
+            .indexUUID(indexUUID)
+            .shardId(shardId)
+            .dataCategory(dataCategory)
+            .dataType(dataType)
+            .build();
+        BlobPath result = FIXED.path(pathInput, null);
         assertEquals(basePath + dataCategory.getName() + SEPARATOR + dataType.getName() + SEPARATOR, result.buildAsString());
 
         // Translog Metadata
         dataType = METADATA;
-        result = FIXED.path(blobPath, indexUUID, shardId, dataCategory, dataType);
+        pathInput = PathInput.builder()
+            .basePath(blobPath)
+            .indexUUID(indexUUID)
+            .shardId(shardId)
+            .dataCategory(dataCategory)
+            .dataType(dataType)
+            .build();
+        result = FIXED.path(pathInput, null);
         assertEquals(basePath + dataCategory.getName() + SEPARATOR + dataType.getName() + SEPARATOR, result.buildAsString());
 
         // Translog Lock files - This is a negative case where the assertion will trip.
-        BlobPath finalBlobPath = blobPath;
-        assertThrows(AssertionError.class, () -> FIXED.path(finalBlobPath, indexUUID, shardId, TRANSLOG, LOCK_FILES));
+        dataType = LOCK_FILES;
+        PathInput finalPathInput = PathInput.builder()
+            .basePath(blobPath)
+            .indexUUID(indexUUID)
+            .shardId(shardId)
+            .dataCategory(dataCategory)
+            .dataType(dataType)
+            .build();
+        assertThrows(AssertionError.class, () -> FIXED.path(finalPathInput, null));
 
         // Segment Data
         dataCategory = SEGMENTS;
         dataType = DATA;
-        result = FIXED.path(blobPath, indexUUID, shardId, dataCategory, dataType);
+        pathInput = PathInput.builder()
+            .basePath(blobPath)
+            .indexUUID(indexUUID)
+            .shardId(shardId)
+            .dataCategory(dataCategory)
+            .dataType(dataType)
+            .build();
+        result = FIXED.path(pathInput, null);
         assertEquals(basePath + dataCategory.getName() + SEPARATOR + dataType.getName() + SEPARATOR, result.buildAsString());
 
         // Segment Metadata
         dataType = METADATA;
-        result = FIXED.path(blobPath, indexUUID, shardId, dataCategory, dataType);
+        pathInput = PathInput.builder()
+            .basePath(blobPath)
+            .indexUUID(indexUUID)
+            .shardId(shardId)
+            .dataCategory(dataCategory)
+            .dataType(dataType)
+            .build();
+        result = FIXED.path(pathInput, null);
         assertEquals(basePath + dataCategory.getName() + SEPARATOR + dataType.getName() + SEPARATOR, result.buildAsString());
 
         // Segment Metadata
         dataType = LOCK_FILES;
-        result = FIXED.path(blobPath, indexUUID, shardId, dataCategory, dataType);
+        pathInput = PathInput.builder()
+            .basePath(blobPath)
+            .indexUUID(indexUUID)
+            .shardId(shardId)
+            .dataCategory(dataCategory)
+            .dataType(dataType)
+            .build();
+        result = FIXED.path(pathInput, null);
         assertEquals(basePath + dataCategory.getName() + SEPARATOR + dataType.getName() + SEPARATOR, result.buildAsString());
     }
 
@@ -108,4 +152,5 @@ private String getPath(List<String> pathList) {
         }
         return p + SEPARATOR;
     }
+
 }
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteStoreTestsHelper.java b/server/src/test/java/org/opensearch/index/remote/RemoteStoreTestsHelper.java
index e072d3037caad..043b4493e8989 100644
--- a/server/src/test/java/org/opensearch/index/remote/RemoteStoreTestsHelper.java
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteStoreTestsHelper.java
@@ -10,6 +10,7 @@
 
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.shard.IndexShard;
@@ -37,4 +38,22 @@ static IndexShard createIndexShard(ShardId shardId, boolean remoteStoreEnabled)
         when(indexShard.store()).thenReturn(store);
         return indexShard;
     }
+
+    public static IndexSettings createIndexSettings(boolean remote) {
+        return createIndexSettings(remote, Settings.EMPTY);
+    }
+
+    public static IndexSettings createIndexSettings(boolean remote, Settings settings) {
+        IndexSettings indexSettings;
+        if (remote) {
+            Settings nodeSettings = Settings.builder()
+                .put("node.name", "xyz")
+                .put("node.attr.remote_store.translog.repository", "seg_repo")
+                .build();
+            indexSettings = IndexSettingsModule.newIndexSettings(new Index("test_index", "_na_"), settings, nodeSettings);
+        } else {
+            indexSettings = IndexSettingsModule.newIndexSettings("test_index", settings);
+        }
+        return indexSettings;
+    }
 }
diff --git a/server/src/test/java/org/opensearch/index/replication/RetentionLeasesReplicationTests.java b/server/src/test/java/org/opensearch/index/replication/RetentionLeasesReplicationTests.java
index 8c59e92a3fe8a..904c9a70e61e0 100644
--- a/server/src/test/java/org/opensearch/index/replication/RetentionLeasesReplicationTests.java
+++ b/server/src/test/java/org/opensearch/index/replication/RetentionLeasesReplicationTests.java
@@ -45,6 +45,7 @@
 import org.opensearch.index.seqno.RetentionLeaseUtils;
 import org.opensearch.index.seqno.RetentionLeases;
 import org.opensearch.index.shard.IndexShard;
+import org.opensearch.index.shard.IndexShardTestUtils;
 import org.opensearch.test.VersionUtils;
 
 import java.util.ArrayList;
@@ -182,7 +183,8 @@ public void testTurnOffTranslogRetentionAfterAllShardStarted() throws Exception
                     null,
                     1L,
                     group.getPrimary().getReplicationGroup().getInSyncAllocationIds(),
-                    group.getPrimary().getReplicationGroup().getRoutingTable()
+                    group.getPrimary().getReplicationGroup().getRoutingTable(),
+                    IndexShardTestUtils.getFakeDiscoveryNodes(shard.routingEntry())
                 );
             }
             group.syncGlobalCheckpoint();
diff --git a/server/src/test/java/org/opensearch/index/seqno/GlobalCheckpointSyncActionTests.java b/server/src/test/java/org/opensearch/index/seqno/GlobalCheckpointSyncActionTests.java
index 8363ea3757a2b..a27f3476888eb 100644
--- a/server/src/test/java/org/opensearch/index/seqno/GlobalCheckpointSyncActionTests.java
+++ b/server/src/test/java/org/opensearch/index/seqno/GlobalCheckpointSyncActionTests.java
@@ -54,6 +54,7 @@
 
 import java.util.Collections;
 
+import static org.opensearch.index.remote.RemoteStoreTestsHelper.createIndexSettings;
 import static org.opensearch.test.ClusterServiceUtils.createClusterService;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -110,6 +111,7 @@ public void testTranslogSyncAfterGlobalCheckpointSync() throws Exception {
         final ShardId shardId = new ShardId(index, id);
         when(indexShard.shardId()).thenReturn(shardId);
 
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(false));
         final Translog.Durability durability = randomFrom(Translog.Durability.ASYNC, Translog.Durability.REQUEST);
         when(indexShard.getTranslogDurability()).thenReturn(durability);
 
@@ -158,14 +160,14 @@ public void testTranslogSyncAfterGlobalCheckpointSync() throws Exception {
     public void testGetReplicationModeWithRemoteTranslog() {
         final GlobalCheckpointSyncAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(true);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(true));
         assertEquals(ReplicationMode.NO_REPLICATION, action.getReplicationMode(indexShard));
     }
 
     public void testGetReplicationModeWithLocalTranslog() {
         final GlobalCheckpointSyncAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(false);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(false));
         assertEquals(ReplicationMode.FULL_REPLICATION, action.getReplicationMode(indexShard));
     }
 
@@ -191,6 +193,7 @@ public void testMayBeSyncTranslogWithRemoteTranslog() throws Exception {
         when(indexShard.getLastKnownGlobalCheckpoint()).thenReturn(globalCheckpoint);
         when(indexShard.getLastSyncedGlobalCheckpoint()).thenReturn(globalCheckpoint - 1);
         when(indexShard.getTranslogDurability()).thenReturn(Translog.Durability.REQUEST);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(true));
 
         action.shardOperationOnPrimary(primaryRequest, indexShard, ActionTestUtils.assertNoFailureListener(r -> {}));
         verify(indexShard, never()).sync();
@@ -205,6 +208,7 @@ public void testMayBeSyncTranslogWithLocalTranslog() throws Exception {
         when(indexShard.getLastKnownGlobalCheckpoint()).thenReturn(globalCheckpoint);
         when(indexShard.getLastSyncedGlobalCheckpoint()).thenReturn(globalCheckpoint - 1);
         when(indexShard.getTranslogDurability()).thenReturn(Translog.Durability.REQUEST);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(false));
 
         action.shardOperationOnPrimary(primaryRequest, indexShard, ActionTestUtils.assertNoFailureListener(r -> {}));
         verify(indexShard).sync();
diff --git a/server/src/test/java/org/opensearch/index/seqno/PeerRecoveryRetentionLeaseExpiryTests.java b/server/src/test/java/org/opensearch/index/seqno/PeerRecoveryRetentionLeaseExpiryTests.java
index ca80c7b9c4884..7a9f1d7baa12e 100644
--- a/server/src/test/java/org/opensearch/index/seqno/PeerRecoveryRetentionLeaseExpiryTests.java
+++ b/server/src/test/java/org/opensearch/index/seqno/PeerRecoveryRetentionLeaseExpiryTests.java
@@ -93,7 +93,8 @@ public void setUpReplicationTracker() throws InterruptedException {
             value -> {},
             currentTimeMillis::get,
             (leases, listener) -> {},
-            () -> safeCommitInfo
+            () -> safeCommitInfo,
+            sId -> false
         );
         replicationTracker.updateFromClusterManager(
             1L,
diff --git a/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerRetentionLeaseTests.java b/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerRetentionLeaseTests.java
index 3cd60ac973709..fdbe89422a2aa 100644
--- a/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerRetentionLeaseTests.java
+++ b/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerRetentionLeaseTests.java
@@ -84,7 +84,8 @@ public void testAddOrRenewRetentionLease() {
             value -> {},
             () -> 0L,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTracker.updateFromClusterManager(
             randomNonNegativeLong(),
@@ -132,7 +133,8 @@ public void testAddDuplicateRetentionLease() {
             value -> {},
             () -> 0L,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTracker.updateFromClusterManager(
             randomNonNegativeLong(),
@@ -164,7 +166,8 @@ public void testRenewNotFoundRetentionLease() {
             value -> {},
             () -> 0L,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTracker.updateFromClusterManager(
             randomNonNegativeLong(),
@@ -202,7 +205,8 @@ public void testAddRetentionLeaseCausesRetentionLeaseSync() {
                     equalTo(retainingSequenceNumbers)
                 );
             },
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         reference.set(replicationTracker);
         replicationTracker.updateFromClusterManager(
@@ -241,7 +245,8 @@ public void testRemoveRetentionLease() {
             value -> {},
             () -> 0L,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTracker.updateFromClusterManager(
             randomNonNegativeLong(),
@@ -305,7 +310,8 @@ public void testCloneRetentionLease() {
                 assertTrue(synced.compareAndSet(false, true));
                 listener.onResponse(new ReplicationResponse());
             },
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTrackerRef.set(replicationTracker);
         replicationTracker.updateFromClusterManager(
@@ -351,7 +357,8 @@ public void testCloneNonexistentRetentionLease() {
             value -> {},
             () -> 0L,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTracker.updateFromClusterManager(
             randomNonNegativeLong(),
@@ -380,7 +387,8 @@ public void testCloneDuplicateRetentionLease() {
             value -> {},
             () -> 0L,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTracker.updateFromClusterManager(
             randomNonNegativeLong(),
@@ -413,7 +421,8 @@ public void testRemoveNotFound() {
             value -> {},
             () -> 0L,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTracker.updateFromClusterManager(
             randomNonNegativeLong(),
@@ -451,7 +460,8 @@ public void testRemoveRetentionLeaseCausesRetentionLeaseSync() {
                     equalTo(retainingSequenceNumbers)
                 );
             },
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         reference.set(replicationTracker);
         replicationTracker.updateFromClusterManager(
@@ -504,7 +514,8 @@ private void runExpirationTest(final boolean primaryMode) {
             value -> {},
             currentTimeMillis::get,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTracker.updateFromClusterManager(
             randomNonNegativeLong(),
@@ -583,7 +594,8 @@ public void testReplicaIgnoresOlderRetentionLeasesVersion() {
             value -> {},
             () -> 0L,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTracker.updateFromClusterManager(
             randomNonNegativeLong(),
@@ -636,7 +648,8 @@ public void testLoadAndPersistRetentionLeases() throws IOException {
             value -> {},
             () -> 0L,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTracker.updateFromClusterManager(
             randomNonNegativeLong(),
@@ -671,7 +684,8 @@ public void testUnnecessaryPersistenceOfRetentionLeases() throws IOException {
             value -> {},
             () -> 0L,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTracker.updateFromClusterManager(
             randomNonNegativeLong(),
@@ -724,7 +738,8 @@ public void testPersistRetentionLeasesUnderConcurrency() throws IOException {
             value -> {},
             () -> 0L,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTracker.updateFromClusterManager(
             randomNonNegativeLong(),
@@ -788,7 +803,8 @@ public void testRenewLeaseWithLowerRetainingSequenceNumber() throws Exception {
             value -> {},
             () -> 0L,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         replicationTracker.updateFromClusterManager(
             randomNonNegativeLong(),
diff --git a/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerTestCase.java b/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerTestCase.java
index e61d27695a5e5..daeefeff59c94 100644
--- a/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerTestCase.java
+++ b/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerTestCase.java
@@ -40,11 +40,13 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.engine.SafeCommitInfo;
+import org.opensearch.index.remote.RemoteStoreTestsHelper;
 import org.opensearch.test.IndexSettingsModule;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.util.Collections;
 import java.util.Set;
+import java.util.function.Function;
 import java.util.function.LongConsumer;
 import java.util.function.LongSupplier;
 import java.util.function.Supplier;
@@ -57,18 +59,20 @@ ReplicationTracker newTracker(
         final AllocationId allocationId,
         final LongConsumer updatedGlobalCheckpoint,
         final LongSupplier currentTimeMillisSupplier,
-        final Settings settings
+        final Settings settings,
+        final boolean remote
     ) {
         return new ReplicationTracker(
             new ShardId("test", "_na_", 0),
             allocationId.getId(),
-            IndexSettingsModule.newIndexSettings("test", settings),
+            remote ? RemoteStoreTestsHelper.createIndexSettings(true, settings) : IndexSettingsModule.newIndexSettings("test", settings),
             randomNonNegativeLong(),
             UNASSIGNED_SEQ_NO,
             updatedGlobalCheckpoint,
             currentTimeMillisSupplier,
             (leases, listener) -> {},
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            remote ? REMOTE_DISCOVERY_NODE : NON_REMOTE_DISCOVERY_NODE
         );
     }
 
@@ -80,8 +84,21 @@ ReplicationTracker newTracker(
         return newTracker(allocationId, updatedGlobalCheckpoint, currentTimeMillisSupplier, Settings.EMPTY);
     }
 
+    ReplicationTracker newTracker(
+        final AllocationId allocationId,
+        final LongConsumer updatedGlobalCheckpoint,
+        final LongSupplier currentTimeMillisSupplier,
+        final Settings settings
+    ) {
+        return newTracker(allocationId, updatedGlobalCheckpoint, currentTimeMillisSupplier, settings, false);
+    }
+
     static final Supplier<SafeCommitInfo> OPS_BASED_RECOVERY_ALWAYS_REASONABLE = () -> SafeCommitInfo.EMPTY;
 
+    static final Function<String, Boolean> NON_REMOTE_DISCOVERY_NODE = shardId -> false;
+
+    static final Function<String, Boolean> REMOTE_DISCOVERY_NODE = shardId -> true;
+
     static String nodeIdFromAllocationId(final AllocationId allocationId) {
         return "n-" + allocationId.getId().substring(0, 8);
     }
diff --git a/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerTests.java b/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerTests.java
index 7971591e82bab..233a99cbe4a73 100644
--- a/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerTests.java
+++ b/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerTests.java
@@ -446,6 +446,10 @@ public void testWaitForAllocationIdToBeInSync() throws Exception {
 
     private AtomicLong updatedGlobalCheckpoint = new AtomicLong(UNASSIGNED_SEQ_NO);
 
+    private ReplicationTracker newTracker(final AllocationId allocationId, Settings settings, boolean remote) {
+        return newTracker(allocationId, updatedGlobalCheckpoint::set, () -> 0L, settings, remote);
+    }
+
     private ReplicationTracker newTracker(final AllocationId allocationId, Settings settings) {
         return newTracker(allocationId, updatedGlobalCheckpoint::set, () -> 0L, settings);
     }
@@ -759,7 +763,8 @@ public void testPrimaryContextHandoff() throws IOException {
             onUpdate,
             () -> 0L,
             onNewRetentionLease,
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
         ReplicationTracker newPrimary = new ReplicationTracker(
             shardId,
@@ -770,7 +775,8 @@ public void testPrimaryContextHandoff() throws IOException {
             onUpdate,
             () -> 0L,
             onNewRetentionLease,
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            NON_REMOTE_DISCOVERY_NODE
         );
 
         Set<String> allocationIds = new HashSet<>(Arrays.asList(oldPrimary.shardAllocationId, newPrimary.shardAllocationId));
@@ -1300,7 +1306,7 @@ public void testGlobalCheckpointUpdateWithRemoteTranslogEnabled() {
             .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
             .put(IndexMetadata.SETTING_REMOTE_STORE_ENABLED, "true")
             .build();
-        final ReplicationTracker tracker = newTracker(primaryId, settings);
+        final ReplicationTracker tracker = newTracker(primaryId, settings, true);
         assertThat(tracker.getGlobalCheckpoint(), equalTo(UNASSIGNED_SEQ_NO));
 
         long primaryLocalCheckpoint = activeWithCheckpoints.get(primaryId);
@@ -1378,7 +1384,7 @@ public void testUpdateFromClusterManagerWithRemoteTranslogEnabled() {
             .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
             .put(IndexMetadata.SETTING_REMOTE_STORE_ENABLED, "true")
             .build();
-        final ReplicationTracker tracker = newTracker(primaryId, settings);
+        final ReplicationTracker tracker = newTracker(primaryId, settings, true);
         assertThat(tracker.getGlobalCheckpoint(), equalTo(UNASSIGNED_SEQ_NO));
 
         long primaryLocalCheckpoint = activeWithCheckpoints.get(primaryId);
@@ -1476,7 +1482,7 @@ public void testMarkAllocationIdAsInSyncWithRemoteTranslogEnabled() throws Excep
             .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
             .put(IndexMetadata.SETTING_REMOTE_STORE_ENABLED, "true")
             .build();
-        final ReplicationTracker tracker = newTracker(primaryId, settings);
+        final ReplicationTracker tracker = newTracker(primaryId, settings, true);
         tracker.updateFromClusterManager(initialClusterStateVersion, ids(active), routingTable(initializing, primaryId));
         final long localCheckpoint = randomLongBetween(0, Long.MAX_VALUE - 1);
         tracker.activatePrimaryMode(localCheckpoint);
@@ -1504,7 +1510,7 @@ public void testMissingActiveIdsDoesNotPreventAdvanceWithRemoteTranslogEnabled()
             .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
             .put(IndexMetadata.SETTING_REMOTE_STORE_ENABLED, "true")
             .build();
-        final ReplicationTracker tracker = newTracker(primaryId, settings);
+        final ReplicationTracker tracker = newTracker(primaryId, settings, true);
         tracker.updateFromClusterManager(randomNonNegativeLong(), ids(active.keySet()), routingTable(initializing.keySet(), primaryId));
         tracker.activatePrimaryMode(NO_OPS_PERFORMED);
         List<AllocationId> initializingRandomSubset = randomSubsetOf(initializing.keySet());
@@ -1537,7 +1543,7 @@ public void testMissingInSyncIdsDoesNotPreventAdvanceWithRemoteTranslogEnabled()
             .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
             .put(IndexMetadata.SETTING_REMOTE_STORE_ENABLED, "true")
             .build();
-        final ReplicationTracker tracker = newTracker(primaryId, settings);
+        final ReplicationTracker tracker = newTracker(primaryId, settings, true);
         tracker.updateFromClusterManager(randomNonNegativeLong(), ids(active.keySet()), routingTable(initializing.keySet(), primaryId));
         tracker.activatePrimaryMode(NO_OPS_PERFORMED);
         randomSubsetOf(randomIntBetween(1, initializing.size() - 1), initializing.keySet()).forEach(
@@ -1606,8 +1612,8 @@ public void testInSyncIdsAreRemovedIfNotValidatedByClusterManagerWithRemoteTrans
             .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
             .put(IndexMetadata.SETTING_REMOTE_STORE_ENABLED, "true")
             .build();
-        final ReplicationTracker tracker = newTracker(primaryId, settings);
-        tracker.updateFromClusterManager(initialClusterStateVersion, ids(active), routingTable(initializing, primaryId));
+        final ReplicationTracker tracker = newTracker(primaryId, settings, true);
+        tracker.updateFromClusterManager(initialClusterStateVersion, ids(active), routingTable(initializing, active, primaryId));
         tracker.activatePrimaryMode(NO_OPS_PERFORMED);
         if (randomBoolean()) {
             initializingToStay.keySet().forEach(k -> markAsTrackingAndInSyncQuietly(tracker, k.getId(), NO_OPS_PERFORMED));
@@ -1655,7 +1661,7 @@ public void testUpdateAllocationIdsFromClusterManagerWithRemoteTranslogEnabled()
             .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
             .put(IndexMetadata.SETTING_REMOTE_STORE_ENABLED, "true")
             .build();
-        final ReplicationTracker tracker = newTracker(primaryId, settings);
+        final ReplicationTracker tracker = newTracker(primaryId, settings, true);
         tracker.updateFromClusterManager(initialClusterStateVersion, ids(activeAllocationIds), routingTable);
         tracker.activatePrimaryMode(NO_OPS_PERFORMED);
         assertThat(tracker.getReplicationGroup().getInSyncAllocationIds(), equalTo(ids(activeAllocationIds)));
@@ -2080,7 +2086,8 @@ public void testPrimaryContextHandoffWithRemoteTranslogEnabled() throws IOExcept
             onUpdate,
             () -> 0L,
             onNewRetentionLease,
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            REMOTE_DISCOVERY_NODE
         );
         ReplicationTracker newPrimary = new ReplicationTracker(
             shardId,
@@ -2091,7 +2098,8 @@ public void testPrimaryContextHandoffWithRemoteTranslogEnabled() throws IOExcept
             onUpdate,
             () -> 0L,
             onNewRetentionLease,
-            OPS_BASED_RECOVERY_ALWAYS_REASONABLE
+            OPS_BASED_RECOVERY_ALWAYS_REASONABLE,
+            REMOTE_DISCOVERY_NODE
         );
 
         Set<String> allocationIds = new HashSet<>(Arrays.asList(oldPrimary.shardAllocationId, newPrimary.shardAllocationId));
diff --git a/server/src/test/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncActionTests.java b/server/src/test/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncActionTests.java
index ed04d9a20f18e..d5d7163b66698 100644
--- a/server/src/test/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncActionTests.java
+++ b/server/src/test/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncActionTests.java
@@ -60,6 +60,7 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import static org.opensearch.index.remote.RemoteStoreTestsHelper.createIndexSettings;
 import static org.opensearch.test.ClusterServiceUtils.createClusterService;
 import static org.hamcrest.Matchers.sameInstance;
 import static org.mockito.Mockito.mock;
@@ -215,14 +216,14 @@ public void testBlocks() {
     public void testGetReplicationModeWithRemoteTranslog() {
         final RetentionLeaseBackgroundSyncAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(true);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(true));
         assertEquals(ReplicationMode.NO_REPLICATION, action.getReplicationMode(indexShard));
     }
 
     public void testGetReplicationModeWithLocalTranslog() {
         final RetentionLeaseBackgroundSyncAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(false);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(false));
         assertEquals(ReplicationMode.FULL_REPLICATION, action.getReplicationMode(indexShard));
     }
 
diff --git a/server/src/test/java/org/opensearch/index/seqno/RetentionLeaseSyncActionTests.java b/server/src/test/java/org/opensearch/index/seqno/RetentionLeaseSyncActionTests.java
index 63a9ac2f2e8ec..7610b8bc39296 100644
--- a/server/src/test/java/org/opensearch/index/seqno/RetentionLeaseSyncActionTests.java
+++ b/server/src/test/java/org/opensearch/index/seqno/RetentionLeaseSyncActionTests.java
@@ -60,6 +60,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import static java.util.Collections.emptyMap;
+import static org.opensearch.index.remote.RemoteStoreTestsHelper.createIndexSettings;
 import static org.opensearch.test.ClusterServiceUtils.createClusterService;
 import static org.hamcrest.Matchers.sameInstance;
 import static org.mockito.Mockito.mock;
@@ -215,15 +216,15 @@ public void testBlocks() {
     public void testGetReplicationModeWithRemoteTranslog() {
         final RetentionLeaseSyncAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(true);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(true));
         assertEquals(ReplicationMode.NO_REPLICATION, action.getReplicationMode(indexShard));
     }
 
     public void testGetReplicationModeWithLocalTranslog() {
         final RetentionLeaseSyncAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(true);
-        assertEquals(ReplicationMode.NO_REPLICATION, action.getReplicationMode(indexShard));
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(false));
+        assertEquals(ReplicationMode.FULL_REPLICATION, action.getReplicationMode(indexShard));
     }
 
     private RetentionLeaseSyncAction createAction() {
diff --git a/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java b/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
index 537bfcf8f8a6b..e5bfa8caee79a 100644
--- a/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
@@ -697,7 +697,8 @@ public void testPrimaryPromotionRollsGeneration() throws Exception {
             (shard, listener) -> {},
             0L,
             Collections.singleton(primaryRouting.allocationId().getId()),
-            new IndexShardRoutingTable.Builder(primaryRouting.shardId()).addShard(primaryRouting).build()
+            new IndexShardRoutingTable.Builder(primaryRouting.shardId()).addShard(primaryRouting).build(),
+            IndexShardTestUtils.getFakeDiscoveryNodes(primaryRouting)
         );
 
         /*
@@ -764,7 +765,8 @@ public void testOperationPermitsOnPrimaryShards() throws Exception {
             },
                 0L,
                 Collections.singleton(indexShard.routingEntry().allocationId().getId()),
-                new IndexShardRoutingTable.Builder(indexShard.shardId()).addShard(primaryRouting).build()
+                new IndexShardRoutingTable.Builder(indexShard.shardId()).addShard(primaryRouting).build(),
+                IndexShardTestUtils.getFakeDiscoveryNodes(primaryRouting)
             );
             latch.await();
             assertThat(indexShard.getActiveOperationsCount(), is(oneOf(0, IndexShard.OPERATIONS_BLOCKED)));
@@ -1446,7 +1448,8 @@ public void onFailure(Exception e) {
             (s, r) -> resyncLatch.countDown(),
             1L,
             Collections.singleton(newRouting.allocationId().getId()),
-            new IndexShardRoutingTable.Builder(newRouting.shardId()).addShard(newRouting).build()
+            new IndexShardRoutingTable.Builder(newRouting.shardId()).addShard(newRouting).build(),
+            IndexShardTestUtils.getFakeDiscoveryNodes(newRouting)
         );
         resyncLatch.await();
         assertThat(indexShard.getLocalCheckpoint(), equalTo(maxSeqNo));
@@ -3284,7 +3287,7 @@ public void testRecoverFromTranslog() throws IOException {
         Translog.Snapshot snapshot = TestTranslog.newSnapshotFromOperations(operations);
         primary.markAsRecovering(
             "store",
-            new RecoveryState(primary.routingEntry(), getFakeDiscoNode(primary.routingEntry().currentNodeId()), null)
+            new RecoveryState(primary.routingEntry(), IndexShardTestUtils.getFakeDiscoNode(primary.routingEntry().currentNodeId()), null)
         );
         recoverFromStore(primary);
 
@@ -4029,15 +4032,19 @@ public void testReadSnapshotAndCheckIndexConcurrently() throws Exception {
         if (isPrimary) {
             newShard.markAsRecovering(
                 "store",
-                new RecoveryState(newShard.routingEntry(), getFakeDiscoNode(newShard.routingEntry().currentNodeId()), null)
+                new RecoveryState(
+                    newShard.routingEntry(),
+                    IndexShardTestUtils.getFakeDiscoNode(newShard.routingEntry().currentNodeId()),
+                    null
+                )
             );
         } else {
             newShard.markAsRecovering(
                 "peer",
                 new RecoveryState(
                     newShard.routingEntry(),
-                    getFakeDiscoNode(newShard.routingEntry().currentNodeId()),
-                    getFakeDiscoNode(newShard.routingEntry().currentNodeId())
+                    IndexShardTestUtils.getFakeDiscoNode(newShard.routingEntry().currentNodeId()),
+                    IndexShardTestUtils.getFakeDiscoNode(newShard.routingEntry().currentNodeId())
                 )
             );
         }
diff --git a/server/src/test/java/org/opensearch/index/shard/PrimaryReplicaSyncerTests.java b/server/src/test/java/org/opensearch/index/shard/PrimaryReplicaSyncerTests.java
index b1bcaac2c1947..09903a8b44cb5 100644
--- a/server/src/test/java/org/opensearch/index/shard/PrimaryReplicaSyncerTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/PrimaryReplicaSyncerTests.java
@@ -111,7 +111,8 @@ public void testSyncerSendsOffCorrectDocuments() throws Exception {
             null,
             1000L,
             Collections.singleton(allocationId),
-            new IndexShardRoutingTable.Builder(shard.shardId()).addShard(shard.routingEntry()).build()
+            new IndexShardRoutingTable.Builder(shard.shardId()).addShard(shard.routingEntry()).build(),
+            IndexShardTestUtils.getFakeDiscoveryNodes(shard.routingEntry())
         );
         shard.updateLocalCheckpointForShard(allocationId, globalCheckPoint);
         assertEquals(globalCheckPoint, shard.getLastKnownGlobalCheckpoint());
@@ -190,7 +191,8 @@ public void testSyncerOnClosingShard() throws Exception {
             null,
             1000L,
             Collections.singleton(allocationId),
-            new IndexShardRoutingTable.Builder(shard.shardId()).addShard(shard.routingEntry()).build()
+            new IndexShardRoutingTable.Builder(shard.shardId()).addShard(shard.routingEntry()).build(),
+            IndexShardTestUtils.getFakeDiscoveryNodes(shard.routingEntry())
         );
 
         CountDownLatch syncCalledLatch = new CountDownLatch(1);
diff --git a/server/src/test/java/org/opensearch/index/snapshots/blobstore/RemoteStoreShardShallowCopySnapshotTests.java b/server/src/test/java/org/opensearch/index/snapshots/blobstore/RemoteStoreShardShallowCopySnapshotTests.java
index 38c4bb781ce06..e3259a3097278 100644
--- a/server/src/test/java/org/opensearch/index/snapshots/blobstore/RemoteStoreShardShallowCopySnapshotTests.java
+++ b/server/src/test/java/org/opensearch/index/snapshots/blobstore/RemoteStoreShardShallowCopySnapshotTests.java
@@ -14,6 +14,8 @@
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.io.IOException;
@@ -40,7 +42,10 @@ public void testToXContent() throws IOException {
         String repositoryBasePath = "test-repo-basepath";
         List<String> fileNames = new ArrayList<>(5);
         fileNames.addAll(Arrays.asList("file1", "file2", "file3", "file4", "file5"));
+
+        // Case 1 - Without remote path type fields
         RemoteStoreShardShallowCopySnapshot shardShallowCopySnapshot = new RemoteStoreShardShallowCopySnapshot(
+            "1",
             snapshot,
             indexVersion,
             primaryTerm,
@@ -52,7 +57,9 @@ public void testToXContent() throws IOException {
             indexUUID,
             remoteStoreRepository,
             repositoryBasePath,
-            fileNames
+            fileNames,
+            null,
+            null
         );
         String actual;
         try (XContentBuilder builder = MediaTypeRegistry.JSON.contentBuilder()) {
@@ -66,6 +73,67 @@ public void testToXContent() throws IOException {
             + "\"test-rs-repository\",\"commit_generation\":5,\"primary_term\":3,\"remote_store_repository_base_path\":"
             + "\"test-repo-basepath\",\"file_names\":[\"file1\",\"file2\",\"file3\",\"file4\",\"file5\"]}";
         assert Objects.equals(actual, expectedXContent) : "xContent is " + actual;
+
+        // Case 2 - with just fixed type
+        shardShallowCopySnapshot = new RemoteStoreShardShallowCopySnapshot(
+            snapshot,
+            indexVersion,
+            primaryTerm,
+            commitGeneration,
+            startTime,
+            time,
+            totalFileCount,
+            totalSize,
+            indexUUID,
+            remoteStoreRepository,
+            repositoryBasePath,
+            fileNames,
+            PathType.FIXED,
+            null
+        );
+        try (XContentBuilder builder = MediaTypeRegistry.JSON.contentBuilder()) {
+            builder.startObject();
+            shardShallowCopySnapshot.toXContent(builder, ToXContent.EMPTY_PARAMS);
+            builder.endObject();
+            actual = builder.toString();
+        }
+
+        expectedXContent = "{\"version\":\"2\",\"name\":\"test-snapshot\",\"index_version\":1,\"start_time\":123,\"time\":123,"
+            + "\"number_of_files\":5,\"total_size\":5,\"index_uuid\":\"syzhajds-ashdlfj\",\"remote_store_repository\":"
+            + "\"test-rs-repository\",\"commit_generation\":5,\"primary_term\":3,\"remote_store_repository_base_path\":"
+            + "\"test-repo-basepath\",\"file_names\":[\"file1\",\"file2\",\"file3\",\"file4\",\"file5\"],\"path_type\":0}";
+        assert Objects.equals(actual, expectedXContent) : "xContent is " + actual;
+
+        // Case 3 - with just hashed prefix type and hash algorithm
+        shardShallowCopySnapshot = new RemoteStoreShardShallowCopySnapshot(
+            snapshot,
+            indexVersion,
+            primaryTerm,
+            commitGeneration,
+            startTime,
+            time,
+            totalFileCount,
+            totalSize,
+            indexUUID,
+            remoteStoreRepository,
+            repositoryBasePath,
+            fileNames,
+            PathType.HASHED_PREFIX,
+            PathHashAlgorithm.FNV_1A
+        );
+        try (XContentBuilder builder = MediaTypeRegistry.JSON.contentBuilder()) {
+            builder.startObject();
+            shardShallowCopySnapshot.toXContent(builder, ToXContent.EMPTY_PARAMS);
+            builder.endObject();
+            actual = builder.toString();
+        }
+
+        expectedXContent = "{\"version\":\"2\",\"name\":\"test-snapshot\",\"index_version\":1,\"start_time\":123,\"time\":123,"
+            + "\"number_of_files\":5,\"total_size\":5,\"index_uuid\":\"syzhajds-ashdlfj\",\"remote_store_repository\":"
+            + "\"test-rs-repository\",\"commit_generation\":5,\"primary_term\":3,\"remote_store_repository_base_path\":"
+            + "\"test-repo-basepath\",\"file_names\":[\"file1\",\"file2\",\"file3\",\"file4\",\"file5\"],\"path_type\":1"
+            + ",\"path_hash_algorithm\":0}";
+        assert Objects.equals(actual, expectedXContent) : "xContent is " + actual;
     }
 
     public void testFromXContent() throws IOException {
@@ -83,6 +151,7 @@ public void testFromXContent() throws IOException {
         List<String> fileNames = new ArrayList<>(5);
         fileNames.addAll(Arrays.asList("file1", "file2", "file3", "file4", "file5"));
         RemoteStoreShardShallowCopySnapshot expectedShardShallowCopySnapshot = new RemoteStoreShardShallowCopySnapshot(
+            "1",
             snapshot,
             indexVersion,
             primaryTerm,
@@ -94,7 +163,9 @@ public void testFromXContent() throws IOException {
             indexUUID,
             remoteStoreRepository,
             repositoryBasePath,
-            fileNames
+            fileNames,
+            null,
+            null
         );
         String xContent = "{\"version\":\"1\",\"name\":\"test-snapshot\",\"index_version\":1,\"start_time\":123,\"time\":123,"
             + "\"number_of_files\":5,\"total_size\":5,\"index_uuid\":\"syzhajds-ashdlfj\",\"remote_store_repository\":"
@@ -102,22 +173,66 @@ public void testFromXContent() throws IOException {
             + "\"test-repo-basepath\",\"file_names\":[\"file1\",\"file2\",\"file3\",\"file4\",\"file5\"]}";
         try (XContentParser parser = createParser(JsonXContent.jsonXContent, xContent)) {
             RemoteStoreShardShallowCopySnapshot actualShardShallowCopySnapshot = RemoteStoreShardShallowCopySnapshot.fromXContent(parser);
-            assertEquals(actualShardShallowCopySnapshot.snapshot(), expectedShardShallowCopySnapshot.snapshot());
-            assertEquals(
-                actualShardShallowCopySnapshot.getRemoteStoreRepository(),
-                expectedShardShallowCopySnapshot.getRemoteStoreRepository()
-            );
-            assertEquals(actualShardShallowCopySnapshot.getCommitGeneration(), expectedShardShallowCopySnapshot.getCommitGeneration());
-            assertEquals(actualShardShallowCopySnapshot.getPrimaryTerm(), expectedShardShallowCopySnapshot.getPrimaryTerm());
-            assertEquals(actualShardShallowCopySnapshot.startTime(), expectedShardShallowCopySnapshot.startTime());
-            assertEquals(actualShardShallowCopySnapshot.time(), expectedShardShallowCopySnapshot.time());
-            assertEquals(actualShardShallowCopySnapshot.totalSize(), expectedShardShallowCopySnapshot.totalSize());
-            assertEquals(actualShardShallowCopySnapshot.totalFileCount(), expectedShardShallowCopySnapshot.totalFileCount());
+            assert Objects.equals(expectedShardShallowCopySnapshot, actualShardShallowCopySnapshot);
+        }
+
+        // with pathType=PathType.FIXED
+        xContent = "{\"version\":\"2\",\"name\":\"test-snapshot\",\"index_version\":1,\"start_time\":123,\"time\":123,"
+            + "\"number_of_files\":5,\"total_size\":5,\"index_uuid\":\"syzhajds-ashdlfj\",\"remote_store_repository\":"
+            + "\"test-rs-repository\",\"commit_generation\":5,\"primary_term\":3,\"remote_store_repository_base_path\":"
+            + "\"test-repo-basepath\",\"file_names\":[\"file1\",\"file2\",\"file3\",\"file4\",\"file5\"],\"path_type\":0}";
+        expectedShardShallowCopySnapshot = new RemoteStoreShardShallowCopySnapshot(
+            "2",
+            snapshot,
+            indexVersion,
+            primaryTerm,
+            commitGeneration,
+            startTime,
+            time,
+            totalFileCount,
+            totalSize,
+            indexUUID,
+            remoteStoreRepository,
+            repositoryBasePath,
+            fileNames,
+            PathType.FIXED,
+            null
+        );
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, xContent)) {
+            RemoteStoreShardShallowCopySnapshot actualShardShallowCopySnapshot = RemoteStoreShardShallowCopySnapshot.fromXContent(parser);
+            assert Objects.equals(expectedShardShallowCopySnapshot, actualShardShallowCopySnapshot);
+        }
+
+        // with pathType=PathType.HASHED_PREFIX and pathHashAlgorithm=PathHashAlgorithm.FNV_1A
+        xContent = "{\"version\":\"2\",\"name\":\"test-snapshot\",\"index_version\":1,\"start_time\":123,\"time\":123,"
+            + "\"number_of_files\":5,\"total_size\":5,\"index_uuid\":\"syzhajds-ashdlfj\",\"remote_store_repository\":"
+            + "\"test-rs-repository\",\"commit_generation\":5,\"primary_term\":3,\"remote_store_repository_base_path\":"
+            + "\"test-repo-basepath\",\"file_names\":[\"file1\",\"file2\",\"file3\",\"file4\",\"file5\"],\"path_type\":1,\"path_hash_algorithm\":0}";
+        expectedShardShallowCopySnapshot = new RemoteStoreShardShallowCopySnapshot(
+            "2",
+            snapshot,
+            indexVersion,
+            primaryTerm,
+            commitGeneration,
+            startTime,
+            time,
+            totalFileCount,
+            totalSize,
+            indexUUID,
+            remoteStoreRepository,
+            repositoryBasePath,
+            fileNames,
+            PathType.HASHED_PREFIX,
+            PathHashAlgorithm.FNV_1A
+        );
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, xContent)) {
+            RemoteStoreShardShallowCopySnapshot actualShardShallowCopySnapshot = RemoteStoreShardShallowCopySnapshot.fromXContent(parser);
+            assert Objects.equals(expectedShardShallowCopySnapshot, actualShardShallowCopySnapshot);
         }
     }
 
     public void testFromXContentInvalid() throws IOException {
-        final int iters = scaledRandomIntBetween(1, 10);
+        final int iters = 14;
         for (int iter = 0; iter < iters; iter++) {
             String snapshot = "test-snapshot";
             long indexVersion = 1;
@@ -133,10 +248,11 @@ public void testFromXContentInvalid() throws IOException {
             List<String> fileNames = new ArrayList<>(5);
             fileNames.addAll(Arrays.asList("file1", "file2", "file3", "file4", "file5"));
             String failure = null;
-            String version = RemoteStoreShardShallowCopySnapshot.DEFAULT_VERSION;
-            long length = Math.max(0, Math.abs(randomLong()));
+            String version = "1";
+            PathType pathType = null;
+            PathHashAlgorithm pathHashAlgorithm = null;
             // random corruption
-            switch (randomIntBetween(0, 8)) {
+            switch (iter) {
                 case 0:
                     snapshot = null;
                     failure = "Invalid/Missing Snapshot Name";
@@ -170,6 +286,31 @@ public void testFromXContentInvalid() throws IOException {
                     failure = "Invalid Version Provided";
                     break;
                 case 8:
+                    version = "2";
+                    failure = "Invalid combination of pathType=null pathHashAlgorithm=null for version=2";
+                    break;
+                case 9:
+                    version = "1";
+                    pathType = PathType.FIXED;
+                    failure = "Invalid combination of pathType=FIXED pathHashAlgorithm=null for version=1";
+                    break;
+                case 10:
+                    version = "1";
+                    pathHashAlgorithm = PathHashAlgorithm.FNV_1A;
+                    failure = "Invalid combination of pathType=null pathHashAlgorithm=FNV_1A for version=1";
+                    break;
+                case 11:
+                    version = "2";
+                    pathType = PathType.FIXED;
+                    pathHashAlgorithm = PathHashAlgorithm.FNV_1A;
+                    failure = "Invalid combination of pathType=FIXED pathHashAlgorithm=FNV_1A for version=2";
+                    break;
+                case 12:
+                    version = "2";
+                    pathType = PathType.HASHED_PREFIX;
+                    pathHashAlgorithm = PathHashAlgorithm.FNV_1A;
+                    break;
+                case 13:
                     break;
                 default:
                     fail("shouldn't be here");
@@ -194,6 +335,14 @@ public void testFromXContentInvalid() throws IOException {
                 builder.value(fileName);
             }
             builder.endArray();
+            // We are handling NP check since a cluster can have indexes created earlier which do not have remote store
+            // path type and path hash algorithm in its custom data in index metadata.
+            if (Objects.nonNull(pathType)) {
+                builder.field(RemoteStoreShardShallowCopySnapshot.PATH_TYPE, pathType.getCode());
+            }
+            if (Objects.nonNull(pathHashAlgorithm)) {
+                builder.field(RemoteStoreShardShallowCopySnapshot.PATH_HASH_ALGORITHM, pathHashAlgorithm.getCode());
+            }
             builder.endObject();
             byte[] xContent = BytesReference.toBytes(BytesReference.bytes(builder));
 
@@ -211,7 +360,8 @@ public void testFromXContentInvalid() throws IOException {
                 assertEquals(remoteStoreShardShallowCopySnapshot.startTime(), startTime);
                 assertEquals(remoteStoreShardShallowCopySnapshot.time(), time);
                 assertEquals(remoteStoreShardShallowCopySnapshot.totalSize(), totalSize);
-                assertEquals(remoteStoreShardShallowCopySnapshot.totalFileCount(), totalFileCount);
+                assertEquals(remoteStoreShardShallowCopySnapshot.getPathType(), pathType);
+                assertEquals(remoteStoreShardShallowCopySnapshot.getPathHashAlgorithm(), pathHashAlgorithm);
             } else {
                 try (XContentParser parser = createParser(JsonXContent.jsonXContent, xContent)) {
                     parser.nextToken();
diff --git a/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryTests.java b/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryTests.java
index 59c8a9d92f07b..44ddd2de9d007 100644
--- a/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryTests.java
+++ b/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryTests.java
@@ -37,7 +37,9 @@
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.engine.NRTReplicationEngineFactory;
-import org.opensearch.index.remote.RemoteStorePathType;
+import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.index.remote.RemoteStoreUtils;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.shard.IndexShardTestCase;
@@ -702,16 +704,19 @@ public void testCleanupAsync() throws Exception {
         String repositoryName = "test-repository";
         String indexUUID = "test-idx-uuid";
         ShardId shardId = new ShardId(Index.UNKNOWN_INDEX_NAME, indexUUID, Integer.parseInt("0"));
-        RemoteStorePathType pathType = randomFrom(RemoteStorePathType.values());
+        RemoteStorePathStrategy pathStrategy = randomFrom(
+            new RemoteStorePathStrategy(PathType.FIXED),
+            new RemoteStorePathStrategy(PathType.HASHED_PREFIX, PathHashAlgorithm.FNV_1A)
+        );
 
         RemoteSegmentStoreDirectory.remoteDirectoryCleanup(
             remoteSegmentStoreDirectoryFactory,
             repositoryName,
             indexUUID,
             shardId,
-            pathType
+            pathStrategy
         );
-        verify(remoteSegmentStoreDirectoryFactory).newDirectory(repositoryName, indexUUID, shardId, pathType);
+        verify(remoteSegmentStoreDirectoryFactory).newDirectory(repositoryName, indexUUID, shardId, pathStrategy);
         verify(threadPool, times(0)).executor(ThreadPool.Names.REMOTE_PURGE);
         verify(remoteMetadataDirectory).delete();
         verify(remoteDataDirectory).delete();
diff --git a/server/src/test/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactoryTests.java b/server/src/test/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactoryTests.java
index 0fe5557737447..de3dfbdaa4778 100644
--- a/server/src/test/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactoryTests.java
+++ b/server/src/test/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactoryTests.java
@@ -11,7 +11,8 @@
 import org.opensearch.common.blobstore.BlobContainer;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.blobstore.BlobStore;
-import org.opensearch.index.remote.RemoteStorePathType;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
 import org.opensearch.test.OpenSearchTestCase;
@@ -49,7 +50,7 @@ public void testNewLockManager() throws IOException {
         String testRepository = "testRepository";
         String testIndexUUID = "testIndexUUID";
         String testShardId = "testShardId";
-        RemoteStorePathType pathType = RemoteStorePathType.FIXED;
+        RemoteStorePathStrategy pathStrategy = new RemoteStorePathStrategy(PathType.FIXED);
 
         BlobStoreRepository repository = mock(BlobStoreRepository.class);
         BlobStore blobStore = mock(BlobStore.class);
@@ -65,7 +66,7 @@ public void testNewLockManager() throws IOException {
             testRepository,
             testIndexUUID,
             testShardId,
-            pathType
+            pathStrategy
         );
 
         assertTrue(lockManager != null);
diff --git a/server/src/test/java/org/opensearch/index/translog/RemoteFsTranslogTests.java b/server/src/test/java/org/opensearch/index/translog/RemoteFsTranslogTests.java
index 9f72d3c7bd825..0e3854f65135f 100644
--- a/server/src/test/java/org/opensearch/index/translog/RemoteFsTranslogTests.java
+++ b/server/src/test/java/org/opensearch/index/translog/RemoteFsTranslogTests.java
@@ -50,6 +50,7 @@
 import org.opensearch.index.translog.transfer.TranslogTransferManager;
 import org.opensearch.index.translog.transfer.TranslogTransferMetadata;
 import org.opensearch.index.translog.transfer.TranslogUploadFailedException;
+import org.opensearch.indices.DefaultRemoteStoreSettings;
 import org.opensearch.indices.recovery.RecoverySettings;
 import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
@@ -99,7 +100,7 @@
 
 import static org.opensearch.common.util.BigArrays.NON_RECYCLING_INSTANCE;
 import static org.opensearch.index.IndexSettings.INDEX_REMOTE_TRANSLOG_KEEP_EXTRA_GEN_SETTING;
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataCategory.TRANSLOG;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataCategory.TRANSLOG;
 import static org.opensearch.index.translog.SnapshotMatchers.containsOperationsInAnyOrder;
 import static org.opensearch.index.translog.TranslogDeletionPolicies.createTranslogDeletionPolicy;
 import static org.hamcrest.Matchers.contains;
@@ -188,7 +189,8 @@ private RemoteFsTranslog create(Path path, BlobStoreRepository repository, Strin
             repository,
             threadPool,
             primaryMode::get,
-            new RemoteTranslogTransferTracker(shardId, 10)
+            new RemoteTranslogTransferTracker(shardId, 10),
+            DefaultRemoteStoreSettings.INSTANCE
         );
     }
 
@@ -459,7 +461,8 @@ public void testExtraGenToKeep() throws Exception {
                 repository,
                 threadPool,
                 () -> Boolean.TRUE,
-                new RemoteTranslogTransferTracker(shardId, 10)
+                new RemoteTranslogTransferTracker(shardId, 10),
+                DefaultRemoteStoreSettings.INSTANCE
             ) {
                 @Override
                 ChannelFactory getChannelFactory() {
@@ -1508,7 +1511,8 @@ public void testTranslogWriterCanFlushInAddOrReadCall() throws IOException {
                 repository,
                 threadPool,
                 () -> Boolean.TRUE,
-                new RemoteTranslogTransferTracker(shardId, 10)
+                new RemoteTranslogTransferTracker(shardId, 10),
+                DefaultRemoteStoreSettings.INSTANCE
             ) {
                 @Override
                 ChannelFactory getChannelFactory() {
@@ -1616,7 +1620,8 @@ public void force(boolean metaData) throws IOException {
                 repository,
                 threadPool,
                 () -> Boolean.TRUE,
-                new RemoteTranslogTransferTracker(shardId, 10)
+                new RemoteTranslogTransferTracker(shardId, 10),
+                DefaultRemoteStoreSettings.INSTANCE
             ) {
                 @Override
                 ChannelFactory getChannelFactory() {
diff --git a/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java b/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java
index a9502dc051428..81ae479d018b0 100644
--- a/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java
+++ b/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java
@@ -18,6 +18,7 @@
 import org.opensearch.common.blobstore.stream.write.WritePriority;
 import org.opensearch.common.blobstore.support.PlainBlobMetadata;
 import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
@@ -27,6 +28,8 @@
 import org.opensearch.index.translog.transfer.FileSnapshot.TransferFileSnapshot;
 import org.opensearch.index.translog.transfer.FileSnapshot.TranslogFileSnapshot;
 import org.opensearch.index.translog.transfer.listener.TranslogTransferListener;
+import org.opensearch.indices.DefaultRemoteStoreSettings;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -48,8 +51,8 @@
 
 import org.mockito.Mockito;
 
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataCategory.TRANSLOG;
-import static org.opensearch.index.remote.RemoteStoreDataEnums.DataType.METADATA;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataCategory.TRANSLOG;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataType.METADATA;
 import static org.opensearch.index.translog.transfer.TranslogTransferMetadata.METADATA_SEPARATOR;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyMap;
@@ -100,7 +103,8 @@ public void setUp() throws Exception {
             remoteBaseTransferPath.add(TRANSLOG.getName()),
             remoteBaseTransferPath.add(METADATA.getName()),
             tracker,
-            remoteTranslogTransferTracker
+            remoteTranslogTransferTracker,
+            DefaultRemoteStoreSettings.INSTANCE
         );
 
         delayForBlobDownload = 1;
@@ -165,7 +169,8 @@ public void onFailure(TransferFileSnapshot fileSnapshot, Exception e) {
             remoteBaseTransferPath.add(TRANSLOG.getName()),
             remoteBaseTransferPath.add(METADATA.getName()),
             fileTransferTracker,
-            remoteTranslogTransferTracker
+            remoteTranslogTransferTracker,
+            DefaultRemoteStoreSettings.INSTANCE
         );
 
         assertTrue(translogTransferManager.transferSnapshot(createTransferSnapshot(), new TranslogTransferListener() {
@@ -188,20 +193,36 @@ public void onUploadFailed(TransferSnapshot transferSnapshot, Exception ex) {
 
     public void testTransferSnapshotOnUploadTimeout() throws Exception {
         doAnswer(invocationOnMock -> {
-            Thread.sleep(31 * 1000);
+            Set<TransferFileSnapshot> transferFileSnapshots = invocationOnMock.getArgument(0);
+            ActionListener<TransferFileSnapshot> listener = invocationOnMock.getArgument(2);
+            Runnable runnable = () -> {
+                try {
+                    Thread.sleep(1000);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+                for (TransferFileSnapshot transferFileSnapshot : transferFileSnapshots) {
+                    listener.onResponse(transferFileSnapshot);
+                }
+            };
+            Thread t = new Thread(runnable);
+            t.start();
             return null;
         }).when(transferService).uploadBlobs(anySet(), anyMap(), any(ActionListener.class), any(WritePriority.class));
         FileTransferTracker fileTransferTracker = new FileTransferTracker(
             new ShardId("index", "indexUUid", 0),
             remoteTranslogTransferTracker
         );
+        RemoteStoreSettings remoteStoreSettings = mock(RemoteStoreSettings.class);
+        when(remoteStoreSettings.getClusterRemoteTranslogTransferTimeout()).thenReturn(new TimeValue(1));
         TranslogTransferManager translogTransferManager = new TranslogTransferManager(
             shardId,
             transferService,
             remoteBaseTransferPath.add(TRANSLOG.getName()),
             remoteBaseTransferPath.add(METADATA.getName()),
             fileTransferTracker,
-            remoteTranslogTransferTracker
+            remoteTranslogTransferTracker,
+            remoteStoreSettings
         );
         SetOnce<Exception> exception = new SetOnce<>();
         translogTransferManager.transferSnapshot(createTransferSnapshot(), new TranslogTransferListener() {
@@ -243,7 +264,8 @@ public void testTransferSnapshotOnThreadInterrupt() throws Exception {
             remoteBaseTransferPath.add(TRANSLOG.getName()),
             remoteBaseTransferPath.add(METADATA.getName()),
             fileTransferTracker,
-            remoteTranslogTransferTracker
+            remoteTranslogTransferTracker,
+            DefaultRemoteStoreSettings.INSTANCE
         );
         SetOnce<Exception> exception = new SetOnce<>();
 
@@ -336,14 +358,6 @@ public String toString() {
     }
 
     public void testReadMetadataNoFile() throws IOException {
-        TranslogTransferManager translogTransferManager = new TranslogTransferManager(
-            shardId,
-            transferService,
-            remoteBaseTransferPath.add(TRANSLOG.getName()),
-            remoteBaseTransferPath.add(METADATA.getName()),
-            null,
-            remoteTranslogTransferTracker
-        );
         doAnswer(invocation -> {
             LatchedActionListener<List<BlobMetadata>> latchedActionListener = invocation.getArgument(3);
             List<BlobMetadata> bmList = new LinkedList<>();
@@ -358,14 +372,6 @@ public void testReadMetadataNoFile() throws IOException {
 
     // This should happen most of the time -
     public void testReadMetadataFile() throws IOException {
-        TranslogTransferManager translogTransferManager = new TranslogTransferManager(
-            shardId,
-            transferService,
-            remoteBaseTransferPath.add(TRANSLOG.getName()),
-            remoteBaseTransferPath.add(METADATA.getName()),
-            null,
-            remoteTranslogTransferTracker
-        );
         TranslogTransferMetadata metadata1 = new TranslogTransferMetadata(1, 1, 1, 2);
         String mdFilename1 = metadata1.getFileName();
 
@@ -395,14 +401,6 @@ public void testReadMetadataFile() throws IOException {
     }
 
     public void testReadMetadataReadException() throws IOException {
-        TranslogTransferManager translogTransferManager = new TranslogTransferManager(
-            shardId,
-            transferService,
-            remoteBaseTransferPath.add(TRANSLOG.getName()),
-            remoteBaseTransferPath.add(METADATA.getName()),
-            null,
-            remoteTranslogTransferTracker
-        );
         TranslogTransferMetadata tm = new TranslogTransferMetadata(1, 1, 1, 2);
         String mdFilename = tm.getFileName();
 
@@ -432,15 +430,6 @@ public void testMetadataFileNameOrder() throws IOException {
     }
 
     public void testReadMetadataListException() throws IOException {
-        TranslogTransferManager translogTransferManager = new TranslogTransferManager(
-            shardId,
-            transferService,
-            remoteBaseTransferPath.add(TRANSLOG.getName()),
-            remoteBaseTransferPath.add(METADATA.getName()),
-            null,
-            remoteTranslogTransferTracker
-        );
-
         doAnswer(invocation -> {
             LatchedActionListener<List<BlobMetadata>> latchedActionListener = invocation.getArgument(3);
             latchedActionListener.onFailure(new IOException("Issue while listing"));
@@ -512,7 +501,8 @@ public void testDeleteTranslogSuccess() throws Exception {
             remoteBaseTransferPath.add(TRANSLOG.getName()),
             remoteBaseTransferPath.add(METADATA.getName()),
             tracker,
-            remoteTranslogTransferTracker
+            remoteTranslogTransferTracker,
+            DefaultRemoteStoreSettings.INSTANCE
         );
         String translogFile = "translog-19.tlog", checkpointFile = "translog-19.ckp";
         tracker.add(translogFile, true);
@@ -526,14 +516,6 @@ public void testDeleteTranslogSuccess() throws Exception {
     }
 
     public void testDeleteStaleTranslogMetadata() {
-        TranslogTransferManager translogTransferManager = new TranslogTransferManager(
-            shardId,
-            transferService,
-            remoteBaseTransferPath.add(TRANSLOG.getName()),
-            remoteBaseTransferPath.add(METADATA.getName()),
-            null,
-            remoteTranslogTransferTracker
-        );
         String tm1 = new TranslogTransferMetadata(1, 1, 1, 2).getFileName();
         String tm2 = new TranslogTransferMetadata(1, 2, 1, 2).getFileName();
         String tm3 = new TranslogTransferMetadata(2, 3, 1, 2).getFileName();
@@ -584,7 +566,8 @@ public void testDeleteTranslogFailure() throws Exception {
             remoteBaseTransferPath.add(TRANSLOG.getName()),
             remoteBaseTransferPath.add(METADATA.getName()),
             tracker,
-            remoteTranslogTransferTracker
+            remoteTranslogTransferTracker,
+            DefaultRemoteStoreSettings.INSTANCE
         );
         String translogFile = "translog-19.tlog", checkpointFile = "translog-19.ckp";
         tracker.add(translogFile, true);
@@ -622,14 +605,6 @@ public void testGetPrimaryTermAndGeneration() {
     }
 
     public void testMetadataConflict() throws InterruptedException {
-        TranslogTransferManager translogTransferManager = new TranslogTransferManager(
-            shardId,
-            transferService,
-            remoteBaseTransferPath.add(TRANSLOG.getName()),
-            remoteBaseTransferPath.add(METADATA.getName()),
-            null,
-            remoteTranslogTransferTracker
-        );
         TranslogTransferMetadata tm = new TranslogTransferMetadata(1, 1, 1, 2, "node--1");
         String mdFilename = tm.getFileName();
         long count = mdFilename.chars().filter(ch -> ch == METADATA_SEPARATOR.charAt(0)).count();
diff --git a/server/src/test/java/org/opensearch/indices/IndicesLifecycleListenerSingleNodeTests.java b/server/src/test/java/org/opensearch/indices/IndicesLifecycleListenerSingleNodeTests.java
index 0e16e81b1bb70..0428bdf0655b0 100644
--- a/server/src/test/java/org/opensearch/indices/IndicesLifecycleListenerSingleNodeTests.java
+++ b/server/src/test/java/org/opensearch/indices/IndicesLifecycleListenerSingleNodeTests.java
@@ -34,6 +34,7 @@
 import org.opensearch.Version;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.ShardRoutingHelper;
@@ -164,7 +165,8 @@ public void afterIndexRemoved(Index index, IndexSettings indexSettings, IndexRem
                 null,
                 null,
                 localNode,
-                null
+                null,
+                DiscoveryNodes.builder().add(localNode).build()
             );
             IndexShardTestCase.updateRoutingEntry(shard, newRouting);
             assertEquals(5, counter.get());
diff --git a/server/src/test/java/org/opensearch/indices/RemoteStoreSettingsDynamicUpdateTests.java b/server/src/test/java/org/opensearch/indices/RemoteStoreSettingsDynamicUpdateTests.java
index 3809a44e55901..8a77d97f88d67 100644
--- a/server/src/test/java/org/opensearch/indices/RemoteStoreSettingsDynamicUpdateTests.java
+++ b/server/src/test/java/org/opensearch/indices/RemoteStoreSettingsDynamicUpdateTests.java
@@ -10,8 +10,11 @@
 
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
 import org.opensearch.test.OpenSearchTestCase;
 
+import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_TRANSLOG_TRANSFER_TIMEOUT_SETTING;
+
 public class RemoteStoreSettingsDynamicUpdateTests extends OpenSearchTestCase {
     private final ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
     private final RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(Settings.EMPTY, clusterSettings);
@@ -66,4 +69,31 @@ public void testSegmentMetadataRetention() {
         );
         assertEquals(15, remoteStoreSettings.getMinRemoteSegmentMetadataFiles());
     }
+
+    public void testClusterRemoteTranslogTransferTimeout() {
+        // Test default value
+        assertEquals(TimeValue.timeValueSeconds(30), remoteStoreSettings.getClusterRemoteTranslogTransferTimeout());
+
+        // Test override with valid value
+        clusterSettings.applySettings(Settings.builder().put(CLUSTER_REMOTE_TRANSLOG_TRANSFER_TIMEOUT_SETTING.getKey(), "40s").build());
+        assertEquals(TimeValue.timeValueSeconds(40), remoteStoreSettings.getClusterRemoteTranslogTransferTimeout());
+
+        // Test override with value less than minimum
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> clusterSettings.applySettings(
+                Settings.builder().put(CLUSTER_REMOTE_TRANSLOG_TRANSFER_TIMEOUT_SETTING.getKey(), "10s").build()
+            )
+        );
+        assertEquals(TimeValue.timeValueSeconds(40), remoteStoreSettings.getClusterRemoteTranslogTransferTimeout());
+
+        // Test override with invalid time value
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> clusterSettings.applySettings(
+                Settings.builder().put(CLUSTER_REMOTE_TRANSLOG_TRANSFER_TIMEOUT_SETTING.getKey(), "123").build()
+            )
+        );
+        assertEquals(TimeValue.timeValueSeconds(40), remoteStoreSettings.getClusterRemoteTranslogTransferTimeout());
+    }
 }
diff --git a/server/src/test/java/org/opensearch/indices/cluster/AbstractIndicesClusterStateServiceTestCase.java b/server/src/test/java/org/opensearch/indices/cluster/AbstractIndicesClusterStateServiceTestCase.java
index c455101ff4549..0490228a5cc16 100644
--- a/server/src/test/java/org/opensearch/indices/cluster/AbstractIndicesClusterStateServiceTestCase.java
+++ b/server/src/test/java/org/opensearch/indices/cluster/AbstractIndicesClusterStateServiceTestCase.java
@@ -35,6 +35,7 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.RoutingNode;
 import org.opensearch.cluster.routing.ShardRouting;
@@ -264,7 +265,8 @@ public MockIndexShard createShard(
             final RetentionLeaseSyncer retentionLeaseSyncer,
             final DiscoveryNode targetNode,
             final DiscoveryNode sourceNode,
-            final RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory
+            final RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
+            final DiscoveryNodes discoveryNodes
         ) throws IOException {
             failRandomly();
             RecoveryState recoveryState = new RecoveryState(shardRouting, targetNode, sourceNode);
@@ -387,7 +389,8 @@ public void updateShardState(
             BiConsumer<IndexShard, ActionListener<ResyncTask>> primaryReplicaSyncer,
             long applyingClusterStateVersion,
             Set<String> inSyncAllocationIds,
-            IndexShardRoutingTable routingTable
+            IndexShardRoutingTable routingTable,
+            DiscoveryNodes discoveryNodes
         ) throws IOException {
             failRandomly();
             assertThat(this.shardId(), equalTo(shardRouting.shardId()));
diff --git a/server/src/test/java/org/opensearch/indices/recovery/PeerRecoverySourceServiceTests.java b/server/src/test/java/org/opensearch/indices/recovery/PeerRecoverySourceServiceTests.java
index 4fbae4b0d53ca..ded174fb98eef 100644
--- a/server/src/test/java/org/opensearch/indices/recovery/PeerRecoverySourceServiceTests.java
+++ b/server/src/test/java/org/opensearch/indices/recovery/PeerRecoverySourceServiceTests.java
@@ -38,6 +38,7 @@
 import org.opensearch.index.seqno.SequenceNumbers;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.shard.IndexShardTestCase;
+import org.opensearch.index.shard.IndexShardTestUtils;
 import org.opensearch.index.store.Store;
 import org.opensearch.indices.IndicesService;
 import org.opensearch.test.NodeRoles;
@@ -65,8 +66,8 @@ public void testDuplicateRecoveries() throws IOException {
         StartRecoveryRequest startRecoveryRequest = new StartRecoveryRequest(
             primary.shardId(),
             randomAlphaOfLength(10),
-            getFakeDiscoNode("source"),
-            getFakeDiscoNode("target"),
+            IndexShardTestUtils.getFakeDiscoNode("source"),
+            IndexShardTestUtils.getFakeDiscoNode("target"),
             Store.MetadataSnapshot.EMPTY,
             randomBoolean(),
             randomLong(),
diff --git a/server/src/test/java/org/opensearch/indices/recovery/PeerRecoveryTargetServiceTests.java b/server/src/test/java/org/opensearch/indices/recovery/PeerRecoveryTargetServiceTests.java
index 1e6cc43703672..a8e5a02011538 100644
--- a/server/src/test/java/org/opensearch/indices/recovery/PeerRecoveryTargetServiceTests.java
+++ b/server/src/test/java/org/opensearch/indices/recovery/PeerRecoveryTargetServiceTests.java
@@ -56,6 +56,7 @@
 import org.opensearch.index.seqno.SequenceNumbers;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.shard.IndexShardTestCase;
+import org.opensearch.index.shard.IndexShardTestUtils;
 import org.opensearch.index.store.Store;
 import org.opensearch.index.store.StoreFileMetadata;
 import org.opensearch.index.translog.Translog;
@@ -92,8 +93,8 @@ public void testWriteFileChunksConcurrently() throws Exception {
             mdFiles.add(md);
         }
         final IndexShard targetShard = newShard(false);
-        final DiscoveryNode pNode = getFakeDiscoNode(sourceShard.routingEntry().currentNodeId());
-        final DiscoveryNode rNode = getFakeDiscoNode(targetShard.routingEntry().currentNodeId());
+        final DiscoveryNode pNode = IndexShardTestUtils.getFakeDiscoNode(sourceShard.routingEntry().currentNodeId());
+        final DiscoveryNode rNode = IndexShardTestUtils.getFakeDiscoNode(targetShard.routingEntry().currentNodeId());
         targetShard.markAsRecovering("test-peer-recovery", new RecoveryState(targetShard.routingEntry(), rNode, pNode));
         final RecoveryTarget recoveryTarget = new RecoveryTarget(targetShard, null, null, threadPool);
         final PlainActionFuture<Void> receiveFileInfoFuture = new PlainActionFuture<>();
diff --git a/server/src/test/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointActionTests.java b/server/src/test/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointActionTests.java
index 2cf006176022d..352f827c74cb2 100644
--- a/server/src/test/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointActionTests.java
+++ b/server/src/test/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointActionTests.java
@@ -15,6 +15,7 @@
 import org.opensearch.action.support.replication.ReplicationMode;
 import org.opensearch.action.support.replication.TransportReplicationAction;
 import org.opensearch.cluster.action.shard.ShardStateAction;
+import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.io.IOUtils;
@@ -35,9 +36,12 @@
 import java.util.Collections;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import static org.opensearch.index.remote.RemoteStoreTestsHelper.createIndexSettings;
 import static org.opensearch.test.ClusterServiceUtils.createClusterService;
 import static org.hamcrest.Matchers.sameInstance;
+import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -128,7 +132,9 @@ public void testPublishCheckpointActionOnReplica() {
 
         final ShardId shardId = new ShardId(index, id);
         when(indexShard.shardId()).thenReturn(shardId);
-
+        when(indexShard.indexSettings()).thenReturn(
+            createIndexSettings(false, Settings.builder().put(IndexMetadata.INDEX_REPLICATION_TYPE_SETTING.getKey(), "SEGMENT").build())
+        );
         final SegmentReplicationTargetService mockTargetService = mock(SegmentReplicationTargetService.class);
 
         final PublishCheckpointAction action = new PublishCheckpointAction(
@@ -160,17 +166,46 @@ public void testPublishCheckpointActionOnReplica() {
 
     }
 
+    public void testPublishCheckpointActionOnDocrepReplicaDuringMigration() {
+        final IndicesService indicesService = mock(IndicesService.class);
+
+        final Index index = new Index("index", "uuid");
+        final IndexService indexService = mock(IndexService.class);
+        when(indicesService.indexServiceSafe(index)).thenReturn(indexService);
+        final int id = randomIntBetween(0, 4);
+        final IndexShard indexShard = mock(IndexShard.class);
+        when(indexService.getShard(id)).thenReturn(indexShard);
+
+        final ShardId shardId = new ShardId(index, id);
+        when(indexShard.shardId()).thenReturn(shardId);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(false));
+        final SegmentReplicationTargetService mockTargetService = mock(SegmentReplicationTargetService.class);
+
+        final PublishCheckpointAction action = new PublishCheckpointAction(
+            Settings.EMPTY,
+            transportService,
+            clusterService,
+            indicesService,
+            threadPool,
+            shardStateAction,
+            new ActionFilters(Collections.emptySet()),
+            mockTargetService
+        );
+        // no interaction with SegmentReplicationTargetService object
+        verify(mockTargetService, never()).onNewCheckpoint(any(), any());
+    }
+
     public void testGetReplicationModeWithRemoteTranslog() {
         final PublishCheckpointAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(true);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(true));
         assertEquals(ReplicationMode.FULL_REPLICATION, action.getReplicationMode(indexShard));
     }
 
     public void testGetReplicationModeWithLocalTranslog() {
         final PublishCheckpointAction action = createAction();
         final IndexShard indexShard = mock(IndexShard.class);
-        when(indexShard.isRemoteTranslogEnabled()).thenReturn(false);
+        when(indexShard.indexSettings()).thenReturn(createIndexSettings(false));
         assertEquals(ReplicationMode.FULL_REPLICATION, action.getReplicationMode(indexShard));
     }
 
diff --git a/server/src/test/java/org/opensearch/search/aggregations/bucket/terms/SignificantTextAggregatorTests.java b/server/src/test/java/org/opensearch/search/aggregations/bucket/terms/SignificantTextAggregatorTests.java
index e9b2d40fd4ede..644cee57bd5a4 100644
--- a/server/src/test/java/org/opensearch/search/aggregations/bucket/terms/SignificantTextAggregatorTests.java
+++ b/server/src/test/java/org/opensearch/search/aggregations/bucket/terms/SignificantTextAggregatorTests.java
@@ -50,6 +50,7 @@
 import org.opensearch.index.analysis.AnalyzerScope;
 import org.opensearch.index.analysis.NamedAnalyzer;
 import org.opensearch.index.mapper.BinaryFieldMapper;
+import org.opensearch.index.mapper.ConstantKeywordFieldMapper;
 import org.opensearch.index.mapper.FlatObjectFieldMapper;
 import org.opensearch.index.mapper.GeoPointFieldMapper;
 import org.opensearch.index.mapper.MappedFieldType;
@@ -104,7 +105,8 @@ protected List<String> unsupportedMappedFieldTypes() {
         return Arrays.asList(
             BinaryFieldMapper.CONTENT_TYPE, // binary fields are not supported because they do not have analyzers
             GeoPointFieldMapper.CONTENT_TYPE, // geopoint fields cannot use term queries
-            FlatObjectFieldMapper.CONTENT_TYPE // flat_object fields are not supported aggregations
+            FlatObjectFieldMapper.CONTENT_TYPE, // flat_object fields are not supported aggregations
+            ConstantKeywordFieldMapper.CONTENT_TYPE // binary fields are not supported because they do not have analyzers
         );
     }
 
diff --git a/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java b/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java
index e002297911788..0d171e17e70e1 100644
--- a/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java
+++ b/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java
@@ -275,11 +275,11 @@ public void testClosesChannelOnErrorInHandshakeWithIncompatibleVersion() throws
         // response so we must just close the connection on an error. To avoid the failure disappearing into a black hole we at least log
         // it.
 
-        try (MockLogAppender mockAppender = MockLogAppender.createForLoggers(LogManager.getLogger(InboundHandler.class))) {
+        try (MockLogAppender mockAppender = MockLogAppender.createForLoggers(LogManager.getLogger(NativeMessageHandler.class))) {
             mockAppender.addExpectation(
                 new MockLogAppender.SeenEventExpectation(
                     "expected message",
-                    InboundHandler.class.getCanonicalName(),
+                    NativeMessageHandler.class.getCanonicalName(),
                     Level.WARN,
                     "could not send error response to handshake"
                 )
@@ -308,11 +308,11 @@ public void testClosesChannelOnErrorInHandshakeWithIncompatibleVersion() throws
     }
 
     public void testLogsSlowInboundProcessing() throws Exception {
-        try (MockLogAppender mockAppender = MockLogAppender.createForLoggers(LogManager.getLogger(InboundHandler.class))) {
+        try (MockLogAppender mockAppender = MockLogAppender.createForLoggers(LogManager.getLogger(NativeMessageHandler.class))) {
             mockAppender.addExpectation(
                 new MockLogAppender.SeenEventExpectation(
                     "expected message",
-                    InboundHandler.class.getCanonicalName(),
+                    NativeMessageHandler.class.getCanonicalName(),
                     Level.WARN,
                     "handling inbound transport message "
                 )
diff --git a/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java b/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java
index ae4b537223394..2dfe8a0dd8590 100644
--- a/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java
+++ b/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java
@@ -72,24 +72,25 @@ public void testPipelineHandling() throws IOException {
         final List<Tuple<MessageData, Exception>> expected = new ArrayList<>();
         final List<Tuple<MessageData, Exception>> actual = new ArrayList<>();
         final List<ReleasableBytesReference> toRelease = new ArrayList<>();
-        final BiConsumer<TcpChannel, InboundMessage> messageHandler = (c, m) -> {
+        final BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler = (c, m) -> {
             try {
-                final Header header = m.getHeader();
+                InboundMessage message = (InboundMessage) m;
+                final Header header = message.getHeader();
                 final MessageData actualData;
                 final Version version = header.getVersion();
                 final boolean isRequest = header.isRequest();
                 final long requestId = header.getRequestId();
                 final boolean isCompressed = header.isCompressed();
-                if (m.isShortCircuit()) {
+                if (message.isShortCircuit()) {
                     actualData = new MessageData(version, requestId, isRequest, isCompressed, header.getActionName(), null);
                 } else if (isRequest) {
-                    final TestRequest request = new TestRequest(m.openOrGetStreamInput());
+                    final TestRequest request = new TestRequest(message.openOrGetStreamInput());
                     actualData = new MessageData(version, requestId, isRequest, isCompressed, header.getActionName(), request.value);
                 } else {
-                    final TestResponse response = new TestResponse(m.openOrGetStreamInput());
+                    final TestResponse response = new TestResponse(message.openOrGetStreamInput());
                     actualData = new MessageData(version, requestId, isRequest, isCompressed, null, response.value);
                 }
-                actual.add(new Tuple<>(actualData, m.getException()));
+                actual.add(new Tuple<>(actualData, message.getException()));
             } catch (IOException e) {
                 throw new AssertionError(e);
             }
@@ -214,7 +215,7 @@ public void testPipelineHandling() throws IOException {
     }
 
     public void testDecodeExceptionIsPropagated() throws IOException {
-        BiConsumer<TcpChannel, InboundMessage> messageHandler = (c, m) -> {};
+        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler = (c, m) -> {};
         final StatsTracker statsTracker = new StatsTracker();
         final LongSupplier millisSupplier = () -> TimeValue.nsecToMSec(System.nanoTime());
         final InboundDecoder decoder = new InboundDecoder(Version.CURRENT, PageCacheRecycler.NON_RECYCLING_INSTANCE);
@@ -268,7 +269,7 @@ public void testDecodeExceptionIsPropagated() throws IOException {
     }
 
     public void testEnsureBodyIsNotPrematurelyReleased() throws IOException {
-        BiConsumer<TcpChannel, InboundMessage> messageHandler = (c, m) -> {};
+        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler = (c, m) -> {};
         final StatsTracker statsTracker = new StatsTracker();
         final LongSupplier millisSupplier = () -> TimeValue.nsecToMSec(System.nanoTime());
         final InboundDecoder decoder = new InboundDecoder(Version.CURRENT, PageCacheRecycler.NON_RECYCLING_INSTANCE);
diff --git a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
index ff99435f765d8..36ba409a2de03 100644
--- a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
+++ b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
@@ -97,8 +97,9 @@ public void setUp() throws Exception {
         final InboundAggregator aggregator = new InboundAggregator(breaker, (Predicate<String>) action -> true);
         pipeline = new InboundPipeline(statsTracker, millisSupplier, decoder, aggregator, (c, m) -> {
             try (BytesStreamOutput streamOutput = new BytesStreamOutput()) {
-                Streams.copy(m.openOrGetStreamInput(), streamOutput);
-                message.set(new Tuple<>(m.getHeader(), streamOutput.bytes()));
+                InboundMessage m1 = (InboundMessage) m;
+                Streams.copy(m1.openOrGetStreamInput(), streamOutput);
+                message.set(new Tuple<>(m1.getHeader(), streamOutput.bytes()));
             } catch (IOException e) {
                 throw new AssertionError(e);
             }
diff --git a/test/framework/src/main/java/org/opensearch/index/engine/EngineTestCase.java b/test/framework/src/main/java/org/opensearch/index/engine/EngineTestCase.java
index 43289a7c89524..1cb5501810c5d 100644
--- a/test/framework/src/main/java/org/opensearch/index/engine/EngineTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/index/engine/EngineTestCase.java
@@ -898,7 +898,8 @@ public EngineConfig config(
                 update -> {},
                 () -> 0L,
                 (leases, listener) -> listener.onResponse(new ReplicationResponse()),
-                () -> SafeCommitInfo.EMPTY
+                () -> SafeCommitInfo.EMPTY,
+                sId -> false
             );
             globalCheckpointSupplier = replicationTracker;
             retentionLeasesSupplier = replicationTracker::getRetentionLeases;
diff --git a/test/framework/src/main/java/org/opensearch/index/mapper/MapperServiceTestCase.java b/test/framework/src/main/java/org/opensearch/index/mapper/MapperServiceTestCase.java
index a65ce3cbdd380..bd16e4f65e159 100644
--- a/test/framework/src/main/java/org/opensearch/index/mapper/MapperServiceTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/index/mapper/MapperServiceTestCase.java
@@ -225,13 +225,32 @@ protected final XContentBuilder mapping(CheckedConsumer<XContentBuilder, IOExcep
         return builder.endObject().endObject().endObject();
     }
 
+    protected final XContentBuilder derivedMapping(CheckedConsumer<XContentBuilder, IOException> buildFields) throws IOException {
+        XContentBuilder builder = XContentFactory.jsonBuilder().startObject().startObject("_doc").startObject("derived");
+        buildFields.accept(builder);
+        return builder.endObject().endObject().endObject();
+    }
+
     protected final XContentBuilder dynamicMapping(Mapping dynamicMapping) throws IOException {
         XContentBuilder builder = XContentFactory.jsonBuilder().startObject();
         dynamicMapping.toXContent(builder, ToXContent.EMPTY_PARAMS);
         return builder.endObject();
     }
 
-    protected final XContentBuilder fieldMapping(CheckedConsumer<XContentBuilder, IOException> buildField) throws IOException {
+    protected XContentBuilder fieldMapping(CheckedConsumer<XContentBuilder, IOException> buildField) throws IOException {
+        return fieldMapping(buildField, false);
+    }
+
+    protected final XContentBuilder fieldMapping(CheckedConsumer<XContentBuilder, IOException> buildField, Boolean isDerived)
+        throws IOException {
+        if (isDerived) {
+            return derivedMapping(b -> {
+                b.startObject("field");
+                buildField.accept(b);
+                b.endObject();
+            });
+        }
+
         return mapping(b -> {
             b.startObject("field");
             buildField.accept(b);
@@ -247,6 +266,9 @@ protected QueryShardContext createQueryShardContext(MapperService mapperService)
         when(queryShardContext.getSearchQuoteAnalyzer(any())).thenCallRealMethod();
         when(queryShardContext.getSearchAnalyzer(any())).thenCallRealMethod();
         when(queryShardContext.getIndexSettings()).thenReturn(mapperService.getIndexSettings());
+        when(queryShardContext.getObjectMapper(anyString())).thenAnswer(
+            inv -> mapperService.getObjectMapper(inv.getArguments()[0].toString())
+        );
         when(queryShardContext.simpleMatchToIndexNames(any())).thenAnswer(
             inv -> mapperService.simpleMatchToFullName(inv.getArguments()[0].toString())
         );
diff --git a/test/framework/src/main/java/org/opensearch/index/replication/OpenSearchIndexLevelReplicationTestCase.java b/test/framework/src/main/java/org/opensearch/index/replication/OpenSearchIndexLevelReplicationTestCase.java
index e6e20ce8f8566..a5dc13c334513 100644
--- a/test/framework/src/main/java/org/opensearch/index/replication/OpenSearchIndexLevelReplicationTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/index/replication/OpenSearchIndexLevelReplicationTestCase.java
@@ -64,6 +64,7 @@
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.AllocationId;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.RecoverySource;
@@ -96,6 +97,7 @@
 import org.opensearch.index.seqno.RetentionLeases;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.shard.IndexShardTestCase;
+import org.opensearch.index.shard.IndexShardTestUtils;
 import org.opensearch.index.shard.PrimaryReplicaSyncer;
 import org.opensearch.index.shard.ShardPath;
 import org.opensearch.index.translog.Translog;
@@ -340,6 +342,23 @@ public synchronized void startAll() throws IOException {
             startReplicas(replicas.size());
         }
 
+        public synchronized DiscoveryNodes generateFakeDiscoveryNodes() {
+            DiscoveryNodes.Builder builder = new DiscoveryNodes.Builder();
+            if (primary.indexSettings() != null && primary.indexSettings().isAssignedOnRemoteNode()) {
+                builder.add(IndexShardTestUtils.getFakeRemoteEnabledNode(primary.routingEntry().currentNodeId()));
+            } else {
+                builder.add(IndexShardTestUtils.getFakeDiscoNode(primary.routingEntry().currentNodeId()));
+            }
+            for (IndexShard replica : replicas) {
+                if (replica.indexSettings() != null && replica.indexSettings().isAssignedOnRemoteNode()) {
+                    builder.add(IndexShardTestUtils.getFakeRemoteEnabledNode(replica.routingEntry().currentNodeId()));
+                } else {
+                    builder.add(IndexShardTestUtils.getFakeDiscoNode(replica.routingEntry().currentNodeId()));
+                }
+            }
+            return builder.build();
+        }
+
         public synchronized int startReplicas(int numOfReplicasToStart) throws IOException {
             if (primary.routingEntry().initializing()) {
                 startPrimary();
@@ -371,7 +390,8 @@ public void startPrimary() throws IOException {
                 null,
                 currentClusterStateVersion.incrementAndGet(),
                 activeIds,
-                routingTable
+                routingTable,
+                generateFakeDiscoveryNodes()
             );
             for (final IndexShard replica : replicas) {
                 recoverReplica(replica);
@@ -492,7 +512,8 @@ public synchronized void promoteReplicaToPrimary(
                 primaryReplicaSyncer,
                 currentClusterStateVersion.incrementAndGet(),
                 activeIds(),
-                routingTable
+                routingTable,
+                generateFakeDiscoveryNodes()
             );
         }
 
@@ -638,14 +659,16 @@ public void syncGlobalCheckpoint() {
         }
 
         private void updateAllocationIDsOnPrimary() throws IOException {
-
             primary.updateShardState(
                 primary.routingEntry(),
                 primary.getPendingPrimaryTerm(),
                 null,
                 currentClusterStateVersion.incrementAndGet(),
                 activeIds(),
-                routingTable(Function.identity())
+                routingTable(Function.identity()),
+                primary.indexSettings().isRemoteTranslogStoreEnabled()
+                    ? IndexShardTestUtils.getFakeRemoteEnabledDiscoveryNodes(routingTable(Function.identity()).getShards())
+                    : IndexShardTestUtils.getFakeDiscoveryNodes(routingTable(Function.identity()).getShards())
             );
         }
 
diff --git a/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
index 9baa6110ab54e..38900ce51c3fa 100644
--- a/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
@@ -48,6 +48,7 @@
 import org.opensearch.cluster.metadata.RepositoryMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.cluster.routing.ShardRouting;
@@ -619,12 +620,14 @@ protected IndexShard newShard(
         IndexingOperationListener... listeners
     ) throws IOException {
         Settings nodeSettings = Settings.builder().put("node.name", routing.currentNodeId()).build();
+        DiscoveryNodes discoveryNodes = IndexShardTestUtils.getFakeDiscoveryNodes(routing);
         // To simulate that the node is remote backed
         if (indexMetadata.getSettings().get(IndexMetadata.SETTING_REMOTE_STORE_ENABLED) == "true") {
             nodeSettings = Settings.builder()
                 .put("node.name", routing.currentNodeId())
                 .put("node.attr.remote_store.translog.repository", "seg_repo")
                 .build();
+            discoveryNodes = DiscoveryNodes.builder().add(IndexShardTestUtils.getFakeRemoteEnabledNode(routing.currentNodeId())).build();
         }
         final IndexSettings indexSettings = new IndexSettings(indexMetadata, nodeSettings);
         final IndexShard indexShard;
@@ -654,7 +657,7 @@ protected IndexShard newShard(
             RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory = null;
             RepositoriesService mockRepoSvc = mock(RepositoriesService.class);
 
-            if (indexSettings.isRemoteStoreEnabled() || indexSettings.isRemoteNode()) {
+            if (indexSettings.isRemoteStoreEnabled() || indexSettings.isAssignedOnRemoteNode()) {
                 String remoteStoreRepository = indexSettings.getRemoteStoreRepository();
                 // remote path via setting a repository . This is a hack used for shards are created using reset .
                 // since we can't get remote path from IndexShard directly, we are using repository to store it .
@@ -679,7 +682,8 @@ protected IndexShard newShard(
                         () -> mockRepoSvc,
                         threadPool,
                         settings.getRemoteStoreTranslogRepository(),
-                        new RemoteTranslogTransferTracker(shardRouting.shardId(), 20)
+                        new RemoteTranslogTransferTracker(shardRouting.shardId(), 20),
+                        DefaultRemoteStoreSettings.INSTANCE
                     );
                 }
                 return new InternalTranslogFactory();
@@ -712,7 +716,8 @@ protected IndexShard newShard(
                 "dummy-node",
                 DefaultRecoverySettings.INSTANCE,
                 DefaultRemoteStoreSettings.INSTANCE,
-                false
+                false,
+                discoveryNodes
             );
             indexShard.addShardFailureCallback(DEFAULT_SHARD_FAILURE_HANDLER);
             if (remoteStoreStatsTrackerFactory != null) {
@@ -986,7 +991,7 @@ protected void closeShards(Iterable<IndexShard> shards) throws IOException {
     protected void recoverShardFromStore(IndexShard primary) throws IOException {
         primary.markAsRecovering(
             "store",
-            new RecoveryState(primary.routingEntry(), getFakeDiscoNode(primary.routingEntry().currentNodeId()), null)
+            new RecoveryState(primary.routingEntry(), IndexShardTestUtils.getFakeDiscoNode(primary.routingEntry().currentNodeId()), null)
         );
         recoverFromStore(primary);
         updateRoutingEntry(primary, ShardRoutingHelper.moveToStarted(primary.routingEntry()));
@@ -1003,7 +1008,19 @@ public static void updateRoutingEntry(IndexShard shard, ShardRouting shardRoutin
             null,
             currentClusterStateVersion.incrementAndGet(),
             inSyncIds,
-            newRoutingTable
+            newRoutingTable,
+            DiscoveryNodes.builder()
+                .add(
+                    new DiscoveryNode(
+                        shardRouting.currentNodeId(),
+                        shardRouting.currentNodeId(),
+                        buildNewFakeTransportAddress(),
+                        Collections.emptyMap(),
+                        DiscoveryNodeRole.BUILT_IN_ROLES,
+                        Version.CURRENT
+                    )
+                )
+                .build()
         );
     }
 
@@ -1017,17 +1034,6 @@ protected void recoveryEmptyReplica(IndexShard replica, boolean startReplica) th
         }
     }
 
-    protected DiscoveryNode getFakeDiscoNode(String id) {
-        return new DiscoveryNode(
-            id,
-            id,
-            buildNewFakeTransportAddress(),
-            Collections.emptyMap(),
-            DiscoveryNodeRole.BUILT_IN_ROLES,
-            Version.CURRENT
-        );
-    }
-
     protected void recoverReplica(IndexShard replica, IndexShard primary, boolean startReplica) throws IOException {
         recoverReplica(replica, primary, startReplica, getReplicationFunc(replica));
     }
@@ -1104,7 +1110,7 @@ protected void recoverReplica(
      * @param targetSupplier         supplies an instance of {@link RecoveryTarget}
      * @param markAsRecovering       set to {@code false} if the replica is marked as recovering
      */
-    protected final void recoverUnstartedReplica(
+    public final void recoverUnstartedReplica(
         final IndexShard replica,
         final IndexShard primary,
         final BiFunction<IndexShard, DiscoveryNode, RecoveryTarget> targetSupplier,
@@ -1113,8 +1119,18 @@ protected final void recoverUnstartedReplica(
         final IndexShardRoutingTable routingTable,
         final Function<List<IndexShard>, List<SegmentReplicationTarget>> replicatePrimaryFunction
     ) throws IOException {
-        final DiscoveryNode pNode = getFakeDiscoNode(primary.routingEntry().currentNodeId());
-        final DiscoveryNode rNode = getFakeDiscoNode(replica.routingEntry().currentNodeId());
+        final DiscoveryNode pNode;
+        final DiscoveryNode rNode;
+        if (primary.isRemoteTranslogEnabled()) {
+            pNode = IndexShardTestUtils.getFakeRemoteEnabledNode(primary.routingEntry().currentNodeId());
+        } else {
+            pNode = IndexShardTestUtils.getFakeDiscoNode(primary.routingEntry().currentNodeId());
+        }
+        if (replica.isRemoteTranslogEnabled()) {
+            rNode = IndexShardTestUtils.getFakeRemoteEnabledNode(replica.routingEntry().currentNodeId());
+        } else {
+            rNode = IndexShardTestUtils.getFakeDiscoNode(replica.routingEntry().currentNodeId());
+        }
         if (markAsRecovering) {
             replica.markAsRecovering("remote", new RecoveryState(replica.routingEntry(), pNode, rNode));
         } else {
@@ -1155,7 +1171,10 @@ protected final void recoverUnstartedReplica(
             null,
             currentClusterStateVersion.incrementAndGet(),
             inSyncIds,
-            routingTable
+            routingTable,
+            primary.isRemoteTranslogEnabled()
+                ? IndexShardTestUtils.getFakeRemoteEnabledDiscoveryNodes(routingTable.getShards())
+                : IndexShardTestUtils.getFakeDiscoveryNodes(routingTable.getShards())
         );
         try {
             PlainActionFuture<RecoveryResponse> future = new PlainActionFuture<>();
@@ -1189,7 +1208,10 @@ protected void startReplicaAfterRecovery(
             null,
             currentClusterStateVersion.incrementAndGet(),
             inSyncIdsWithReplica,
-            newRoutingTable
+            newRoutingTable,
+            primary.indexSettings.isRemoteTranslogStoreEnabled()
+                ? IndexShardTestUtils.getFakeRemoteEnabledDiscoveryNodes(routingTable.shards())
+                : IndexShardTestUtils.getFakeDiscoveryNodes(routingTable.shards())
         );
         replica.updateShardState(
             replica.routingEntry().moveToStarted(),
@@ -1197,7 +1219,10 @@ protected void startReplicaAfterRecovery(
             null,
             currentClusterStateVersion.get(),
             inSyncIdsWithReplica,
-            newRoutingTable
+            newRoutingTable,
+            replica.indexSettings.isRemoteTranslogStoreEnabled()
+                ? IndexShardTestUtils.getFakeRemoteEnabledDiscoveryNodes(routingTable.shards())
+                : IndexShardTestUtils.getFakeDiscoveryNodes(routingTable.shards())
         );
     }
 
@@ -1226,7 +1251,8 @@ protected void promoteReplica(IndexShard replica, Set<String> inSyncIds, IndexSh
             ),
             currentClusterStateVersion.incrementAndGet(),
             inSyncIds,
-            newRoutingTable
+            newRoutingTable,
+            IndexShardTestUtils.getFakeDiscoveryNodes(routingEntry)
         );
     }
 
@@ -1370,7 +1396,7 @@ protected void recoverShardFromSnapshot(final IndexShard shard, final Snapshot s
         final Version version = Version.CURRENT;
         final ShardId shardId = shard.shardId();
         final IndexId indexId = new IndexId(shardId.getIndex().getName(), shardId.getIndex().getUUID());
-        final DiscoveryNode node = getFakeDiscoNode(shard.routingEntry().currentNodeId());
+        final DiscoveryNode node = IndexShardTestUtils.getFakeDiscoNode(shard.routingEntry().currentNodeId());
         final RecoverySource.SnapshotRecoverySource recoverySource = new RecoverySource.SnapshotRecoverySource(
             UUIDs.randomBase64UUID(),
             snapshot,
@@ -1498,7 +1524,7 @@ private SegmentReplicationTargetService prepareForReplication(
 
         SegmentReplicationSourceFactory sourceFactory = null;
         SegmentReplicationTargetService targetService;
-        if (primaryShard.indexSettings.isRemoteStoreEnabled() || primaryShard.indexSettings.isRemoteNode()) {
+        if (primaryShard.indexSettings.isRemoteStoreEnabled() || primaryShard.indexSettings.isAssignedOnRemoteNode()) {
             RecoverySettings recoverySettings = new RecoverySettings(
                 Settings.EMPTY,
                 new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
diff --git a/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestUtils.java b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestUtils.java
new file mode 100644
index 0000000000000..d3a4a95c3bdef
--- /dev/null
+++ b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestUtils.java
@@ -0,0 +1,67 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.shard;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class IndexShardTestUtils {
+    public static DiscoveryNode getFakeDiscoNode(String id) {
+        return new DiscoveryNode(
+            id,
+            id,
+            IndexShardTestCase.buildNewFakeTransportAddress(),
+            Collections.emptyMap(),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+    }
+
+    public static DiscoveryNode getFakeRemoteEnabledNode(String id) {
+        Map<String, String> remoteNodeAttributes = new HashMap<String, String>();
+        remoteNodeAttributes.put(RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, "test-repo");
+        return new DiscoveryNode(
+            id,
+            id,
+            IndexShardTestCase.buildNewFakeTransportAddress(),
+            remoteNodeAttributes,
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+    }
+
+    public static DiscoveryNodes getFakeDiscoveryNodes(List<ShardRouting> shardRoutings) {
+        DiscoveryNodes.Builder builder = DiscoveryNodes.builder();
+        for (ShardRouting routing : shardRoutings) {
+            builder.add(getFakeDiscoNode(routing.currentNodeId()));
+        }
+        return builder.build();
+    }
+
+    public static DiscoveryNodes getFakeRemoteEnabledDiscoveryNodes(List<ShardRouting> shardRoutings) {
+        DiscoveryNodes.Builder builder = DiscoveryNodes.builder();
+        for (ShardRouting routing : shardRoutings) {
+            builder.add(getFakeRemoteEnabledNode(routing.currentNodeId()));
+        }
+        return builder.build();
+    }
+
+    public static DiscoveryNodes getFakeDiscoveryNodes(ShardRouting shardRouting) {
+        return DiscoveryNodes.builder().add(getFakeDiscoNode(shardRouting.currentNodeId())).build();
+    }
+}
diff --git a/test/framework/src/main/java/org/opensearch/script/MockScriptEngine.java b/test/framework/src/main/java/org/opensearch/script/MockScriptEngine.java
index 8c7e9718eb0cd..456b55883f91e 100644
--- a/test/framework/src/main/java/org/opensearch/script/MockScriptEngine.java
+++ b/test/framework/src/main/java/org/opensearch/script/MockScriptEngine.java
@@ -288,10 +288,10 @@ public double execute(Map<String, Object> params1, double[] values) {
                 ctx
             ) {
                 @Override
-                public Object execute() {
+                public void execute() {
                     Map<String, Object> vars = new HashMap<>(derivedFieldsParams);
                     vars.put("params", derivedFieldsParams);
-                    return script.apply(vars);
+                    script.apply(vars);
                 }
             };
             return context.factoryClazz.cast(factory);
diff --git a/test/framework/src/main/java/org/opensearch/search/aggregations/AggregatorTestCase.java b/test/framework/src/main/java/org/opensearch/search/aggregations/AggregatorTestCase.java
index 4eb49ebb42241..e538dede07fc8 100644
--- a/test/framework/src/main/java/org/opensearch/search/aggregations/AggregatorTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/search/aggregations/AggregatorTestCase.java
@@ -95,8 +95,10 @@
 import org.opensearch.index.fielddata.IndexFieldDataService;
 import org.opensearch.index.mapper.BinaryFieldMapper;
 import org.opensearch.index.mapper.CompletionFieldMapper;
+import org.opensearch.index.mapper.ConstantKeywordFieldMapper;
 import org.opensearch.index.mapper.ContentPath;
 import org.opensearch.index.mapper.DateFieldMapper;
+import org.opensearch.index.mapper.DerivedFieldMapper;
 import org.opensearch.index.mapper.FieldAliasMapper;
 import org.opensearch.index.mapper.FieldMapper;
 import org.opensearch.index.mapper.GeoPointFieldMapper;
@@ -198,6 +200,7 @@ public abstract class AggregatorTestCase extends OpenSearchTestCase {
         denylist.add(ObjectMapper.NESTED_CONTENT_TYPE); // TODO support for nested
         denylist.add(CompletionFieldMapper.CONTENT_TYPE); // TODO support completion
         denylist.add(FieldAliasMapper.CONTENT_TYPE); // TODO support alias
+        denylist.add(DerivedFieldMapper.CONTENT_TYPE); // TODO support derived fields
         TYPE_TEST_DENYLIST = denylist;
     }
 
@@ -778,6 +781,10 @@ public void testSupportedFieldTypes() throws IOException {
                 source.put("doc_values", "true");
             }
 
+            if (mappedType.getKey().equals(ConstantKeywordFieldMapper.CONTENT_TYPE) == true) {
+                source.put("value", "default_value");
+            }
+
             Mapper.Builder builder = mappedType.getValue().parse(fieldName, source, new MockParserContext());
             FieldMapper mapper = (FieldMapper) builder.build(new BuilderContext(settings, new ContentPath()));
 
diff --git a/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java b/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
index 664314245530e..f0f5576713042 100644
--- a/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
@@ -2538,7 +2538,7 @@ public static Settings buildRemoteStoreNodeAttributes(
         );
     }
 
-    public static Settings buildRemoteStoreNodeAttributes(
+    private static Settings buildRemoteStoreNodeAttributes(
         String segmentRepoName,
         Path segmentRepoPath,
         String segmentRepoType,