diff --git a/community/kernel-api/src/main/java/org/neo4j/internal/kernel/api/IndexCapability.java b/community/kernel-api/src/main/java/org/neo4j/internal/kernel/api/IndexCapability.java
index 1c5ddeb18a67b..0aa439aa84d9d 100644
--- a/community/kernel-api/src/main/java/org/neo4j/internal/kernel/api/IndexCapability.java
+++ b/community/kernel-api/src/main/java/org/neo4j/internal/kernel/api/IndexCapability.java
@@ -30,6 +30,9 @@
  */
 public interface IndexCapability
 {
+    IndexOrder[] ORDER_ASC = {IndexOrder.ASCENDING};
+    IndexOrder[] ORDER_NONE = new IndexOrder[0];
+
     /**
      * What possible orderings is this index capable to provide for a query on given combination of {@link ValueGroup}.
      * Ordering of ValueGroup correspond to ordering of related {@link IndexReference#properties()}.
@@ -56,12 +59,17 @@ public interface IndexCapability
      */
     IndexValueCapability valueCapability( ValueGroup... valueGroups );
 
+    default boolean singleWildcard( ValueGroup[] valueGroups )
+    {
+        return valueGroups.length == 1 && valueGroups[0] == ValueGroup.UNKNOWN;
+    }
+
     IndexCapability NO_CAPABILITY = new IndexCapability()
     {
         @Override
         public IndexOrder[] orderCapability( ValueGroup... valueGroups )
         {
-            return new IndexOrder[0];
+            return ORDER_NONE;
         }
 
         @Override
diff --git a/community/kernel-api/src/test/java/org/neo4j/internal/kernel/api/NodeValueIndexCursorTestBase.java b/community/kernel-api/src/test/java/org/neo4j/internal/kernel/api/NodeValueIndexCursorTestBase.java
index d9ac7e4559bb4..d8143654d2334 100644
--- a/community/kernel-api/src/test/java/org/neo4j/internal/kernel/api/NodeValueIndexCursorTestBase.java
+++ b/community/kernel-api/src/test/java/org/neo4j/internal/kernel/api/NodeValueIndexCursorTestBase.java
@@ -26,6 +26,9 @@
 import org.neo4j.graphdb.GraphDatabaseService;
 import org.neo4j.graphdb.Node;
 import org.neo4j.graphdb.Transaction;
+import org.neo4j.internal.kernel.api.exceptions.KernelException;
+import org.neo4j.values.storable.CoordinateReferenceSystem;
+import org.neo4j.values.storable.DateValue;
 import org.neo4j.values.storable.Value;
 import org.neo4j.values.storable.ValueGroup;
 import org.neo4j.values.storable.Values;
@@ -38,6 +41,10 @@
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.neo4j.graphdb.Label.label;
+import static org.neo4j.values.storable.CoordinateReferenceSystem.Cartesian;
+import static org.neo4j.values.storable.CoordinateReferenceSystem.Cartesian_3D;
+import static org.neo4j.values.storable.CoordinateReferenceSystem.WGS84;
+import static org.neo4j.values.storable.CoordinateReferenceSystem.WGS84_3D;
 import static org.neo4j.values.storable.Values.stringValue;
 
 public abstract class NodeValueIndexCursorTestBase<G extends KernelAPIReadTestSupport>
@@ -47,6 +54,7 @@ public abstract class NodeValueIndexCursorTestBase<G extends KernelAPIReadTestSu
     private static long boolTrue, num5, num6, num12a, num12b;
     private static long strOneNoLabel;
     private static long joeDalton, williamDalton, jackDalton, averellDalton;
+    private static long date891, date892, date86;
 
     @Override
     void createTestGraph( GraphDatabaseService graphDb )
@@ -101,6 +109,18 @@ void createTestGraph( GraphDatabaseService graphDb )
             williamDalton = person( graphDb, "William", "Dalton" );
             jackDalton = person( graphDb, "Jack", "Dalton" );
             averellDalton = person( graphDb, "Averell", "Dalton" );
+            nodeWithProp( graphDb, Values.pointValue( Cartesian, 1, 0 ) ); // Purposely mix order
+            nodeWithProp( graphDb, Values.pointValue( Cartesian, 0, 0 ) );
+            nodeWithProp( graphDb, Values.pointValue( Cartesian, 0, 0 ) );
+            nodeWithProp( graphDb, Values.pointValue( Cartesian, 0, 0 ) );
+            nodeWithProp( graphDb, Values.pointValue( Cartesian, 0, 1 ) );
+            nodeWithProp( graphDb, Values.pointValue( Cartesian_3D, 0, 0, 0 ) );
+            nodeWithProp( graphDb, Values.pointValue( WGS84, 0, 0 ) );
+            nodeWithProp( graphDb, Values.pointValue( WGS84_3D, 0, 0, 0 ) );
+            date891 = nodeWithProp( graphDb, DateValue.date( 1989, 3, 24 ) ); // Purposely mix order
+            date86 = nodeWithProp( graphDb, DateValue.date( 1986, 11, 18 ) );
+            date892 = nodeWithProp( graphDb, DateValue.date( 1989, 3, 24 ) );
+
             tx.success();
         }
     }
