src/tests/fidl/compatibility/compatibility_service.test.fidl

// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
library fidl.test.compatibility;

using fidl.test.imported as imp;
using zx;

type this_is_a_struct = struct {
    s string;
};

type this_is_an_empty_struct = struct {};

type this_is_a_union = strict union {
    1: s string;
    2: b bool;
};

type this_is_a_table = table {
    1: s string;
};

type this_is_a_xunion = flexible union {
    1: s string;
    2: b bool;
};

type primitive_types = struct {
    b bool;
    i8 int8;
    i16 int16;
    i32 int32;
    i64 int64;
    u8 uint8;
    u16 uint16;
    u32 uint32;
    u64 uint64;
    f32 float32;
    f64 float64;
};

type default_values = struct {
    @allow_deprecated_struct_defaults
    b1 bool = true;
    @allow_deprecated_struct_defaults
    b2 bool = false;
    @allow_deprecated_struct_defaults
    i8 int8 = -23;
    @allow_deprecated_struct_defaults
    i16 int16 = 34;
    @allow_deprecated_struct_defaults
    i32 int32 = -34595;
    @allow_deprecated_struct_defaults
    i64 int64 = 3948038;
    @allow_deprecated_struct_defaults
    u8 uint8 = 0;
    @allow_deprecated_struct_defaults
    u16 uint16 = 348;
    @allow_deprecated_struct_defaults
    u32 uint32 = 9038;
    @allow_deprecated_struct_defaults
    u64 uint64 = 19835;
    @allow_deprecated_struct_defaults
    f32 float32 = 1.30;
    @allow_deprecated_struct_defaults
    f64 float64 = 0.0000054;
    @allow_deprecated_struct_defaults
    s string = "hello";
};

// Arbitrary, but must be small enough such that a single message doesn't exceed
// kMaxMessageSize or kMaxMessageHandles.
const arrays_size uint32 = 3;

type arrays = resource struct {
    b_0 array<bool, 1>;
    i8_0 array<int8, 1>;
    i16_0 array<int16, 1>;
    i32_0 array<int32, 1>;
    i64_0 array<int64, 1>;
    u8_0 array<uint8, 1>;
    u16_0 array<uint16, 1>;
    u32_0 array<uint32, 1>;
    u64_0 array<uint64, 1>;
    f32_0 array<float32, 1>;
    f64_0 array<float64, 1>;
    handle_0 array<zx.handle, 1>;
    b_1 array<bool, arrays_size>;
    i8_1 array<int8, arrays_size>;
    i16_1 array<int16, arrays_size>;
    i32_1 array<int32, arrays_size>;
    i64_1 array<int64, arrays_size>;
    u8_1 array<uint8, arrays_size>;
    u16_1 array<uint16, arrays_size>;
    u32_1 array<uint32, arrays_size>;
    u64_1 array<uint64, arrays_size>;
    f32_1 array<float32, arrays_size>;
    f64_1 array<float64, arrays_size>;
    handle_1 array<zx.handle, arrays_size>;
};

type arrays_2d = resource struct {
    b array<array<bool, 2>, arrays_size>;
    i8 array<array<int8, 2>, arrays_size>;
    i16 array<array<int16, 2>, arrays_size>;
    i32 array<array<int32, 2>, arrays_size>;
    i64 array<array<int64, 2>, arrays_size>;
    u8 array<array<uint8, 2>, arrays_size>;
    u16 array<array<uint16, 2>, arrays_size>;
    u32 array<array<uint32, 2>, arrays_size>;
    u64 array<array<uint64, 2>, arrays_size>;
    f32 array<array<float32, 2>, arrays_size>;
    f64 array<array<float64, 2>, arrays_size>;
    handle_handle array<array<zx.handle, 2>, arrays_size>;
};

// Arbitrary, but must be small enough such that a single message doesn't exceed
// kMaxMessageSize or kMaxMessageHandles.
const vectors_size uint32 = 3;

