invokeNextSibling = () => {
			if (sSiblingPath !== undefined) {
				bRefreshNeeded = true;
				const sActionPath = sNonCanonicalChildPath + "/"
					+ this.oAggregation.$Actions.ChangeNextSiblingAction;
				const sSiblingPredicate = sSiblingPath?.slice(sSiblingPath.indexOf("("));
				oSiblingNode = this.aElements.$byPredicate[sSiblingPredicate];
				let oNextSibling = null;
				if (oSiblingNode) {
					// remove OOP for all descendants (incl. itself) of a next sibling
					this.oTreeState.deleteOutOfPlace(sSiblingPredicate);
					const oNextSiblingType = this.oAggregation.$fetchMetadata(
						_Helper.getMetaPath("/" + sActionPath + "/NextSibling/")
					).getResult();
					const aKeys = Object.keys(oNextSiblingType).filter((sKey) => sKey[0] !== "$");
					oNextSibling = aKeys.reduce((oKeys, sKey) => {
						oKeys[sKey] = oSiblingNode[sKey];
						return oKeys;
					}, {});
				}

				return this.oRequestor.request("POST", sActionPath, oGroupLock.getUnlockedCopy(), {
						"If-Match" : oChildNode,
						Prefer : "return=minimal"
					}, {NextSibling : oNextSibling});
			}
		}
Moves the (child) node with the given path to the parent node with the given path by sending
a PATCH request for "<parent navigation>@odata.bind". A <code>null</code> parent turns the
child into a root. The optional sibling path invokes an action for moving the (child) node
before the given sibling (or with <code>null</code> to the last sibling position) by sending
a POST request for the "ChangeNextSiblingAction". If the optional parameter
<code>bCopy</code> is set, it invokes an action for copying the (child) node by sending a
POST request for the "CopyAction".

@param {sap.ui.model.odata.v4.lib._GroupLock} oGroupLock
  A lock for the group to associate the requests with
@param {string} sChildPath
  The (child) node's path relative to the cache
@param {string|null} sParentPath
  The parent node's path relative to the cache
@param {string|null} [sSiblingPath]
  The next sibling's path relative to the cache
@param {string} [sNonCanonicalChildPath]
  The (child) node's non-canonical path (relative to the service); only used when
  <code>sSiblingPath</code> is given
@param {boolean} [bRequestSiblingRank]
  Whether to request the next sibling's rank and return its new index
@param {boolean} [bCopy]
  Whether the node should be copied instead of moved. The returned promise resolves with the
  index for the copied node.
@returns {{promise : sap.ui.base.SyncPromise<function():number|number[]>, refresh : boolean}}
  An object with two properties:
  - <code>promise</code>: A promise which is resolved when the move is finished, or rejected
    in case of an error. In case a refresh is needed, the promise is resolved with a function
    that can be called w/o args once the refresh is finished - it then returns an array with
    the new indices of the moved node (or <code>undefined</code>) and of the next sibling (if
    requested), and in case of copy a promise which resolves with the index of the copied
    node. Else it is resolved with an array of:
    - the number of child nodes added (normally one, but maybe more in case the parent node
      was collapsed before),
    - the new index of the moved node,
    - the number of descendant nodes that were affected by collapsing the moved node
      (<code>undefined</code> in case the moved node was not expanded before),
  - <code>refresh</code>: A flag indicating whether a side-effects refresh is needed

@public