Specifies the bytes to be in the order of most significant byte first.


BIG_ENDIAN

string

Colon (:) will be use as the field separator.


COLON

Comma (,) will be used as the field separator.


COMMA

Field separator will be "," and the record separator will be a new line.


Represents the record separator of the CSV file.


CSV_RECORD_SEPARATOR

The default value is the format specified by the CSVChannel. Precedence will be given to the field separator and record separator.


DEFAULT

Default encoding for the abstract read/write APIs.


DEFAULT_ENCODING

Represents the colon separator, which should be used to identify colon-separated files.


FS_COLON

Specifies the byte order to be the least significant byte first.


LITTLE_ENDIAN

Represents the minimum number of headers, which will be included in the CSV.


MINIMUM_HEADER_COUNT

NEW_LINE

stderr

stdout

Tab (/t) will be use as the field separator.


Field separator will be a tab and the record separator will be a new line.


The `BlockStream` is used to initialize a stream of type `Block`. This `BlockStream` refers to the stream that is embedded to
the I/O byte channels.


Initialize a `BlockStream` using an `io:ReadableByteChannel`.



init

The `io:ReadableByteChannel` that this block stream is referred to


readableByteChannel

ReadableByteChannel

blockSize

The next function reads and returns the next block of the related stream.



close

`()` when the closing was successful or an `io:Error`


Error

BlockStream

The `io:CSVStream` is used to initialize a stream of type CSV records. This `io:CSVStream` refers to the stream
that is embedded to the I/O record channels.


Initialize a `CSVStream` using an `io:ReadableTextRecordChannel`.



The `io:ReadableTextRecordChannel` that this CSV stream is referred to


readableTextRecordChannel

ReadableTextRecordChannel

The next function reads and returns the next CSV record of the related stream.



A CSV record as a string array when a record is avaliable in the stream or
`()` when the stream reaches the end


Close the stream. The primary usage of this function is to close the stream without reaching the end.
If the stream reaches the end, the `CSVStream.next()` will automatically close the stream.



CSVStream

The `io:LineStream` is used to initialize a stream of the type strings(lines). This `io:LineStream` refers to the
stream that is embedded to the I/O character channels.


Initialize an `io:LineStream` using an `io:ReadableCharacterChannel`.



The `io:ReadableCharacterChannel` that the line stream is referred to


readableCharacterChannel

ReadableCharacterChannel

The next function reads and returns the next line of the related stream.



A line as a string when a line is avaliable in the stream or returns `()` when the stream reaches the end


Closes the stream. The primary usage of this function is to close the stream without reaching the end
If the stream reaches the end, the `LineStream.next()` will automatically close the stream.



LineStream

ReadableByteChannel represents an input resource (i.e file), which could be used to source bytes.
A file path or an in-memory `byte` array can be used to obtain an `io:ReadableByteChannel`.
An `io:ReadableByteChannel` does not support initialization, and it should be obtained using the following methods or implemented natively.

`io:openReadableFile("./files/sample.txt")` - used to obtain an `io:ReadableByteChannel` from a given file path
`io:createReadableChannel(byteArray)` - used to obtain an `io:ReadableByteChannel` from a given `byte` array


Source bytes from a given input resource.
This operation will be asynchronous in which the total number of required bytes might not be returned at a given
time. An `io:EofError` will return once the channel reaches the end.
```ballerina
byte[]|io:Error result = readableByteChannel.read(1000);
```



read

A positive integer. Represents the number of bytes, which should be read


nBytes

Content (the number of bytes) read, an `EofError` once the channel reaches the end or else an `io:Error`


Read all content of the channel as a `byte` array and return a read only `byte` array.
```ballerina
byte[]|io:Error result = readableByteChannel.readAll();
```



readAll

A read-only `byte` array or else an `io:Error`


Return a block stream that can be used to read all `byte` blocks as a stream.
```ballerina
stream<io:Block, io:Error>|io:Error result = readableByteChannel.blockStream();
```


blockStream

Encodes a given `io:ReadableByteChannel` using the Base64 encoding scheme.
```ballerina
io:ReadableByteChannel|Error encodedChannel = readableByteChannel.base64Encode();
```



base64Encode

An encoded `io:ReadableByteChannel` or else an `io:Error`


Decodes a given Base64 encoded `io:ReadableByteChannel`.
```ballerina
io:ReadableByteChannel|Error encodedChannel = readableByteChannel.base64Decode();
```



base64Decode

A decoded `io:ReadableByteChannel` or else an `io:Error`


Closes the `io:ReadableByteChannel`.
After a channel is closed, any further reading operations will cause an error.
```ballerina
io:Error? err = readableByteChannel.close();
```



`()` or else an `io:Error` if any error occurred


Represents a channel, which could be used to read characters through a given ReadableByteChannel.


Constructs an `io:ReadableCharacterChannel` from a given `io:ReadableByteChannel` and `Charset`.



The `io:ReadableByteChannel`, which would be used to read the characters