@@ -181,6 +201,44 @@ public void shouldPerformExactLookup() throws Exception
 
             // then
             assertFoundNodesAndNoValue( node, uniqueIds, boolTrue );
+
+            // when
+            valueCapability = index.valueCapability( ValueGroup.GEOMETRY );
+            read.nodeIndexSeek( index, node, IndexOrder.NONE, IndexQuery.exact( prop, Values.pointValue( Cartesian, 0, 0 ) ) );
+
+            // then
+            assertFoundNodesAndNoValue( node, 3, uniqueIds );
+
+            // when
+            read.nodeIndexSeek( index, node, IndexOrder.NONE, IndexQuery.exact( prop, Values.pointValue( Cartesian_3D, 0, 0, 0 ) ) );
+
+            // then
+            assertFoundNodesAndNoValue( node, 1, uniqueIds );
+
+            // when
+            read.nodeIndexSeek( index, node, IndexOrder.NONE, IndexQuery.exact( prop, Values.pointValue( WGS84, 0, 0 ) ) );
+
+            // then
+            assertFoundNodesAndNoValue( node, 1, uniqueIds );
+
+            // when
+            read.nodeIndexSeek( index, node, IndexOrder.NONE, IndexQuery.exact( prop, Values.pointValue( WGS84_3D, 0, 0, 0 ) ) );
+
+            // then
+            assertFoundNodesAndNoValue( node, 1, uniqueIds );
+
+            // when
+            valueCapability = index.valueCapability( ValueGroup.DATE );
+            read.nodeIndexSeek( index, node, IndexOrder.NONE, IndexQuery.exact( prop, DateValue.date( 1989, 3, 24 ) ) );
+
+            // then
+            assertFoundNodesAndNoValue( node, 2, uniqueIds );
+
+            // when
+            read.nodeIndexSeek( index, node, IndexOrder.NONE, IndexQuery.exact( prop, DateValue.date( 1986, 11, 18 ) ) );
+
+            // then
+            assertFoundNodesAndNoValue( node, 1, uniqueIds );
         }
     }
 
@@ -349,6 +407,84 @@ public void shouldPerformNumericRangeSearch() throws Exception
         }
     }
 
