ffi-bindings 1.0.0 → 1.0.2

package/src/generated/matrix_sdk_base.ts

@@ -0,0 +1,252 @@
+// 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, 
+  type UniffiDuration, 
+  AbstractFfiConverterByteArray, 
+  FfiConverterBool, 
+  FfiConverterDuration, 
+  FfiConverterInt32, 
+  FfiConverterOptional, 
+  FfiConverterUInt64, 
+  RustBuffer, 
+  UniffiInternalError, 
+  UniffiRustCaller, 
+  uniffiCreateFfiConverterString, 
+  uniffiCreateRecord } 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.
+
+
+
+
+
+
+
+
+
+/**
+ * The retention policy for media content used by the [`MediaStore`].
+ *
+ * [`EventCacheStore`]: crate::event_cache::store::EventCacheStore
+ */
+export type MediaRetentionPolicy = {
+    /**
+     * The maximum authorized size of the overall media cache, in bytes.
+     *
+     * The cache size is defined as the sum of the sizes of all the (possibly
+     * encrypted) media contents in the cache, excluding any metadata
+     * associated with them.
+     *
+     * If this is set and the cache size is bigger than this value, the oldest
+     * media contents in the cache will be removed during a cleanup until the
+     * cache size is below this threshold.
+     *
+     * Note that it is possible for the cache size to temporarily exceed this
+     * value between two cleanups.
+     *
+     * Defaults to 400 MiB.
+     */
+    maxCacheSize?: /*u64*/bigint,
+    /**
+     * The maximum authorized size of a single media content, in bytes.
+     *
+     * The size of a media content is the size taken by the content in the
+     * database, after it was possibly encrypted, so it might differ from the
+     * initial size of the content.
+     *
+     * The maximum authorized size of a single media content is actually the
+     * lowest value between `max_cache_size` and `max_file_size`.
+     *
+     * If it is set, media content bigger than the maximum size will not be
+     * cached. If the maximum size changed after media content that exceeds the
+     * new value was cached, the corresponding content will be removed
+     * during a cleanup.
+     *
+     * Defaults to 20 MiB.
+     */
+    maxFileSize?: /*u64*/bigint,
+    /**
+     * The duration after which unaccessed media content is considered
+     * expired.
+     *
+     * If this is set, media content whose last access is older than this
+     * duration will be removed from the media cache during a cleanup.
+     *
+     * Defaults to 60 days.
+     */
+    lastAccessExpiry?: UniffiDuration,
+    /**
+     * The duration between two automatic media cache cleanups.
+     *
+     * If this is set, a cleanup will be triggered after the given duration
+     * is elapsed, at the next call to the media cache API. If this is set to
+     * zero, each call to the media cache API will trigger a cleanup. If this
+     * is `None`, cleanups will only occur if they are triggered manually.
+     *
+     * Defaults to running cleanups daily.
+     */
+    cleanupFrequency?: UniffiDuration
+}
+
+/**
+ * Generated factory for {@link MediaRetentionPolicy} record objects.
+ */
+export const MediaRetentionPolicy = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<MediaRetentionPolicy, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<MediaRetentionPolicy>,
+
+    });
+})();
+
+const FfiConverterTypeMediaRetentionPolicy = (() => {
+    type TypeName = MediaRetentionPolicy;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                maxCacheSize: FfiConverterOptionalUInt64.read(from), 
+                maxFileSize: FfiConverterOptionalUInt64.read(from), 
+                lastAccessExpiry: FfiConverterOptionalDuration.read(from), 
+                cleanupFrequency: FfiConverterOptionalDuration.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterOptionalUInt64.write(value.maxCacheSize, into);
+            FfiConverterOptionalUInt64.write(value.maxFileSize, into);
+            FfiConverterOptionalDuration.write(value.lastAccessExpiry, into);
+            FfiConverterOptionalDuration.write(value.cleanupFrequency, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalUInt64.allocationSize(value.maxCacheSize) + 
+            FfiConverterOptionalUInt64.allocationSize(value.maxFileSize) + 
+            FfiConverterOptionalDuration.allocationSize(value.lastAccessExpiry) + 
+            FfiConverterOptionalDuration.allocationSize(value.cleanupFrequency);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+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);
+
+
+
+
+/**
+ * Represents the state of a room encryption.
+ */
+export enum EncryptionState {
+    /**
+     * The room is encrypted.
+     */
+    Encrypted,
+    /**
+     * The room is not encrypted.
+     */
+    NotEncrypted,
+    /**
+     * The state of the room encryption is unknown, probably because the
+     * `/sync` did not provide all data needed to decide.
+     */
+    Unknown
+}
+
+const FfiConverterTypeEncryptionState = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = EncryptionState;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return EncryptionState.Encrypted;
+                case 2: return EncryptionState.NotEncrypted;
+                case 3: return EncryptionState.Unknown;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value) {
+                case EncryptionState.Encrypted: return ordinalConverter.write(1, into);
+                case EncryptionState.NotEncrypted: return ordinalConverter.write(2, into);
+                case EncryptionState.Unknown: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+
+
+// FfiConverter for UniffiDuration | undefined
+const FfiConverterOptionalDuration = new FfiConverterOptional(FfiConverterDuration);
+
+
+// FfiConverter for /*u64*/bigint | undefined
+const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
+
+
+
+/**
+ * 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_base_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+
+    }
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeEncryptionState,
+    FfiConverterTypeMediaRetentionPolicy,
+  }
+});

package/src/generated/matrix_sdk_common.ts

@@ -0,0 +1,370 @@
+// 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, 
+  FfiConverterOptional, 
+  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);
+
+
+// Enum: BackgroundTaskFailureReason
+export enum BackgroundTaskFailureReason_Tags {
+    Panic = "Panic",
+    Error = "Error",
+    EarlyTermination = "EarlyTermination"
+}
+/**
+ * Reason why a background task failed.
+ */
+export const BackgroundTaskFailureReason = (() => {
+    
+
+    type Panic__interface = {
+        tag: BackgroundTaskFailureReason_Tags.Panic;
+        inner: Readonly<{message: string | undefined; panicBacktrace: string | undefined}>
+    };
+
+    
+    /**
+     * The task panicked.
+     */
+    class Panic_ extends UniffiEnum implements Panic__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "BackgroundTaskFailureReason";
+        readonly tag = BackgroundTaskFailureReason_Tags.Panic;
+        readonly inner: Readonly<{message: string | undefined; panicBacktrace: string | undefined}>;
+        constructor(inner: { 
+        /**
+         * The panic message, if it could be extracted.
+         */message: string | undefined, 
+        /**
+         * Backtrace captured after the panic (if available).
+         */panicBacktrace: string | undefined }) {
+            super("BackgroundTaskFailureReason", "Panic");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { 
+        /**
+         * The panic message, if it could be extracted.
+         */message: string | undefined, 
+        /**
+         * Backtrace captured after the panic (if available).
+         */panicBacktrace: string | undefined }): Panic_ {
+            return new Panic_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Panic_ {
+            return obj.tag === BackgroundTaskFailureReason_Tags.Panic;
+        }
+        
+
+        
+
+    }
+    
+
+    type Error__interface = {
+        tag: BackgroundTaskFailureReason_Tags.Error;
+        inner: Readonly<{error: string}>
+    };
+
+    
+    /**
+     * The task returned an error.
+     */
+    class Error_ extends UniffiEnum implements Error__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "BackgroundTaskFailureReason";
+        readonly tag = BackgroundTaskFailureReason_Tags.Error;
+        readonly inner: Readonly<{error: string}>;
+        constructor(inner: { 
+        /**
+         * String representation of the error.
+         */error: string }) {
+            super("BackgroundTaskFailureReason", "Error");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { 
+        /**
+         * String representation of the error.
+         */error: string }): Error_ {
+            return new Error_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Error_ {
+            return obj.tag === BackgroundTaskFailureReason_Tags.Error;
+        }
+        
+
+        
+
+    }
+    
+
+    type EarlyTermination__interface = {
+        tag: BackgroundTaskFailureReason_Tags.EarlyTermination
+    };
+
+    
+    /**
+     * The task ended unexpectedly (for tasks expected to run forever).
+     */
+    class EarlyTermination_ extends UniffiEnum implements EarlyTermination__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "BackgroundTaskFailureReason";
+        readonly tag = BackgroundTaskFailureReason_Tags.EarlyTermination;
+        constructor() {
+            super("BackgroundTaskFailureReason", "EarlyTermination");
+        }
+
+        static new(): EarlyTermination_ {
+            return new EarlyTermination_();
+        }
+
+        static instanceOf(obj: any): obj is EarlyTermination_ {
+            return obj.tag === BackgroundTaskFailureReason_Tags.EarlyTermination;
+        }
+        
+
+        
+
+    }
+
+    function instanceOf(obj: any): obj is BackgroundTaskFailureReason {
+        return obj[uniffiTypeNameSymbol] === "BackgroundTaskFailureReason";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  Panic: Panic_, 
+  Error: Error_, 
+  EarlyTermination: EarlyTermination_
+    });
+
+})();
+
+
+/**
+ * Reason why a background task failed.
+ */
+
+export type BackgroundTaskFailureReason = InstanceType<
+    typeof BackgroundTaskFailureReason[keyof Omit<typeof BackgroundTaskFailureReason, 'instanceOf'>]
+>;
+
+// FfiConverter for enum BackgroundTaskFailureReason
+const FfiConverterTypeBackgroundTaskFailureReason = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = BackgroundTaskFailureReason;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new BackgroundTaskFailureReason.Panic({message: FfiConverterOptionalString.read(from), panicBacktrace: FfiConverterOptionalString.read(from) });
+                case 2: return new BackgroundTaskFailureReason.Error({error: FfiConverterString.read(from) });
+                case 3: return new BackgroundTaskFailureReason.EarlyTermination();
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value.tag) {
+                case BackgroundTaskFailureReason_Tags.Panic: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterOptionalString.write(inner.message, into);
+                    FfiConverterOptionalString.write(inner.panicBacktrace, into);
+                    return;
+                }
+                case BackgroundTaskFailureReason_Tags.Error: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.error, into);
+                    return;
+                }
+                case BackgroundTaskFailureReason_Tags.EarlyTermination: {
+                    ordinalConverter.write(3, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that BackgroundTaskFailureReason_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case BackgroundTaskFailureReason_Tags.Panic: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterOptionalString.allocationSize(inner.message);
+                    size += FfiConverterOptionalString.allocationSize(inner.panicBacktrace);
+                    return size;
+                }
+                case BackgroundTaskFailureReason_Tags.Error: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterString.allocationSize(inner.error);
+                    return size;
+                }
+                case BackgroundTaskFailureReason_Tags.EarlyTermination: {
+                    return ordinalConverter.allocationSize(3);
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+/**
+ * A machine-readable representation of the authenticity for a `ShieldState`.
+ */
+export enum ShieldStateCode {
+    /**
+     * 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
+}
+
+const FfiConverterTypeShieldStateCode = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = ShieldStateCode;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ShieldStateCode.AuthenticityNotGuaranteed;
+                case 2: return ShieldStateCode.UnknownDevice;
+                case 3: return ShieldStateCode.UnsignedDevice;
+                case 4: return ShieldStateCode.UnverifiedIdentity;
+                case 5: return ShieldStateCode.VerificationViolation;
+                case 6: return ShieldStateCode.MismatchedSender;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value) {
+                case ShieldStateCode.AuthenticityNotGuaranteed: return ordinalConverter.write(1, into);
+                case ShieldStateCode.UnknownDevice: return ordinalConverter.write(2, into);
+                case ShieldStateCode.UnsignedDevice: return ordinalConverter.write(3, into);
+                case ShieldStateCode.UnverifiedIdentity: return ordinalConverter.write(4, into);
+                case ShieldStateCode.VerificationViolation: return ordinalConverter.write(5, into);
+                case ShieldStateCode.MismatchedSender: return ordinalConverter.write(6, into);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+
+
+/**
+ * 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_common_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+
+    }
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeBackgroundTaskFailureReason,
+    FfiConverterTypeShieldStateCode,
+  }
+});