<!--
  ~ Licensed to the Apache Software Foundation (ASF) under one
  ~ or more contributor license agreements.  See the NOTICE file
  ~ distributed with this work for additional information
  ~ regarding copyright ownership.  The ASF 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.
  -->

<html>
<h2>Built-in I/Os</h2>
<p>
  Beam SDKs provide many out of the box I/O transforms that can be used to read from many
  different sources and write to many different sinks.
</p>
<p>
  See the <a href="https://beam.apache.org/documentation/io/built-in/">Beam-provided I/O
  Transforms</a> page for a list of the currently available I/O transforms.
</p>
<p>
  <b>Note:</b> There is no kata for this task. Please click the "Check" button and
  proceed to the next task.
</p>
</html>