+    @Test
+    public void shouldPerformTemporalRangeSearch() throws KernelException
+    {
+        // given
+        int label = token.nodeLabel( "Node" );
+        int prop = token.propertyKey( "prop" );
+        CapableIndexReference index = schemaRead.index( label, prop );
+        IndexValueCapability temporalCapability = index.valueCapability( ValueGroup.DATE );
+        try ( NodeValueIndexCursor node = cursors.allocateNodeValueIndexCursor();
+              PrimitiveLongSet uniqueIds = Primitive.longSet() )
+        {
+            // when
+            read.nodeIndexSeek( index, node, IndexOrder.NONE,
+                    IndexQuery.range( prop, DateValue.date( 1986, 11, 18 ), true, DateValue.date( 1989, 3, 24 ), true ) );
+
+            // then
+            assertFoundNodesAndValue( node, uniqueIds, temporalCapability, date86, date891, date892 );
+
+            // when
+            read.nodeIndexSeek( index, node, IndexOrder.NONE,
+                    IndexQuery.range( prop, DateValue.date( 1986, 11, 18 ), true, DateValue.date( 1989, 3, 24 ), false ) );
+
+            // then
+            assertFoundNodesAndValue( node, uniqueIds, temporalCapability, date86 );
+
+            // when
+            read.nodeIndexSeek( index, node, IndexOrder.NONE,
+                    IndexQuery.range( prop, DateValue.date( 1986, 11, 18 ), false, DateValue.date( 1989, 3, 24 ), true ) );
+
+            // then
+            assertFoundNodesAndValue( node, uniqueIds, temporalCapability, date891, date892 );
+
+            // when
+            read.nodeIndexSeek( index, node, IndexOrder.NONE,
+                    IndexQuery.range( prop, DateValue.date( 1986, 11, 18 ), false, DateValue.date( 1989, 3, 24 ), false ) );
+
+            // then
+            assertFoundNodesAndValue( node, uniqueIds, temporalCapability );
+        }
+    }
+
+    @Test
+    public void shouldPerformSpatialRangeSearch() throws KernelException
+    {
+        // given
+        int label = token.nodeLabel( "Node" );
+        int prop = token.propertyKey( "prop" );
+        CapableIndexReference index = schemaRead.index( label, prop );
+        IndexValueCapability spatialCapability = index.valueCapability( ValueGroup.GEOMETRY );
+        try ( NodeValueIndexCursor node = cursors.allocateNodeValueIndexCursor();
+              PrimitiveLongSet uniqueIds = Primitive.longSet() )
+        {
+            // when
+            read.nodeIndexSeek( index, node, IndexOrder.NONE, IndexQuery.range( prop, Cartesian ) );
+
+            // then
+            assertFoundNodesAndValue( node, 5, uniqueIds, spatialCapability );
+
+            // when
+            read.nodeIndexSeek( index, node, IndexOrder.NONE, IndexQuery.range( prop, Cartesian_3D ) );
+
+            // then
+            assertFoundNodesAndValue( node, 1, uniqueIds, spatialCapability );
+
+            // when
+            read.nodeIndexSeek( index, node, IndexOrder.NONE, IndexQuery.range( prop, WGS84 ) );
+
+            // then
+            assertFoundNodesAndValue( node, 1, uniqueIds, spatialCapability );
+
+            // when
+            read.nodeIndexSeek( index, node, IndexOrder.NONE, IndexQuery.range( prop, WGS84_3D ) );
+
+            // then
+            assertFoundNodesAndValue( node, 1, uniqueIds, spatialCapability );
+        }
+    }
+
     @Test
     public void shouldPerformIndexScan() throws Exception
     {
@@ -365,7 +501,7 @@ public void shouldPerformIndexScan() throws Exception
 
             // then
             assertThat( node.numberOfProperties(), equalTo( 1 ) );
-            assertFoundNodesAndValue( node, 24, uniqueIds, wildcardCapability );
+            assertFoundNodesAndValue( node, 35, uniqueIds, wildcardCapability );
         }
     }
 
@@ -411,6 +547,49 @@ public void shouldRespectOrderCapabilitiesForStrings() throws Exception
         }
     }
 
