{ObjectOpts{Name: "c1test", VersionID: "vid", DeleteMarker: true, SSEC: true, OpType: DeleteReplicationType}, cfgs[0], true}, // 7. permanent delete of version

            throw new EsAccessException("Failed to insert " + id, e);
        }
    }

    protected <T> void insertAll(final List<T> list, final OpType opType) {
        insertAll(list, opType, false);
    }

    protected <T> void insertAll(final List<T> list, final OpType opType, final boolean ignoreAlreadyExists) {
        final List<T> bufferedList = new ArrayList<>(bulkBufferSize);

	case replication.Pending:
		if ri.OpType.IsDataReplication() && prevStatus != status {
			rs.set(ri.Arn, ri.Size, 0, status, ri.OpType, ri.endpoint, ri.secure, ri.Err)
		}
	case replication.Completed:
		if ri.OpType.IsDataReplication() {
			rs.set(ri.Arn, ri.Size, ri.Duration, status, ri.OpType, ri.endpoint, ri.secure, ri.Err)
		}
	case replication.Failed:
		if ri.OpType.IsDataReplication() && prevStatus == replication.Pending {

      break;
    case OpType::kUnaryOp:
      quantization_attributes = {"quantization"};
      break;
    case OpType::kBinaryOp:
      quantization_attributes = {"lhs_quantization", "rhs_quantization",
                                 "output_quantization"};
      break;
    case OpType::kQuantizationOp:
      quantization_attributes = {"input_quantization", "output_quantization"};
      break;
    default:

using ops::ResizeBilinear;
using ops::ResizeNearestNeighbor;
using ops::ScaleAndTranslate;

class ImageGradTest : public ::testing::Test {
 protected:
  ImageGradTest() : scope_(Scope::NewRootScope()) {}

  enum OpType { RESIZE_NEAREST, RESIZE_BILINEAR, RESIZE_BICUBIC };

  template <typename T>
  Tensor MakeData(const TensorShape& data_shape) {
    DataType data_type = DataTypeToEnum<T>::v();
    Tensor data(data_type, data_shape);

				// exported non-type (const, var, func)
				if r := find(obj, o.Type(), append(path, opType), nil); r != nil {
					return Path(r), nil
				}
			}
			continue
		}

		// Inspect declared methods of defined types.
		if T, ok := aliases.Unalias(o.Type()).(*types.Named); ok {
			path = append(path, opType)
			// The method index here is always with respect
			// to the underlying go/types data structures,

        insert(urlQueue);
    }

    @Override
    public void insert(final EsUrlQueue urlQueue) {
        try {
            super.insert(urlQueue, urlQueue.getId() == null ? OpType.CREATE : OpType.INDEX);
        } catch (final EsAccessException e) {
            final Throwable cause = e.getCause();
            if (cause != null && "VersionConflictEngineException".equals(cause.getClass().getSimpleName())) {

FailureOr<SmallVector<int32_t>> CastI64ArrayToI32(
    ArrayRef<int64_t> int64_array);

// Returns the first operation with the given type in the function.
template <typename OpType>
OpType FindOperationOfType(func::FuncOp function) {
  for (auto op : function.getBody().getOps<OpType>()) {
    return op;
  }
  return nullptr;
}

// Returns the first user of the given operation, optionally of the given

      "CompileTimeConstantOperand should have at least one operand index.");

  using OpType = OpT;

  // Returns the indices of operands that should be compile time constants.
  static constexpr std::array<int, sizeof...(OperandIdx)> OperandIndices() {
    return {OperandIdx...};
  }
};

// Finds all op of type `T::OpType` `func_op` and recursively duplicates

  builder.insert(new_result);
}

template <typename OpType>
LogicalResult FindAndExcludeOp(func::FuncOp func,
                               const StringAttr& replication_attr,
                               llvm::SetVector<Operation*>& merged_set,
                               OpType& found_op) {
  // Find the TPUReplicationMetadata or TPUCompilationResult ops which will be