type vectors = resource struct {
    b_0 vector<bool>;
    i8_0 vector<int8>;
    i16_0 vector<int16>;
    i32_0 vector<int32>;
    i64_0 vector<int64>;
    u8_0 vector<uint8>;
    u16_0 vector<uint16>;
    u32_0 vector<uint32>;
    u64_0 vector<uint64>;
    f32_0 vector<float32>;
    f64_0 vector<float64>;
    handle_0 vector<zx.handle>;
    b_1 vector<vector<bool>:2>;
    i8_1 vector<vector<int8>:2>;
    i16_1 vector<vector<int16>:2>;
    i32_1 vector<vector<int32>:2>;
    i64_1 vector<vector<int64>:2>;
    u8_1 vector<vector<uint8>:2>;
    u16_1 vector<vector<uint16>:2>;
    u32_1 vector<vector<uint32>:2>;
    u64_1 vector<vector<uint64>:2>;
    f32_1 vector<vector<float32>:2>;
    f64_1 vector<vector<float64>:2>;
    handle_1 vector<vector<zx.handle>:2>;
    b_sized_0 vector<bool>:1;
    i8_sized_0 vector<int8>:1;
    i16_sized_0 vector<int16>:1;
    i32_sized_0 vector<int32>:1;
    i64_sized_0 vector<int64>:1;
    u8_sized_0 vector<uint8>:1;
    u16_sized_0 vector<uint16>:1;
    u32_sized_0 vector<uint32>:1;
    u64_sized_0 vector<uint64>:1;
    f32_sized_0 vector<float32>:1;
    f64_sized_0 vector<float64>:1;
    handle_sized_0 vector<zx.handle>:1;
    b_sized_1 vector<bool>:vectors_size;
    i8_sized_1 vector<int8>:vectors_size;
    i16_sized_1 vector<int16>:vectors_size;
    i32_sized_1 vector<int32>:vectors_size;
    i64_sized_1 vector<int64>:vectors_size;
    u8_sized_1 vector<uint8>:vectors_size;
    u16_sized_1 vector<uint16>:vectors_size;
    u32_sized_1 vector<uint32>:vectors_size;
    u64_sized_1 vector<uint64>:vectors_size;
    f32_sized_1 vector<float32>:vectors_size;
    f64_sized_1 vector<float64>:vectors_size;
    handle_sized_1 vector<zx.handle>:vectors_size;
    b_sized_2 vector<vector<bool>:2>:vectors_size;
    i8_sized_2 vector<vector<int8>:2>:vectors_size;
    i16_sized_2 vector<vector<int16>:2>:vectors_size;
    i32_sized_2 vector<vector<int32>:2>:vectors_size;
    i64_sized_2 vector<vector<int64>:2>:vectors_size;
    u8_sized_2 vector<vector<uint8>:2>:vectors_size;
    u16_sized_2 vector<vector<uint16>:2>:vectors_size;
    u32_sized_2 vector<vector<uint32>:2>:vectors_size;
    u64_sized_2 vector<vector<uint64>:2>:vectors_size;
    f32_sized_2 vector<vector<float32>:2>:vectors_size;
    f64_sized_2 vector<vector<float64>:2>:vectors_size;
    handle_sized_2 vector<vector<zx.handle>:2>:vectors_size;
    b_nullable_0 vector<bool>:<1, optional>;
    i8_nullable_0 vector<int8>:<1, optional>;
    i16_nullable_0 vector<int16>:<1, optional>;
    i32_nullable_0 vector<int32>:<1, optional>;
    i64_nullable_0 vector<int64>:<1, optional>;
    u8_nullable_0 vector<uint8>:<1, optional>;
    u16_nullable_0 vector<uint16>:<1, optional>;
    u32_nullable_0 vector<uint32>:<1, optional>;
    u64_nullable_0 vector<uint64>:<1, optional>;
    f32_nullable_0 vector<float32>:<1, optional>;
    f64_nullable_0 vector<float64>:<1, optional>;
    handle_nullable_0 vector<zx.handle>:<1, optional>;
    b_nullable_1 vector<vector<bool>:2>:optional;
    i8_nullable_1 vector<vector<int8>:2>:optional;
    i16_nullable_1 vector<vector<int16>:2>:optional;
    i32_nullable_1 vector<vector<int32>:2>:optional;
    i64_nullable_1 vector<vector<int64>:2>:optional;
    u8_nullable_1 vector<vector<uint8>:2>:optional;
    u16_nullable_1 vector<vector<uint16>:2>:optional;
    u32_nullable_1 vector<vector<uint32>:2>:optional;
    u64_nullable_1 vector<vector<uint64>:2>:optional;
    f32_nullable_1 vector<vector<float32>:2>:optional;
    f64_nullable_1 vector<vector<float64>:2>:optional;
    handle_nullable_1 vector<vector<zx.handle>:2>:optional;
    b_nullable_sized_0 vector<bool>:<1, optional>;
    i8_nullable_sized_0 vector<int8>:<1, optional>;
    i16_nullable_sized_0 vector<int16>:<1, optional>;
    i32_nullable_sized_0 vector<int32>:<1, optional>;
    i64_nullable_sized_0 vector<int64>:<1, optional>;
    u8_nullable_sized_0 vector<uint8>:<1, optional>;
    u16_nullable_sized_0 vector<uint16>:<1, optional>;
    u32_nullable_sized_0 vector<uint32>:<1, optional>;
    u64_nullable_sized_0 vector<uint64>:<1, optional>;
    f32_nullable_sized_0 vector<float32>:<1, optional>;
    f64_nullable_sized_0 vector<float64>:<1, optional>;
    handle_nullable_sized_0 vector<zx.handle>:<1, optional>;
    b_nullable_sized_1 vector<bool>:<vectors_size, optional>;
    i8_nullable_sized_1 vector<int8>:<vectors_size, optional>;
    i16_nullable_sized_1 vector<int16>:<vectors_size, optional>;
    i32_nullable_sized_1 vector<int32>:<vectors_size, optional>;
    i64_nullable_sized_1 vector<int64>:<vectors_size, optional>;
    u8_nullable_sized_1 vector<uint8>:<vectors_size, optional>;
    u16_nullable_sized_1 vector<uint16>:<vectors_size, optional>;
    u32_nullable_sized_1 vector<uint32>:<vectors_size, optional>;
    u64_nullable_sized_1 vector<uint64>:<vectors_size, optional>;
    f32_nullable_sized_1 vector<float32>:<vectors_size, optional>;
    f64_nullable_sized_1 vector<float64>:<vectors_size, optional>;
    handle_nullable_sized_1 vector<zx.handle>:<vectors_size, optional>;
    b_nullable_sized_2 vector<vector<bool>:2>:<vectors_size, optional>;
    i8_nullable_sized_2 vector<vector<int8>:2>:<vectors_size, optional>;
    i16_nullable_sized_2 vector<vector<int16>:2>:<vectors_size, optional>;
    i32_nullable_sized_2 vector<vector<int32>:2>:<vectors_size, optional>;
    i64_nullable_sized_2 vector<vector<int64>:2>:<vectors_size, optional>;
    u8_nullable_sized_2 vector<vector<uint8>:2>:<vectors_size, optional>;
    u16_nullable_sized_2 vector<vector<uint16>:2>:<vectors_size, optional>;
    u32_nullable_sized_2 vector<vector<uint32>:2>:<vectors_size, optional>;
    u64_nullable_sized_2 vector<vector<uint64>:2>:<vectors_size, optional>;
    f32_nullable_sized_2 vector<vector<float32>:2>:<vectors_size, optional>;
    f64_nullable_sized_2 vector<vector<float64>:2>:<vectors_size, optional>;
    handle_nullable_sized_2 vector<vector<zx.handle>:2>:<vectors_size, optional>;
};