+    @Test
+    public void shouldRespectOrderCapabilitiesForTemporal() throws KernelException
+    {
+        // given
+        int label = token.nodeLabel( "Node" );
+        int prop = token.propertyKey( "prop" );
+        CapableIndexReference index = schemaRead.index( label, prop );
+        IndexOrder[] orderCapabilities = index.orderCapability( ValueGroup.DATE );
+        try ( NodeValueIndexCursor node = cursors.allocateNodeValueIndexCursor() )
+        {
+            for ( IndexOrder orderCapability : orderCapabilities )
+            {
+                // when
+                read.nodeIndexSeek( index, node, orderCapability,
+                        IndexQuery.range( prop, DateValue.date( 1986, 11, 18 ), true, DateValue.date( 1989, 3, 24 ), true ) );
+
+                // then
+                assertFoundNodesInOrder( node, orderCapability );
+            }
+        }
+    }
+
+    @Test
+    public void shouldRespectOrderCapabilitiesForSpatial() throws KernelException
+    {
+        // given
+        int label = token.nodeLabel( "Node" );
+        int prop = token.propertyKey( "prop" );
+        CapableIndexReference index = schemaRead.index( label, prop );
+        IndexOrder[] orderCapabilities = index.orderCapability( ValueGroup.GEOMETRY );
+        try ( NodeValueIndexCursor node = cursors.allocateNodeValueIndexCursor() )
+        {
+            for ( IndexOrder orderCapability : orderCapabilities )
+            {
+                // when
+                read.nodeIndexSeek( index, node, orderCapability, IndexQuery.range( prop, CoordinateReferenceSystem.Cartesian ) );
+
+                // then
+                assertFoundNodesInOrder( node, orderCapability );
+            }
+        }
+    }
+
     @Test
     public void shouldRespectOrderCapabilitiesForWildcard() throws Exception
     {
@@ -593,12 +772,12 @@ public void shouldNotFindDeletedNodeInIndexScan() throws Exception
             // when
             tx.dataRead().nodeIndexScan( index, node, IndexOrder.NONE );
             assertThat( node.numberOfProperties(), equalTo( 1 ) );
-            assertFoundNodesAndValue( node, 24, uniqueIds, wildcardCapability );
+            assertFoundNodesAndValue( node, 35, uniqueIds, wildcardCapability );
 
             // then
             tx.dataWrite().nodeDelete( strOne );
             tx.dataRead().nodeIndexScan( index, node, IndexOrder.NONE );
-            assertFoundNodesAndValue( node, 23, uniqueIds, wildcardCapability );
+            assertFoundNodesAndValue( node, 34, uniqueIds, wildcardCapability );
         }
     }
 
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/NumberIndexProvider.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/NumberIndexProvider.java
index 4fcd76c242ebc..752be4adf84c4 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/NumberIndexProvider.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/NumberIndexProvider.java
@@ -99,17 +99,14 @@ public IndexCapability getCapability( SchemaIndexDescriptor schemaIndexDescripto
      */
     private static class NumberIndexCapability implements IndexCapability
     {
-        private static final IndexOrder[] SUPPORTED_ORDER = {IndexOrder.ASCENDING};
-        private static final IndexOrder[] EMPTY_ORDER = new IndexOrder[0];
-
         @Override
         public IndexOrder[] orderCapability( ValueGroup... valueGroups )
         {
             if ( support( valueGroups ) )
             {
-                return SUPPORTED_ORDER;
+                return ORDER_ASC;
             }
-            return EMPTY_ORDER;
+            return ORDER_NONE;
         }
 
         @Override
@@ -126,11 +123,6 @@ public IndexValueCapability valueCapability( ValueGroup... valueGroups )
             return IndexValueCapability.NO;
         }
 
-        private boolean singleWildcard( ValueGroup[] valueGroups )
-        {
-            return valueGroups.length == 1 && valueGroups[0] == ValueGroup.UNKNOWN;
-        }
-
         private boolean support( ValueGroup[] valueGroups )
         {
             return valueGroups.length == 1 && valueGroups[0] == ValueGroup.NUMBER;
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/SpatialIndexPartReader.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/SpatialIndexPartReader.java
index 7faa8685e709f..0e02d2bd0d10b 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/SpatialIndexPartReader.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/SpatialIndexPartReader.java
@@ -66,12 +66,7 @@ void validateQuery( IndexOrder indexOrder, IndexQuery[] predicates )
             throw new UnsupportedOperationException( "Spatial index doesn't handle composite queries" );
         }
 
-        if ( indexOrder != IndexOrder.NONE )
-        {
-            throw new UnsupportedOperationException(
-                    format( "Tried to query index with unsupported order %s. Supported orders for query %s are %s.", indexOrder, Arrays.toString( predicates ),
-                            IndexOrder.NONE ) );
-        }
+        CapabilityValidator.validateQuery( SpatialIndexProvider.CAPABILITY, indexOrder, predicates );
     }
 
     @Override
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/SpatialIndexProvider.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/SpatialIndexProvider.java
index b6c1102d27102..a10eb5b8a469f 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/SpatialIndexProvider.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/SpatialIndexProvider.java
@@ -28,6 +28,8 @@
 import org.neo4j.index.internal.gbptree.MetadataMismatchException;
 import org.neo4j.index.internal.gbptree.RecoveryCleanupWorkCollector;
 import org.neo4j.internal.kernel.api.IndexCapability;