byteChannel

The character set, which is used to encode/decode the given bytes to characters


charset

Reads a given number of characters. This will attempt to read up to the `numberOfChars` characters of the channel.
An `io:EofError` will return once the channel reaches the end.
```ballerina
string|io:Error result = readableCharChannel.read(1000);
```



Number of characters, which should be read


numberOfChars

The characters that read as a string, an `io:EofError` once the channel reaches the end, or else an
`io:Error` if something went wrong while reading


Read the entire channel content as a string.
```ballerina
string|io:Error content = readableCharChannel.readString();
```


readString

The content that read as a string or an `io:Error`


Read the entire channel content as a list of lines.
```ballerina
string[]|io:Error content = readableCharChannel.readAllLines();
```


readAllLines

The content that read as an array of lines (separated by the `\n` character) or an `io:Error`


Reads a JSON from the given channel.
```ballerina
json|io:Error result = readableCharChannel.readJson();
```



readJson

The content that is read as a JSON or else an `io:Error`


Reads an XML from the given channel.
```ballerina
json|io:Error result = readableCharChannel.readXml();
```



readXml

The content that is read as an XML or else an `io:Error`


Reads a property from a .properties file with a default value.
```ballerina
string|io:Error result = readableCharChannel.readProperty(key, defaultValue);
```


readProperty

The property key, which needs to be read


defaultValue

The property value related to the given key or else an `io:Error`


Return a stream of lines that can be used to read all the lines in a file as a stream.
```ballerina
stream<string, io:Error>|io:Error? result = readableCharChannel.lineStream();
```



lineStream

A stream of strings (lines) or an `io:Error`


Reads all properties from a .properties file.
```ballerina
map<string>|io:Error result = readableCharChannel.readAllProperties();
```



readAllProperties

A map of strings that contains all properties


Closes the character channel.
After a channel is closed, any further reading operations will cause an error.
```ballerina
io:Error? err = readableCharChannel.close();
```



Represents a ReadableCSVChannel which could be used to read records from CSV file.


Constructs a CSV channel from a CharacterChannel to read CSV records.



The CharacterChannel, which will represent the content in the CSV file


Field separator, which will separate between the records in the CSV file


Separator

Number of headers, which should be skipped prior to reading records


nHeaders

Skips the given number of headers.
```ballerina
readableCSVChannel.skipHeaders(5);
```



skipHeaders

The number of headers, which should be skipped


Indicates whether there's another record, which could be read.
```ballerina
boolean hasNext = readableCSVChannel.hasNext();
```



hasNext

boolean

Gets the next record from the CSV file.
```ballerina
string[]|io:Error? record = readableCSVChannel.getNext();
```



getNext

List of fields in the CSV or else an `io:Error`


Returns a CSV record stream that can be used to CSV records as a stream.
```ballerina
stream<string[], io:Error>|io:Error? record = readableCSVChannel.csvStream();
```



csvStream

A stream of records(string[]) or else an `io:Error`


Closes the `io:ReadableCSVChannel`.
After a channel is closed, any further reading operations will cause an error.
```ballerina
io:Error? err = readableCSVChannel.close();
```



Returns a table, which corresponds to the CSV records.
```ballerina
var tblResult1 = readableCSVChannel.getTable(Employee);
var tblResult2 = readableCSVChannel.getTable(Employee, ["id", "name"]);
```



getTable

The object in which the CSV records should be deserialized


structType

The names of the fields used as the (composite) key of the table


fieldNames

Table, which represents the CSV records or else an `io:Error`
# Deprecated
This function is deprecated due to the introduction of `ReadableCSVChannel.toTable()`, making 'fieldNames' a mandatory parameter


Returns a table, which corresponds to the CSV records.
```ballerina
var tblResult = readableCSVChannel.toTable(Employee, ["id", "name"]);
```



toTable

keyFieldNames

Table, which represents the CSV records or else an `io:Error`


ReadableCSVChannel

Represents a data channel for reading data.


The channel, which would represent the source to read/write data


bOrder

ByteOrder

Reads a 16 bit integer.
```ballerina
int|io:Error result = dataChannel.readInt16();
```



readInt16

The value of the integer, which is read or else an `io:Error` if any error occurred


Reads a 32 bit integer.
```ballerina
int|io:Error result = dataChannel.readInt32();
```



readInt32

Reads a 64 bit integer.
```ballerina
int|io:Error result = dataChannel.readInt64();
```



readInt64

Reads a 32 bit float.
```ballerina
float|io:Error result = dataChannel.readFloat32();
```



readFloat32

The value of the float which is read or else `io:Error` if any error occurred


Reads a 64 bit float.
```ballerina
float|io:Error result = dataChannel.readFloat64();
```



readFloat64

Reads a byte and convert its value to boolean.
```ballerina
boolean|io:Error result = dataChannel.readBool();
```



readBool

Boolean value, which is read or else `io:Error` if any error occurred