// We don't test handle types that don't support duplication
// (supports_duplication in zx/object_traits.h) or that require special
// privileges to create.
type handles = resource struct {
    handle_handle zx.handle;
    process_handle zx.handle:PROCESS;
    thread_handle zx.handle:THREAD;
    vmo_handle zx.handle:VMO;
    event_handle zx.handle:EVENT;
    port_handle zx.handle:PORT;
    socket_handle zx.handle:SOCKET;
    eventpair_handle zx.handle:EVENTPAIR;
    job_handle zx.handle:JOB;
    vmar_handle zx.handle:VMAR;
    fifo_handle zx.handle:FIFO;
    timer_handle zx.handle:TIMER;
    nullable_handle_handle zx.handle:optional;
    nullable_process_handle zx.handle:<PROCESS, optional>;
    nullable_thread_handle zx.handle:<THREAD, optional>;
    nullable_vmo_handle zx.handle:<VMO, optional>;
    nullable_channel_handle zx.handle:<CHANNEL, optional>;
    nullable_event_handle zx.handle:<EVENT, optional>;
    nullable_port_handle zx.handle:<PORT, optional>;
    nullable_interrupt_handle zx.handle:<INTERRUPT, optional>;
    nullable_log_handle zx.handle:<LOG, optional>;
    nullable_socket_handle zx.handle:<SOCKET, optional>;
    nullable_eventpair_handle zx.handle:<EVENTPAIR, optional>;
    nullable_job_handle zx.handle:<JOB, optional>;
    nullable_vmar_handle zx.handle:<VMAR, optional>;
    nullable_fifo_handle zx.handle:<FIFO, optional>;
    nullable_timer_handle zx.handle:<TIMER, optional>;
};