+import org.neo4j.internal.kernel.api.IndexOrder;
+import org.neo4j.internal.kernel.api.IndexValueCapability;
 import org.neo4j.internal.kernel.api.InternalIndexState;
 import org.neo4j.io.fs.FileSystemAbstraction;
 import org.neo4j.io.pagecache.PageCache;
@@ -41,10 +43,12 @@
 import org.neo4j.kernel.impl.index.schema.config.SpaceFillingCurveSettingsFactory;
 import org.neo4j.kernel.impl.index.schema.config.SpatialIndexSettings;
 import org.neo4j.kernel.impl.storemigration.StoreMigrationParticipant;
+import org.neo4j.values.storable.ValueGroup;
 
 public class SpatialIndexProvider extends IndexProvider
 {
     public static final String KEY = "spatial";
+    static final IndexCapability CAPABILITY = new SpatialIndexCapability();
     private static final Descriptor SPATIAL_PROVIDER_DESCRIPTOR = new Descriptor( KEY, "1.0" );
 
     private final PageCache pageCache;
@@ -162,7 +166,7 @@ public InternalIndexState getInitialState( long indexId, SchemaIndexDescriptor d
     @Override
     public IndexCapability getCapability( SchemaIndexDescriptor indexDescriptor )
     {
-        return IndexCapability.NO_CAPABILITY;
+        return CAPABILITY;
     }
 
     @Override
@@ -172,4 +176,24 @@ public StoreMigrationParticipant storeMigrationParticipant( FileSystemAbstractio
         // Migration should happen in the combined layer for the time being.
         return StoreMigrationParticipant.NOT_PARTICIPATING;
     }
+
+    /**
+     * For single property spatial queries capabilities are
+     * Order: NONE (can not provide results in ordering)
+     * Value: NO (can not provide exact value)
+     */
+    private static class SpatialIndexCapability implements IndexCapability
+    {
+        @Override
+        public IndexOrder[] orderCapability( ValueGroup... valueGroups )
+        {
+            return ORDER_NONE;
+        }
+
+        @Override
+        public IndexValueCapability valueCapability( ValueGroup... valueGroups )
+        {
+            return IndexValueCapability.NO;
+        }
+    }
 }
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/StringIndexProvider.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/StringIndexProvider.java
index cfd1c88451c95..9689f5a8fb43a 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/StringIndexProvider.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/StringIndexProvider.java
@@ -90,17 +90,14 @@ public IndexCapability getCapability( SchemaIndexDescriptor schemaIndexDescripto
      */
     private static class StringIndexCapability implements IndexCapability
     {
-        private static final IndexOrder[] SUPPORTED_ORDER = {IndexOrder.ASCENDING};
-        private static final IndexOrder[] EMPTY_ORDER = new IndexOrder[0];
-
         @Override
         public IndexOrder[] orderCapability( ValueGroup... valueGroups )
         {
             if ( support( valueGroups ) )
             {
-                return SUPPORTED_ORDER;
+                return ORDER_ASC;
             }
-            return EMPTY_ORDER;
+            return ORDER_NONE;
         }
 
         @Override
@@ -117,11 +114,6 @@ public IndexValueCapability valueCapability( ValueGroup... valueGroups )
             return IndexValueCapability.NO;
         }
 
-        private boolean singleWildcard( ValueGroup[] valueGroups )
-        {
-            return valueGroups.length == 1 && valueGroups[0] == ValueGroup.UNKNOWN;
-        }
-
         private boolean support( ValueGroup[] valueGroups )
         {
             return valueGroups.length == 1 && valueGroups[0] == ValueGroup.TEXT;
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/TemporalIndexPartReader.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/TemporalIndexPartReader.java
index f942b7ea8cfb1..fad588d49232e 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/TemporalIndexPartReader.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/TemporalIndexPartReader.java
@@ -21,7 +21,6 @@
 
 import org.neo4j.index.internal.gbptree.GBPTree;
 import org.neo4j.index.internal.gbptree.Layout;
-import org.neo4j.internal.kernel.api.IndexCapability;
 import org.neo4j.internal.kernel.api.IndexOrder;
 import org.neo4j.internal.kernel.api.IndexQuery;
 import org.neo4j.kernel.api.schema.index.SchemaIndexDescriptor;
@@ -47,7 +46,7 @@ protected void validateQuery( IndexOrder indexOrder, IndexQuery[] predicates )
             throw new UnsupportedOperationException();
         }
 
-        CapabilityValidator.validateQuery( IndexCapability.NO_CAPABILITY, indexOrder, predicates );
+        CapabilityValidator.validateQuery( TemporalIndexProvider.CAPABILITY, indexOrder, predicates );
     }
 
     @Override
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/TemporalIndexProvider.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/TemporalIndexProvider.java
index 46d7fc5a9a70b..7f499fe051d3a 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/TemporalIndexProvider.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/TemporalIndexProvider.java
@@ -24,6 +24,8 @@
 import org.neo4j.index.internal.gbptree.MetadataMismatchException;
 import org.neo4j.index.internal.gbptree.RecoveryCleanupWorkCollector;
 import org.neo4j.internal.kernel.api.IndexCapability;
+import org.neo4j.internal.kernel.api.IndexOrder;
+import org.neo4j.internal.kernel.api.IndexValueCapability;
 import org.neo4j.internal.kernel.api.InternalIndexState;
 import org.neo4j.io.fs.FileSystemAbstraction;
 import org.neo4j.io.pagecache.PageCache;
@@ -34,11 +36,13 @@
 import org.neo4j.kernel.api.schema.index.SchemaIndexDescriptor;
 import org.neo4j.kernel.impl.api.index.sampling.IndexSamplingConfig;
 import org.neo4j.kernel.impl.storemigration.StoreMigrationParticipant;
+import org.neo4j.values.storable.ValueGroup;
 
 public class TemporalIndexProvider extends IndexProvider
 {
     public static final String KEY = "temporal";
-    public static final Descriptor TEMPORAL_PROVIDER_DESCRIPTOR = new Descriptor( KEY, "1.0" );
+    static final IndexCapability CAPABILITY = new TemporalIndexCapability();
+    private static final Descriptor TEMPORAL_PROVIDER_DESCRIPTOR = new Descriptor( KEY, "1.0" );
 
     private final PageCache pageCache;
     private final FileSystemAbstraction fs;
@@ -130,7 +134,7 @@ public InternalIndexState getInitialState( long indexId, SchemaIndexDescriptor d
     @Override
     public IndexCapability getCapability( SchemaIndexDescriptor schemaIndexDescriptor )
     {
-        return IndexCapability.NO_CAPABILITY;
+        return CAPABILITY;
     }
 
     @Override
@@ -140,4 +144,49 @@ public StoreMigrationParticipant storeMigrationParticipant( FileSystemAbstractio
         // Migration should happen in the combined layer for the time being.
         return StoreMigrationParticipant.NOT_PARTICIPATING;
     }
+
+    /**
+     * For single property temporal queries capabilities are
+     * Order: ASCENDING
+     * Value: YES (can provide exact value)
+     *
+     * For other queries there is no support
+     */
+    private static class TemporalIndexCapability implements IndexCapability
+    {
+        @Override
+        public IndexOrder[] orderCapability( ValueGroup... valueGroups )
+        {
+            if ( support( valueGroups ) )
+            {
+                return ORDER_ASC;
+            }
+            return ORDER_NONE;
+        }
+
+        @Override
+        public IndexValueCapability valueCapability( ValueGroup... valueGroups )
+        {
+            if ( support( valueGroups ) )
+            {
+                return IndexValueCapability.YES;
+            }
+            if ( singleWildcard( valueGroups ) )
+            {
+                return IndexValueCapability.PARTIAL;
+            }
+            return IndexValueCapability.NO;
+        }
+
+        private boolean support( ValueGroup[] valueGroups )
+        {
+            return valueGroups.length == 1 &&
+                    (valueGroups[0] == ValueGroup.DATE ||
+                     valueGroups[0] == ValueGroup.DURATION ||
+                     valueGroups[0] == ValueGroup.LOCAL_DATE_TIME ||
+                     valueGroups[0] == ValueGroup.LOCAL_TIME ||
+                     valueGroups[0] == ValueGroup.ZONED_DATE_TIME ||
+                     valueGroups[0] == ValueGroup.ZONED_TIME );
+        }
+    }
 }
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/TemporalIndexReader.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/TemporalIndexReader.java
index cbdf1b0a1b9cb..3691d243bbd3d 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/TemporalIndexReader.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/TemporalIndexReader.java
@@ -21,10 +21,8 @@
 
 import java.io.IOException;
 
-import org.neo4j.collection.primitive.PrimitiveLongResourceCollections;
 import org.neo4j.collection.primitive.PrimitiveLongResourceIterator;
 import org.neo4j.graphdb.Resource;
-import org.neo4j.helpers.collection.Iterables;
 import org.neo4j.helpers.collection.Iterators;
 import org.neo4j.internal.kernel.api.IndexOrder;
 import org.neo4j.internal.kernel.api.IndexQuery;
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/DefaultNodeValueIndexCursor.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/DefaultNodeValueIndexCursor.java
index 0bd8503329eea..c615c371d862d 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/DefaultNodeValueIndexCursor.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/DefaultNodeValueIndexCursor.java
@@ -237,7 +237,9 @@ private void prefixQuery( SchemaIndexDescriptor descriptor, IndexQuery.StringPre
     private void rangeQuery( SchemaIndexDescriptor descriptor, IndexQuery.RangePredicate predicate )
     {
         ValueGroup valueGroup = predicate.valueGroup();
-        this.needsValues = valueGroup == ValueGroup.TEXT || valueGroup == ValueGroup.NUMBER;
+        this.needsValues = valueGroup == ValueGroup.TEXT || valueGroup == ValueGroup.NUMBER ||
+                valueGroup == ValueGroup.DATE || valueGroup == ValueGroup.LOCAL_DATE_TIME || valueGroup == ValueGroup.ZONED_DATE_TIME ||
+                valueGroup == ValueGroup.DURATION || valueGroup == ValueGroup.LOCAL_TIME || valueGroup == ValueGroup.ZONED_TIME;
         if ( read.hasTxStateWithChanges() )
         {
             TransactionState txState = read.txState();