Reads the string value represented through the provided number of bytes.
```ballerina
string|io:Error string = dataChannel.readString(10, "UTF-8");
```



Specifies the number of bytes, which represents the string


Specifies the char-set encoding of the string


encoding

The value of the string or else `io:Error` if any error occurred


Reads a variable length integer.
```ballerina
int|io:Error result = dataChannel.readVarInt();
```



readVarInt

The value of the integer which is read or else `io:Error` if any error occurred


Closes the data channel.
After a channel is closed, any further reading operations will cause an error.
```ballerina
io:Error? err = dataChannel.close();
```


ReadableDataChannel

Represents a channel which will allow to read.


Constructs a ReadableTextRecordChannel from a given ReadableCharacterChannel.



CharacterChannel which will point to the input/output resource


charChannel

Record separator (this could be a regex)


Checks whether there is a record left to be read.
```ballerina
boolean hasNext = readableRecChannel.hasNext();
```



True if there is a record left to be read


Get the next record from the input/output resource.
```ballerina
string[]|io:Error record = readableRecChannel.getNext();
```



Set of fields included in the record or else `io:Error`


Closes the record channel.
After a channel is closed, any further reading operations will cause an error.
```ballerina
io:Error err = readableRecChannel.close();
```



Represents a reader which will wrap string content as a channel.


content

Encoding of the characters of the content


Reads string as JSON using the reader.
```ballerina
io:StringReader reader = new("{\"name\": \"Alice\"}");
json|io:Error? person = reader.readJson();
```



JSON or else an `io:Error` if any error occurred


Reads a string as XML using the reader.
```ballerina
io:StringReader reader = new("<Person><Name>Alice</Name></Person>");
xml|io:Error? person = reader.readXml();
```



XML or else an `io:Error` if any error occurred


Reads the characters from the given string.
```ballerina
io:StringReader reader = new("Some text");
string|io:Error? person = reader.readChar(4);
```



readChar

nCharacters

String or else an `io:Error` if any error occurred


Closes the string reader.
```ballerina
io:Error? err = reader.close();
```



StringReader

WritableByteChannel represents an output resource (i.e file) which could be used to sink bytes
A file path can be used to obtain an `io:WritableByteChannel`.
An `io:WritableByteChannel` can only be obtained using the following method or by providing a native implementation.
It cannot be instantiated.
`io:openWritableFile("./files/sample.txt")` - used to obtain an `io:WritableByteChannel` from a given file path


Sinks bytes from a given input/output resource.

This is an asynchronous operation. The method might return before writing all the content.
```ballerina
int|io:Error result = writableByteChannel.write(record, 0);
```



write

Offset of the provided content, which needs to be kept when writing bytes


offset

Number of bytes written or else an `io:Error`


WritableByteChannel

## Overview

This module provides file read/write APIs and console print/read APIs. The file APIs allow read and write operations on different kinds of file types such as bytes, text, CSV, JSON, and XML. Further, these file APIs can be categorized as streaming and non-streaming APIs.

The file I/O operations can be categorized further based on the serialization and deserialization types such as:
- Bytes I/O
- Strings I/O
- CSV I/O
- JSON I/O
- XML I/O

### Console I/O
The console I/O APIs, which help you to read from the console as well as write to the console are as follows.
- `io:print`
- `io:println`
- `io:readln`

### Bytes I/O
The bytes I/O APIs provide the reading and writing APIs in both streaming and non-streaming ways. Those APIs are,
- `io:fileReadBytes`
- `io:fileReadBlocksAsStream`
- `io:fileWriteBytes`
- `io:fileWriteBlocksFromStream`

### Strings I/O
The strings I/O APIs provide the reading and writing APIs in 3 different ways:
1. Read the complete file content as a string and write a given string to a file
2. Read the complete file content as a set of lines and write a given set of lines to a file
3. Read the complete file content as a stream of lines and write a given stream of lines to a file

The strings I/O APIs are as follows:
- `io:fileReadString`
- `io:fileReadLines`
- `io:fileReadLinesAsStream`
- `io:fileWriteLines`
- `io:fileWriteLinesFromStream`

### CSV I/O
The CSV I/O APIs provide the reading and writing APIs in both streaming and non-streaming ways. Those APIs are:
- `io:fileReadCsv`
- `io:fileReadCsvAsStream`
- `io:fileWriteCsv`
- `io:fileWriteCsvFromStream`

### JSON I/O
The JSON I/O APIs provide the reading and writing APIs for JSON content. Those APIs are:
- `io:fileReadJson`
- `io:fileWriteJson`

### XML I/O
The XML I/O APIs provide the reading and writing APIs for XML content. Those APIs are:
- `io:fileReadXml`
- `io:fileWriteXml`


This module provides file read/write APIs and console print/read APIs. The file APIs allow read and write operations on different kinds of file types such as bytes, text, CSV, JSON, and XML. Further, these file APIs can be categorized as streaming and non-streaming APIs.


Constants