// Arbitrary.
const strings_size uint32 = 32;

type strings = struct {
    s string;
    nullable_s string:optional;
    size_0_s string:2;
    size_1_s string:strings_size;
    nullable_size_0_s string:<2, optional>;
    nullable_size_1_s string:<strings_size, optional>;
};

type default_enum = strict enum {
    kZero = 0;
    kOne = 1;
};

type i8_enum = strict enum : int8 {
    kNegativeOne = -1;
    kOne = 1;
};

type i16_enum = strict enum : int16 {
    kNegativeOne = -1;
    kOne = 1;
    kTwo = 2;
};

type i32_enum = strict enum : int32 {
    kNegativeOne = -1;
    kOne = 1;
    kTwo = 2;
    kThree = 3;
};

type i64_enum = strict enum : int64 {
    kNegativeOne = -1;
    kOne = 1;
    kTwo = 2;
    kThree = 3;
    kFour = 4;
};

type u8_enum = strict enum : uint8 {
    kOne = 1;
    kTwo = 2;
    kThree = 3;
    kFour = 4;
    kFive = 5;
};

type u16_enum = strict enum : uint16 {
    kOne = 1;
    kTwo = 2;
    kThree = 3;
    kFour = 4;
    kFive = 5;
    kSix = 6;
};

type u32_enum = strict enum : uint32 {
    kOne = 1;
    kTwo = 2;
    kThree = 3;
    kFour = 4;
    kFive = 5;
    kSix = 6;
    kSeven = 7;
};

type u64_enum = strict enum : uint64 {
    kOne = 1;
    kTwo = 2;
    kThree = 3;
    kFour = 4;
    kFive = 5;
    kSix = 6;
    kSeven = 7;
    kEight = 8;
};

type default_bits = strict bits {
    kOne = 1;
    kTwo = 2;
};

type u8_bits = strict bits : uint8 {
    kOne = 1;
    kTwo = 2;
    kThree = 4;
    kFour = 8;
    kFive = 16;
};

type u16_bits = strict bits : uint16 {
    kOne = 1;
    kTwo = 2;
    kThree = 4;
    kFour = 8;
    kFive = 16;
    kSix = 32;
};

type u32_bits = strict bits : uint32 {
    kOne = 1;
    kTwo = 2;
    kThree = 4;
    kFour = 8;
    kFive = 16;
    kSix = 32;
    kSeven = 64;
};

type u64_bits = strict bits : uint64 {
    kOne = 1;
    kTwo = 2;
    kThree = 4;
    kFour = 8;
    kFive = 16;
    kSix = 32;
    kSeven = 64;
    kEight = 128;
};

type structs = struct {
    s this_is_a_struct;
    nullable_s box<this_is_a_struct>;
    es this_is_an_empty_struct;
};

type unions = struct {
    u this_is_a_union;
    nullable_u this_is_a_union:optional;
};

// This struct is meant to exercise almost all features of FIDL.
type Struct = resource struct {
    primitive_types primitive_types;
    default_values default_values;
    arrays arrays;
    arrays_2d arrays_2d;
    vectors vectors;
    handles handles;
    strings strings;
    default_enum default_enum;
    i8_enum i8_enum;
    i16_enum i16_enum;
    i32_enum i32_enum;
    i64_enum i64_enum;
    u8_enum u8_enum;
    u16_enum u16_enum;
    u32_enum u32_enum;
    u64_enum u64_enum;
    default_bits default_bits;
    u8_bits u8_bits;
    u16_bits u16_bits;
    u32_bits u32_bits;
    u64_bits u64_bits;
    structs structs;
    unions unions;
    table this_is_a_table;
    xunion this_is_a_xunion;
    b bool;
};

