function searchSorted_(sortedSequence, values, side = "left") {
    const $sortedSequence = (0, _tensorUtilEnv.convertToTensor)(sortedSequence, "sortedSequence", "searchSorted");
    const $values = (0, _tensorUtilEnv.convertToTensor)(values, "values", "searchSorted");
    const sequenceSize = $sortedSequence.shape[$sortedSequence.shape.length - 1];
    const valuesSize = $values.shape[$values.shape.length - 1];
    const $sortedSequence2D = (0, _reshape.reshape)($sortedSequence, [
        -1,
        sequenceSize
    ]);
    const $values2D = (0, _reshape.reshape)($values, [
        -1,
        valuesSize
    ]);
    if ($sortedSequence2D.rank < 2) throw new Error(`Sorted input argument must be at least 2-dimensional`);
    if ($sortedSequence2D.shape[0] !== $values2D.shape[0]) throw new Error(`Leading dimension of 'sortedSequence' and 'values' must match.`);
    if ((0, _utilBase.sizeFromShape)($values2D.shape) >= INT32_MAX) throw new Error(`values tensor size must less than ${INT32_MAX}`);
    if ($sortedSequence2D.shape[1] >= INT32_MAX) throw new Error(`trailing dim_size must less than ${INT32_MAX} for int32 output type, was ${$sortedSequence2D.shape[1]}`);
    const inputs = {
        sortedSequence: $sortedSequence2D,
        values: $values2D
    };
    const attrs = {
        side
    };
    return (0, _engine.ENGINE).runKernel((0, _kernelNames.SearchSorted), inputs, attrs);
}
Searches for where a value would go in a sorted sequence.

This is not a method for checking containment (like javascript in).

The typical use case for this operation is "binning", "bucketing", or
"discretizing". The values are assigned to bucket-indices based on the edges
listed in 'sortedSequence'. This operation returns the bucket-index for each
value.

The side argument controls which index is returned if a value lands exactly
on an edge.

The axis is not settable for this operation. It always operates on the
innermost dimension (axis=-1). The operation will accept any number of outer
dimensions.

Note: This operation assumes that 'sortedSequence' is sorted along the
innermost axis, maybe using 'sort(..., axis=-1)'. If the sequence is not
sorted no error is raised and the content of the returned tensor is not well
defined.

```js
const edges = tf.tensor1d([-1, 3.3, 9.1, 10.0]);
let values = tf.tensor1d([0.0, 4.1, 12.0]);
const result1 = tf.searchSorted(edges, values, 'left');
result1.print(); // [1, 2, 4]

const seq = tf.tensor1d([0, 3, 9, 10, 10]);
values = tf.tensor1d([0, 4, 10]);
const result2 = tf.searchSorted(seq, values, 'left');
result2.print(); // [0, 2, 3]
const result3 = tf.searchSorted(seq, values, 'right');
result3.print(); // [1, 2, 5]

const sortedSequence = tf.tensor2d([[0., 3., 8., 9., 10.],
                                    [1., 2., 3., 4., 5.]]);
values = tf.tensor2d([[9.8, 2.1, 4.3],
                      [0.1, 6.6, 4.5, ]]);
const result4 = tf.searchSorted(sortedSequence, values, 'left');
result4.print(); // [[4, 1, 2], [0, 5, 4]]
```
@param sortedSequence: N-D. Sorted sequence.
@param values: N-D. Search values.
@param side: 'left'|'right'. Defaults to 'left'. 'left' corresponds to lower
    bound and 'right' to upper bound.
@return An N-D int32 tensor the size of values containing the result of
    applying either lower bound or upper bound (depending on side) to each
    value. The result is not a global index to the entire Tensor, but the
    index in the last dimension.
@doc {heading: 'Operations', subheading: 'Evaluation'}