ffi-bindings 1.0.3 → 1.0.4

package/src/generated/matrix_sdk_ui.ts

@@ -0,0 +1,816 @@
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+import * as wasmBundle from "./wasm-bindgen/index.js";
+import {
+  type UniffiByteArray, 
+  AbstractFfiConverterByteArray, 
+  FfiConverterBool, 
+  FfiConverterInt32, 
+  RustBuffer, 
+  UniffiEnum, 
+  UniffiInternalError, 
+  UniffiRustCaller, 
+  uniffiCreateFfiConverterString, 
+  uniffiTypeNameSymbol } from "uniffi-bindgen-react-native";
+
+// Get converters from the other files, if any.
+const nativeModule = () => wasmBundle;
+const uniffiCaller = new UniffiRustCaller(() => new wasmBundle.RustCallStatus());
+
+const uniffiIsDebug =
+  // @ts-ignore -- The process global might not be defined
+  typeof process !== "object" ||
+  // @ts-ignore -- The process global might not be defined
+  process?.env?.NODE_ENV !== "production" ||
+  false;
+// Public interface members begin here.
+
+
+
+
+
+
+
+const stringConverter = (() => {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        stringToBytes: (s: string) => encoder.encode(s),
+        bytesToString: (ab: UniffiByteArray) => decoder.decode(ab),
+        stringByteLength: (s: string) => encoder.encode(s).byteLength,
+    };
+})();
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+
+/**
+ * Where this event came.
+ */
+export enum EventItemOrigin {
+    /**
+     * The event was created locally.
+     */
+    Local,
+    /**
+     * The event came from a sync response.
+     */
+    Sync,
+    /**
+     * The event came from pagination.
+     */
+    Pagination,
+    /**
+     * The event came from a cache.
+     */
+    Cache
+}
+
+const FfiConverterTypeEventItemOrigin = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = EventItemOrigin;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return EventItemOrigin.Local;
+                case 2: return EventItemOrigin.Sync;
+                case 3: return EventItemOrigin.Pagination;
+                case 4: return EventItemOrigin.Cache;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value) {
+                case EventItemOrigin.Local: return ordinalConverter.write(1, into);
+                case EventItemOrigin.Sync: return ordinalConverter.write(2, into);
+                case EventItemOrigin.Pagination: return ordinalConverter.write(3, into);
+                case EventItemOrigin.Cache: return ordinalConverter.write(4, into);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+
+
+export enum LatestEventValueLocalState {
+    IsSending,
+    HasBeenSent,
+    CannotBeSent
+}
+
+const FfiConverterTypeLatestEventValueLocalState = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = LatestEventValueLocalState;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return LatestEventValueLocalState.IsSending;
+                case 2: return LatestEventValueLocalState.HasBeenSent;
+                case 3: return LatestEventValueLocalState.CannotBeSent;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value) {
+                case LatestEventValueLocalState.IsSending: return ordinalConverter.write(1, into);
+                case LatestEventValueLocalState.HasBeenSent: return ordinalConverter.write(2, into);
+                case LatestEventValueLocalState.CannotBeSent: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+
+
+/**
+ * The type of change between the previous and current pinned events.
+ */
+export enum RoomPinnedEventsChange {
+    /**
+     * Only new event ids were added.
+     */
+    Added,
+    /**
+     * Only event ids were removed.
+     */
+    Removed,
+    /**
+     * Some change other than only adding or only removing ids happened.
+     */
+    Changed
+}
+
+const FfiConverterTypeRoomPinnedEventsChange = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = RoomPinnedEventsChange;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return RoomPinnedEventsChange.Added;
+                case 2: return RoomPinnedEventsChange.Removed;
+                case 3: return RoomPinnedEventsChange.Changed;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value) {
+                case RoomPinnedEventsChange.Added: return ordinalConverter.write(1, into);
+                case RoomPinnedEventsChange.Removed: return ordinalConverter.write(2, into);
+                case RoomPinnedEventsChange.Changed: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+
+
+// Enum: SpaceRoomListPaginationState
+export enum SpaceRoomListPaginationState_Tags {
+    Idle = "Idle",
+    Loading = "Loading"
+}
+export const SpaceRoomListPaginationState = (() => {
+    
+
+    type Idle__interface = {
+        tag: SpaceRoomListPaginationState_Tags.Idle;
+        inner: Readonly<{endReached: boolean}>
+    };
+
+    
+    class Idle_ extends UniffiEnum implements Idle__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "SpaceRoomListPaginationState";
+        readonly tag = SpaceRoomListPaginationState_Tags.Idle;
+        readonly inner: Readonly<{endReached: boolean}>;
+        constructor(inner: { endReached: boolean }) {
+            super("SpaceRoomListPaginationState", "Idle");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { endReached: boolean }): Idle_ {
+            return new Idle_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Idle_ {
+            return obj.tag === SpaceRoomListPaginationState_Tags.Idle;
+        }
+        
+
+        
+
+    }
+    
+
+    type Loading__interface = {
+        tag: SpaceRoomListPaginationState_Tags.Loading
+    };
+
+    
+    class Loading_ extends UniffiEnum implements Loading__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "SpaceRoomListPaginationState";
+        readonly tag = SpaceRoomListPaginationState_Tags.Loading;
+        constructor() {
+            super("SpaceRoomListPaginationState", "Loading");
+        }
+
+        static new(): Loading_ {
+            return new Loading_();
+        }
+
+        static instanceOf(obj: any): obj is Loading_ {
+            return obj.tag === SpaceRoomListPaginationState_Tags.Loading;
+        }
+        
+
+        
+
+    }
+
+    function instanceOf(obj: any): obj is SpaceRoomListPaginationState {
+        return obj[uniffiTypeNameSymbol] === "SpaceRoomListPaginationState";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  Idle: Idle_, 
+  Loading: Loading_
+    });
+
+})();
+
+
+
+export type SpaceRoomListPaginationState = InstanceType<
+    typeof SpaceRoomListPaginationState[keyof Omit<typeof SpaceRoomListPaginationState, 'instanceOf'>]
+>;
+
+// FfiConverter for enum SpaceRoomListPaginationState
+const FfiConverterTypeSpaceRoomListPaginationState = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = SpaceRoomListPaginationState;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new SpaceRoomListPaginationState.Idle({endReached: FfiConverterBool.read(from) });
+                case 2: return new SpaceRoomListPaginationState.Loading();
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value.tag) {
+                case SpaceRoomListPaginationState_Tags.Idle: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterBool.write(inner.endReached, into);
+                    return;
+                }
+                case SpaceRoomListPaginationState_Tags.Loading: {
+                    ordinalConverter.write(2, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that SpaceRoomListPaginationState_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case SpaceRoomListPaginationState_Tags.Idle: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterBool.allocationSize(inner.endReached);
+                    return size;
+                }
+                case SpaceRoomListPaginationState_Tags.Loading: {
+                    return ordinalConverter.allocationSize(2);
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+// Enum: ThreadListPaginationState
+export enum ThreadListPaginationState_Tags {
+    Idle = "Idle",
+    Loading = "Loading"
+}
+/**
+ * The pagination state of a [`ThreadListService`].
+ */
+export const ThreadListPaginationState = (() => {
+    
+
+    type Idle__interface = {
+        tag: ThreadListPaginationState_Tags.Idle;
+        inner: Readonly<{endReached: boolean}>
+    };
+
+    
+    /**
+     * The list is idle (not currently loading).
+     */
+    class Idle_ extends UniffiEnum implements Idle__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "ThreadListPaginationState";
+        readonly tag = ThreadListPaginationState_Tags.Idle;
+        readonly inner: Readonly<{endReached: boolean}>;
+        constructor(inner: { 
+        /**
+         * Whether the end of the thread list has been reached (no more pages
+         * to load).
+         */endReached: boolean }) {
+            super("ThreadListPaginationState", "Idle");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { 
+        /**
+         * Whether the end of the thread list has been reached (no more pages
+         * to load).
+         */endReached: boolean }): Idle_ {
+            return new Idle_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Idle_ {
+            return obj.tag === ThreadListPaginationState_Tags.Idle;
+        }
+        
+
+        
+
+    }
+    
+
+    type Loading__interface = {
+        tag: ThreadListPaginationState_Tags.Loading
+    };
+
+    
+    /**
+     * The list is currently loading the next page.
+     */
+    class Loading_ extends UniffiEnum implements Loading__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "ThreadListPaginationState";
+        readonly tag = ThreadListPaginationState_Tags.Loading;
+        constructor() {
+            super("ThreadListPaginationState", "Loading");
+        }
+
+        static new(): Loading_ {
+            return new Loading_();
+        }
+
+        static instanceOf(obj: any): obj is Loading_ {
+            return obj.tag === ThreadListPaginationState_Tags.Loading;
+        }
+        
+
+        
+
+    }
+
+    function instanceOf(obj: any): obj is ThreadListPaginationState {
+        return obj[uniffiTypeNameSymbol] === "ThreadListPaginationState";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  Idle: Idle_, 
+  Loading: Loading_
+    });
+
+})();
+
+
+/**
+ * The pagination state of a [`ThreadListService`].
+ */
+
+export type ThreadListPaginationState = InstanceType<
+    typeof ThreadListPaginationState[keyof Omit<typeof ThreadListPaginationState, 'instanceOf'>]
+>;
+
+// FfiConverter for enum ThreadListPaginationState
+const FfiConverterTypeThreadListPaginationState = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = ThreadListPaginationState;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new ThreadListPaginationState.Idle({endReached: FfiConverterBool.read(from) });
+                case 2: return new ThreadListPaginationState.Loading();
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value.tag) {
+                case ThreadListPaginationState_Tags.Idle: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterBool.write(inner.endReached, into);
+                    return;
+                }
+                case ThreadListPaginationState_Tags.Loading: {
+                    ordinalConverter.write(2, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that ThreadListPaginationState_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case ThreadListPaginationState_Tags.Idle: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterBool.allocationSize(inner.endReached);
+                    return size;
+                }
+                case ThreadListPaginationState_Tags.Loading: {
+                    return ordinalConverter.allocationSize(2);
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+// Enum: TimelineEventFocusThreadMode
+export enum TimelineEventFocusThreadMode_Tags {
+    ForceThread = "ForceThread",
+    Automatic = "Automatic"
+}
+/**
+ * Options for controlling the behaviour of [`TimelineFocus::Event`]
+ * for threaded events.
+ */
+export const TimelineEventFocusThreadMode = (() => {
+    
+
+    type ForceThread__interface = {
+        tag: TimelineEventFocusThreadMode_Tags.ForceThread
+    };
+
+    
+    /**
+     * Force the timeline into threaded mode.
+     *
+     * When the focused event is part of a thread, the timeline will be focused
+     * on that thread's root. Otherwise, the timeline will treat the target
+     * event itself as the thread root. Threaded events will never be
+     * hidden.
+     */
+    class ForceThread_ extends UniffiEnum implements ForceThread__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "TimelineEventFocusThreadMode";
+        readonly tag = TimelineEventFocusThreadMode_Tags.ForceThread;
+        constructor() {
+            super("TimelineEventFocusThreadMode", "ForceThread");
+        }
+
+        static new(): ForceThread_ {
+            return new ForceThread_();
+        }
+
+        static instanceOf(obj: any): obj is ForceThread_ {
+            return obj.tag === TimelineEventFocusThreadMode_Tags.ForceThread;
+        }
+        
+
+        
+
+    }
+    
+
+    type Automatic__interface = {
+        tag: TimelineEventFocusThreadMode_Tags.Automatic;
+        inner: Readonly<{hideThreadedEvents: boolean}>
+    };
+
+    
+    /**
+     * Automatically determine if the target event is part of a thread or not.
+     *
+     * If the event is part of a thread, the timeline
+     * will be filtered to on-thread events.
+     */
+    class Automatic_ extends UniffiEnum implements Automatic__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "TimelineEventFocusThreadMode";
+        readonly tag = TimelineEventFocusThreadMode_Tags.Automatic;
+        readonly inner: Readonly<{hideThreadedEvents: boolean}>;
+        constructor(inner: { 
+        /**
+         * When the target event is not part of a thread, whether to
+         * hide in-thread replies from the live timeline.
+         *
+         * Has no effect when the target event is part of a thread.
+         *
+         * This should be set to true when the client can create
+         * [`TimelineFocus::Thread`]-focused timelines from the thread roots
+         * themselves and doesn't use the [`Self::ForceThread`] mode.
+         */hideThreadedEvents: boolean }) {
+            super("TimelineEventFocusThreadMode", "Automatic");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { 
+        /**
+         * When the target event is not part of a thread, whether to
+         * hide in-thread replies from the live timeline.
+         *
+         * Has no effect when the target event is part of a thread.
+         *
+         * This should be set to true when the client can create
+         * [`TimelineFocus::Thread`]-focused timelines from the thread roots
+         * themselves and doesn't use the [`Self::ForceThread`] mode.
+         */hideThreadedEvents: boolean }): Automatic_ {
+            return new Automatic_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Automatic_ {
+            return obj.tag === TimelineEventFocusThreadMode_Tags.Automatic;
+        }
+        
+
+        
+
+    }
+
+    function instanceOf(obj: any): obj is TimelineEventFocusThreadMode {
+        return obj[uniffiTypeNameSymbol] === "TimelineEventFocusThreadMode";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  ForceThread: ForceThread_, 
+  Automatic: Automatic_
+    });
+
+})();
+
+
+/**
+ * Options for controlling the behaviour of [`TimelineFocus::Event`]
+ * for threaded events.
+ */
+
+export type TimelineEventFocusThreadMode = InstanceType<
+    typeof TimelineEventFocusThreadMode[keyof Omit<typeof TimelineEventFocusThreadMode, 'instanceOf'>]
+>;
+
+// FfiConverter for enum TimelineEventFocusThreadMode
+const FfiConverterTypeTimelineEventFocusThreadMode = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = TimelineEventFocusThreadMode;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new TimelineEventFocusThreadMode.ForceThread();
+                case 2: return new TimelineEventFocusThreadMode.Automatic({hideThreadedEvents: FfiConverterBool.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value.tag) {
+                case TimelineEventFocusThreadMode_Tags.ForceThread: {
+                    ordinalConverter.write(1, into);
+                    return;
+                }
+                case TimelineEventFocusThreadMode_Tags.Automatic: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterBool.write(inner.hideThreadedEvents, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that TimelineEventFocusThreadMode_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case TimelineEventFocusThreadMode_Tags.ForceThread: {
+                    return ordinalConverter.allocationSize(1);
+                }
+                case TimelineEventFocusThreadMode_Tags.Automatic: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterBool.allocationSize(inner.hideThreadedEvents);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+/**
+ * Extends [`ShieldStateCode`] to allow for a `SentInClear` code.
+ */
+export enum TimelineEventShieldStateCode {
+    /**
+     * Not enough information available to check the authenticity.
+     */
+    AuthenticityNotGuaranteed,
+    /**
+     * The sending device isn't yet known by the Client.
+     */
+    UnknownDevice,
+    /**
+     * The sending device hasn't been verified by the sender.
+     */
+    UnsignedDevice,
+    /**
+     * The sender hasn't been verified by the Client's user.
+     */
+    UnverifiedIdentity,
+    /**
+     * The sender was previously verified but changed their identity.
+     */
+    VerificationViolation,
+    /**
+     * The `sender` field on the event does not match the owner of the device
+     * that established the Megolm session.
+     */
+    MismatchedSender,
+    /**
+     * An unencrypted event in an encrypted room.
+     */
+    SentInClear
+}
+
+const FfiConverterTypeTimelineEventShieldStateCode = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = TimelineEventShieldStateCode;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return TimelineEventShieldStateCode.AuthenticityNotGuaranteed;
+                case 2: return TimelineEventShieldStateCode.UnknownDevice;
+                case 3: return TimelineEventShieldStateCode.UnsignedDevice;
+                case 4: return TimelineEventShieldStateCode.UnverifiedIdentity;
+                case 5: return TimelineEventShieldStateCode.VerificationViolation;
+                case 6: return TimelineEventShieldStateCode.MismatchedSender;
+                case 7: return TimelineEventShieldStateCode.SentInClear;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value) {
+                case TimelineEventShieldStateCode.AuthenticityNotGuaranteed: return ordinalConverter.write(1, into);
+                case TimelineEventShieldStateCode.UnknownDevice: return ordinalConverter.write(2, into);
+                case TimelineEventShieldStateCode.UnsignedDevice: return ordinalConverter.write(3, into);
+                case TimelineEventShieldStateCode.UnverifiedIdentity: return ordinalConverter.write(4, into);
+                case TimelineEventShieldStateCode.VerificationViolation: return ordinalConverter.write(5, into);
+                case TimelineEventShieldStateCode.MismatchedSender: return ordinalConverter.write(6, into);
+                case TimelineEventShieldStateCode.SentInClear: return ordinalConverter.write(7, into);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+
+
+/**
+ * The level of read receipt tracking for the timeline.
+ */
+export enum TimelineReadReceiptTracking {
+    /**
+     * Track read receipts for all events.
+     */
+    AllEvents,
+    /**
+     * Track read receipts only for message-like events.
+     */
+    MessageLikeEvents,
+    /**
+     * Disable read receipt tracking.
+     */
+    Disabled
+}
+
+const FfiConverterTypeTimelineReadReceiptTracking = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = TimelineReadReceiptTracking;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return TimelineReadReceiptTracking.AllEvents;
+                case 2: return TimelineReadReceiptTracking.MessageLikeEvents;
+                case 3: return TimelineReadReceiptTracking.Disabled;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value) {
+                case TimelineReadReceiptTracking.AllEvents: return ordinalConverter.write(1, into);
+                case TimelineReadReceiptTracking.MessageLikeEvents: return ordinalConverter.write(2, into);
+                case TimelineReadReceiptTracking.Disabled: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+
+
+
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+    // Get the bindings contract version from our ComponentInterface
+    const bindingsContractVersion = 30;
+    // Get the scaffolding contract version by calling the into the dylib
+    const scaffoldingContractVersion = nativeModule().ubrn_ffi_matrix_sdk_ui_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+
+    }
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeEventItemOrigin,
+    FfiConverterTypeLatestEventValueLocalState,
+    FfiConverterTypeRoomPinnedEventsChange,
+    FfiConverterTypeSpaceRoomListPaginationState,
+    FfiConverterTypeThreadListPaginationState,
+    FfiConverterTypeTimelineEventFocusThreadMode,
+    FfiConverterTypeTimelineEventShieldStateCode,
+    FfiConverterTypeTimelineReadReceiptTracking,
+  }
+});