// This struct contains arrays of all different kinds of FIDL types.
type ArraysStruct = resource struct {
    bools array<bool, arrays_size>;
    int8s array<int8, arrays_size>;
    int16s array<int16, arrays_size>;
    int32s array<int32, arrays_size>;
    int64s array<int64, arrays_size>;
    uint8s array<uint8, arrays_size>;
    uint16s array<uint16, arrays_size>;
    uint32s array<uint32, arrays_size>;
    uint64s array<uint64, arrays_size>;
    float32s array<float32, arrays_size>;
    float64s array<float64, arrays_size>;
    enums array<default_enum, arrays_size>;
    bits array<default_bits, arrays_size>;
    handles array<zx.handle, arrays_size>;
    nullable_handles array<zx.handle:optional, arrays_size>;
    strings array<string, arrays_size>;
    nullable_strings array<string:optional, arrays_size>;
    structs array<this_is_a_struct, arrays_size>;
    nullable_structs array<box<this_is_a_struct>, arrays_size>;
    unions array<this_is_a_union, arrays_size>;
    nullable_unions array<this_is_a_union:optional, arrays_size>;
    arrays array<array<uint32, arrays_size>, arrays_size>;
    vectors array<vector<uint32>, arrays_size>;
    nullable_vectors array<vector<uint32>:optional, arrays_size>;
    tables array<this_is_a_table, arrays_size>;
    xunions array<this_is_a_xunion, arrays_size>;
};

// This struct contains vectors of all different kinds of FIDL types.
type VectorsStruct = resource struct {
    bools vector<bool>:vectors_size;
    int8s vector<int8>:vectors_size;
    int16s vector<int16>:vectors_size;
    int32s vector<int32>:vectors_size;
    int64s vector<int64>:vectors_size;
    uint8s vector<uint8>:vectors_size;
    uint16s vector<uint16>:vectors_size;
    uint32s vector<uint32>:vectors_size;
    uint64s vector<uint64>:vectors_size;
    float32s vector<float32>:vectors_size;
    float64s vector<float64>:vectors_size;
    enums vector<default_enum>:vectors_size;
    bits vector<default_bits>:vectors_size;
    handles vector<zx.handle>:vectors_size;
    nullable_handles vector<zx.handle:optional>:vectors_size;
    strings vector<string>:vectors_size;
    nullable_strings vector<string:optional>:vectors_size;
    structs vector<this_is_a_struct>:vectors_size;
    nullable_structs vector<box<this_is_a_struct>>:vectors_size;
    unions vector<this_is_a_union>:vectors_size;
    nullable_unions vector<this_is_a_union:optional>:vectors_size;
    arrays vector<array<uint32, vectors_size>>:vectors_size;
    vectors vector<vector<uint32>>:vectors_size;
    nullable_vectors vector<vector<uint32>:optional>:vectors_size;
    tables vector<this_is_a_table>:vectors_size;
    xunions vector<this_is_a_xunion>:vectors_size;
};

// This table has members all different FIDL types.
type AllTypesTable = resource table {
    1: bool_member bool;
    2: int8_member int8;
    3: int16_member int16;
    4: int32_member int32;
    5: int64_member int64;
    6: uint8_member uint8;
    7: uint16_member uint16;
    8: uint32_member uint32;
    9: uint64_member uint64;
   10: float32_member float32;
   11: float64_member float64;
   12: enum_member default_enum;
   13: bits_member default_bits;
   14: handle_member zx.handle;
   15: string_member string;
   16: struct_member this_is_a_struct;
   17: union_member this_is_a_union;
   18: array_member array<uint32, arrays_size>;
   19: vector_member vector<uint32>;
   20: table_member this_is_a_table;
   21: xunion_member this_is_a_xunion;
};

// This xunion has members all different FIDL types.
type AllTypesXunion = flexible resource union {
    1: bool_member bool;
    2: int8_member int8;
    3: int16_member int16;
    4: int32_member int32;
    5: int64_member int64;
    6: uint8_member uint8;
    7: uint16_member uint16;
    8: uint32_member uint32;
    9: uint64_member uint64;
   10: float32_member float32;
   11: float64_member float64;
   12: enum_member default_enum;
   13: bits_member default_bits;
   14: handle_member zx.handle;
   15: string_member string;
   16: struct_member this_is_a_struct;
   17: union_member this_is_a_union;
   18: array_member array<uint32, arrays_size>;
   19: vector_member vector<uint32>;
   20: table_member this_is_a_table;
   21: xunion_member this_is_a_xunion;
};

type RespondWith = strict enum {
    SUCCESS = 1;
    ERR = 2;
};

type RequestTable = table {
    1: value uint64;
    2: forward_to_server string;
};

type ResponseTable = table {
    1: value uint64;
};

type RequestUnion = flexible union {
    1: unsigned struct {
        value uint64;
        forward_to_server string;
    };
    2: signed struct {
        value int64;
        forward_to_server string;
    };
};

type ResponseUnion = strict union {
    1: unsigned uint64;
    2: signed int64;
};

