class WireServer

Reads the partition corresponding to `configuration` and `asset` into a vmo and returns it.

The size field of the returned `Buffer` will be the size of just the asset, if it can be

determined. Otherwise, it will be the size of the entire partition.

The size and stream size of the vmo in the returned `Buffer` will always be the size of the

entire partition.

Writes partition corresponding to `configuration` and `asset` with data from `payload`.

`payload` may need to be resized to the partition size, so the provided vmo must have

been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with

`ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller

than the size of the partition being written.

Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.

Writes firmware data from `payload`.

`configuration` represents the A/B/R configuration. For platforms that do not support

firmware A/B/R, the parameter will be ignored by the underlying device-specific logic .

`type` is a device-specific string identifying the payload contents,

used to select the proper paving logic. For example, a device with

multiple bootloader stages might send them as separate calls to

`WriteFirmware()`, differentiated by `type`. An empty string

indicates the default type.

`payload` may need to be resized to the partition size, so the provided

vmo must have been created with `ZX_VMO_RESIZABLE` or must be a child

VMO that was created with `ZX_VMO_CHILD_RESIZABLE`.

Read firmware corresponding to `configuration` and `type`.

Parameter `configuration` and `type` are the same as WriteFirmware.

If ReadFirmware returns error, caller should assume that firmware image does not exist

or is in a bad state, or firmware read is not defined for the product.

Writes FVM with data from streamed via `payload`. This potentially affects all

configurations.

Write a raw volume image to the device. The image will be passed as it is to the device

partitioner backend to write. Therefore the format and write logic for the image is up to

the product to define. It differs from WriteVolume(), which is specifically for writing the

FVM sparse image, in that the paver will not perform any FVM related parsing or other

operation of the image. Thus it is not dependent on the volume driver version and less

susceptible to an outdated paver.

Returns ZX_ERR_NOT_SUPPORTED if the backend does not support opaque volume blobs.

Writes an image in the Android Sparse format. Identical in behaviour to

`WriteOpaqueVolume`, except the contents of `payload` are parsed as a sparse image and

unpacked before being written to disk.

Flush all previously buffered writes to persistent storage.

|bind_handler| returns a handler that binds incoming connections to this

server implementation.

The returned handler borrows the server instance.

The server must outlive the provided |dispatcher|. Only after

the dispatcher is shutdown will it be safe to destroy the servers.

The server should not be moved.