@discoverable
protocol Echo {
    compose imp.Composed;

    // If `forward_to_server` is empty, just returns `value`.
    // If `forward_to_server` is not empty, it is treated as the URL of a server
    // which implements this interface. The server that receives the non-empty
    // `forward_to_server` arg acts as a proxy for that other server.
    // For the error variants: if should_error is true, the provided err result
    // error is sent, otherwise the response variant is sent.
    EchoMinimal(struct {
        forward_to_server string;
    }) -> ();
    EchoMinimalWithError(struct {
        forward_to_server string;
        result_variant RespondWith;
    }) -> (struct {}) error uint32;

    // Same as the above, but the server should use the event to return the
    // response, rather than a return value.
    EchoMinimalNoRetVal(struct {
        forward_to_server string;
    });
    -> EchoMinimalEvent();

    EchoStruct(resource struct {
        value Struct;
        forward_to_server string;
    }) -> (resource struct {
        value Struct;
    });
    EchoStructWithError(resource struct {
        value Struct;
        result_err default_enum;
        forward_to_server string;
        result_variant RespondWith;
    }) -> (resource struct {
        value Struct;
    }) error default_enum;
    EchoStructNoRetVal(resource struct {
        value Struct;
        forward_to_server string;
    });
    -> EchoEvent(resource struct {
        value Struct;
    });
    EchoArrays(resource struct {
        value ArraysStruct;
        forward_to_server string;
    }) -> (resource struct {
        value ArraysStruct;
    });
    EchoArraysWithError(resource struct {
        value ArraysStruct;
        result_err default_enum;
        forward_to_server string;
        result_variant RespondWith;
    }) -> (resource struct {
        value ArraysStruct;
    }) error default_enum;

    EchoVectors(resource struct {
        value VectorsStruct;
        forward_to_server string;
    }) -> (resource struct {
        value VectorsStruct;
    });
    EchoVectorsWithError(resource struct {
        value VectorsStruct;
        result_err default_enum;
        forward_to_server string;
        result_variant RespondWith;
    }) -> (resource struct {
        value VectorsStruct;
    }) error default_enum;

    EchoTable(resource struct {
        value AllTypesTable;
        forward_to_server string;
    }) -> (resource struct {
        value AllTypesTable;
    });
    EchoTableWithError(resource struct {
        value AllTypesTable;
        result_err default_enum;
        forward_to_server string;
        result_variant RespondWith;
    }) -> (resource struct {
        value AllTypesTable;
    }) error default_enum;


    // TODO(fxbug.dev/88343): renamed these tests to make clearer the difference between these and
    // the payload tests below.
    EchoXunions(resource struct {
        value vector<AllTypesXunion>;
        forward_to_server string;
    }) -> (resource struct {
        value vector<AllTypesXunion>;
    });
    EchoXunionsWithError(resource struct {
        value vector<AllTypesXunion>;
        result_err default_enum;
        forward_to_server string;
        result_variant RespondWith;
    }) -> (resource struct {
        value vector<AllTypesXunion>;
    }) error default_enum;

    EchoNamedStruct(imp.RequestStruct) -> (imp.ResponseStruct);
    EchoNamedStructWithError(imp.ErrorableRequestStruct) -> (imp.ResponseStruct) error uint32;
    EchoNamedStructNoRetVal(imp.EventTriggeringRequestStruct);
    -> OnEchoNamedEvent(imp.ResponseStruct);

    EchoTablePayload(RequestTable) -> (ResponseTable);
    EchoTablePayloadWithError(table {
        1: value uint64;
        2: forward_to_server string;
        3: result_err default_enum;
        4: result_variant RespondWith;
    }) -> (ResponseTable) error default_enum;
    EchoTablePayloadNoRetVal(RequestTable);
    -> OnEchoTablePayloadEvent(ResponseTable);

    EchoUnionPayload(RequestUnion) -> (ResponseUnion);
    EchoUnionPayloadWithError(flexible union {
        1: unsigned @generated_name("UnsignedErrorable") struct {
            value uint64;
            forward_to_server string;
            result_err default_enum;
            result_variant RespondWith;
        };
        2: signed @generated_name("SignedErrorable") struct {
            value int64;
            forward_to_server string;
            result_err default_enum;
            result_variant RespondWith;
        };
    }) -> (ResponseUnion) error default_enum;
    EchoUnionPayloadNoRetVal(RequestUnion);
    -> OnEchoUnionPayloadEvent(ResponseUnion);
};