From 4bbfe7e2cc6e9d6977b093d2f23e05e3124ab6fa Mon Sep 17 00:00:00 2001 From: Tulir Asokan Date: Thu, 16 Jul 2026 21:07:51 +0300 Subject: [PATCH 01/14] msgconv/from-signal: handle attachment mime types more like signal desktop --- pkg/connector/capabilities.go | 7 +++++-- pkg/msgconv/from-signal.go | 18 ++++++++++++------ 2 files changed, 17 insertions(+), 8 deletions(-) diff --git a/pkg/connector/capabilities.go b/pkg/connector/capabilities.go index 930366e..803dc18 100644 --- a/pkg/connector/capabilities.go +++ b/pkg/connector/capabilities.go @@ -38,7 +38,7 @@ func supportedIfFFmpeg() event.CapabilitySupportLevel { } func capID() string { - base := "fi.mau.signal.capabilities.2026_07_14" + base := "fi.mau.signal.capabilities.2026_07_16" if ffmpeg.Supported() { return base + "+ffmpeg" } @@ -77,6 +77,7 @@ var signalCaps = &event.RoomFeatures{ "image/jpeg": event.CapLevelFullySupported, "image/webp": event.CapLevelFullySupported, "image/bmp": event.CapLevelFullySupported, + "image/avif": event.CapLevelFullySupported, }, MaxWidth: 4096, MaxHeight: 4096, @@ -98,6 +99,8 @@ var signalCaps = &event.RoomFeatures{ MimeTypes: map[string]event.CapabilitySupportLevel{ "audio/aac": event.CapLevelFullySupported, "audio/mpeg": event.CapLevelFullySupported, + "audio/mp3": event.CapLevelFullySupported, + "audio/flac": event.CapLevelFullySupported, }, MaxSize: MaxFileSize, }, @@ -237,5 +240,5 @@ func (s *SignalConnector) GetCapabilities() *bridgev2.NetworkGeneralCapabilities } func (s *SignalConnector) GetBridgeInfoVersion() (info, capabilities int) { - return 1, 9 + return 1, 10 } diff --git a/pkg/msgconv/from-signal.go b/pkg/msgconv/from-signal.go index d39ee44..612bc28 100644 --- a/pkg/msgconv/from-signal.go +++ b/pkg/msgconv/from-signal.go @@ -23,6 +23,7 @@ import ( "errors" "fmt" "io" + "mime" "net/http" "os" "strconv" @@ -569,15 +570,20 @@ func (mc *MessageConverter) reuploadAttachment(ctx context.Context, att *signalp content.Info.Blurhash = att.GetBlurHash() content.Info.AnoaBlurhash = att.GetBlurHash() } - switch strings.Split(content.Info.MimeType, "/")[0] { - case "image": + plainMime, _, _ := mime.ParseMediaType(content.Info.MimeType) + // Supported mime types from https://github.com/signalapp/Signal-Desktop/blob/main/ts/util/GoogleChrome.std.ts + switch plainMime { + case "image/avif", "image/bmp", "image/gif", "image/jpeg", "image/webp", "image/x-xbitmap", + "image/vnd.microsoft.icon", "image/ico", "image/icon", "image/x-icon", "image/png", "image/apng": content.MsgType = event.MsgImage - case "video": + case "video/mp4", "video/ogg", "video/webm": content.MsgType = event.MsgVideo - case "audio": - content.MsgType = event.MsgAudio default: - content.MsgType = event.MsgFile + if strings.HasPrefix(plainMime, "audio/") && !strings.HasSuffix(plainMime, "aiff") { + content.MsgType = event.MsgAudio + } else { + content.MsgType = event.MsgFile + } } var extra map[string]any if att.GetFlags()&uint32(signalpb.AttachmentPointer_GIF) != 0 { From bed128ab8405ab564b095595e8907f0a398018f0 Mon Sep 17 00:00:00 2001 From: Tulir Asokan Date: Sat, 18 Jul 2026 16:51:55 +0300 Subject: [PATCH 02/14] dependencies: update mautrix-go --- go.mod | 4 +- go.sum | 8 ++-- .../store/upgrades/16-remove-extra-prekeys.go | 40 +++++++++---------- .../upgrades/20-fix-backup-chat-columns.go | 22 +++++----- pkg/signalmeow/store/upgrades/upgrades.go | 10 ++--- 5 files changed, 40 insertions(+), 44 deletions(-) diff --git a/go.mod b/go.mod index 694bb3d..df3521e 100644 --- a/go.mod +++ b/go.mod @@ -14,14 +14,14 @@ require ( github.com/rs/zerolog v1.35.1 github.com/stretchr/testify v1.11.1 github.com/tidwall/gjson v1.19.0 - go.mau.fi/util v0.9.11 + go.mau.fi/util v0.9.12-0.20260719092501-f9c03d846391 golang.org/x/crypto v0.54.0 golang.org/x/exp v0.0.0-20260709172345-9ea1abe57597 golang.org/x/net v0.57.0 golang.org/x/sync v0.22.0 google.golang.org/protobuf v1.36.11 gopkg.in/yaml.v3 v3.0.1 - maunium.net/go/mautrix v0.29.0 + maunium.net/go/mautrix v0.29.1-0.20260719130752-5743d9b6f27e ) require ( diff --git a/go.sum b/go.sum index 968612c..409741f 100644 --- a/go.sum +++ b/go.sum @@ -61,8 +61,8 @@ github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY= github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28= github.com/yuin/goldmark v1.8.4 h1:oat/nd3U6NeQqFEL3xpEJq7d7c86NI+DbSNGAs4xnjA= github.com/yuin/goldmark v1.8.4/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg= -go.mau.fi/util v0.9.11 h1:Cus1Lu/t7d3OG6VF4aYWvlUUS0Q4O1/lcpPNJZ0jsw0= -go.mau.fi/util v0.9.11/go.mod h1:xunp/oIQfFD68HHcNHfG0pOiHkvEtDhTweeIwKJ//+Q= +go.mau.fi/util v0.9.12-0.20260719092501-f9c03d846391 h1:lsvBEY8MJfYdV61YbwikiQvb0Al/onbmLW5wfl/0tag= +go.mau.fi/util v0.9.12-0.20260719092501-f9c03d846391/go.mod h1:xunp/oIQfFD68HHcNHfG0pOiHkvEtDhTweeIwKJ//+Q= go.mau.fi/zeroconfig v0.2.0 h1:e/OGEERqVRRKlgaro7E6bh8xXiKFSXB3eNNIud7FUjU= go.mau.fi/zeroconfig v0.2.0/go.mod h1:J0Vn0prHNOm493oZoQ84kq83ZaNCYZnq+noI1b1eN8w= golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw= @@ -91,5 +91,5 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= maunium.net/go/mauflag v1.0.0 h1:YiaRc0tEI3toYtJMRIfjP+jklH45uDHtT80nUamyD4M= maunium.net/go/mauflag v1.0.0/go.mod h1:nLivPOpTpHnpzEh8jEdSL9UqO9+/KBJFmNRlwKfkPeA= -maunium.net/go/mautrix v0.29.0 h1:OkcBJF1dvp+93EgahxMxOUZZOrGTYculI9IprvRIMOQ= -maunium.net/go/mautrix v0.29.0/go.mod h1:LynuVr8N9nWsE1N4WAE+vItRACDB1pt9M3gN4SIBpeY= +maunium.net/go/mautrix v0.29.1-0.20260719130752-5743d9b6f27e h1:tPGnL/s5dfqhNoVLvmCKY3V60migQsNHBXAhUALBSd8= +maunium.net/go/mautrix v0.29.1-0.20260719130752-5743d9b6f27e/go.mod h1:PeLuIih5jnbwb2xKNNi0Te7AtINEQE2Uv3p6iG3RV80= diff --git a/pkg/signalmeow/store/upgrades/16-remove-extra-prekeys.go b/pkg/signalmeow/store/upgrades/16-remove-extra-prekeys.go index 5046abf..44c70c2 100644 --- a/pkg/signalmeow/store/upgrades/16-remove-extra-prekeys.go +++ b/pkg/signalmeow/store/upgrades/16-remove-extra-prekeys.go @@ -58,24 +58,22 @@ func deleteExtraPrekeys(ctx context.Context, db *dbutil.Database, selectQuery, d return nil } -func init() { - Table.Register(-1, 16, 13, "Remove extra prekeys", dbutil.TxnModeOn, func(ctx context.Context, db *dbutil.Database) error { - err := deleteExtraPrekeys(ctx, db, ` - SELECT account_id, service_id, COUNT(*), MAX(key_id) FROM signalmeow_pre_keys WHERE is_signed=false GROUP BY 1, 2 - `, ` - DELETE FROM signalmeow_pre_keys WHERE account_id=$1 AND service_id=$2 AND is_signed=false AND key_id<$3 - `) - if err != nil { - return fmt.Errorf("failed to process EC: %w", err) - } - err = deleteExtraPrekeys(ctx, db, ` - SELECT account_id, service_id, COUNT(*), MAX(key_id) FROM signalmeow_kyber_pre_keys WHERE is_last_resort=false GROUP BY 1, 2 - `, ` - DELETE FROM signalmeow_kyber_pre_keys WHERE account_id=$1 AND service_id=$2 AND is_last_resort=false AND key_id<$3 - `) - if err != nil { - return fmt.Errorf("failed to process kyber: %w", err) - } - return nil - }) -} +var upgradeV16 = dbutil.WrapUpgrade(-1, 16, 13, "Remove extra prekeys", dbutil.TxnModeOn, func(ctx context.Context, db *dbutil.Database) error { + err := deleteExtraPrekeys(ctx, db, ` + SELECT account_id, service_id, COUNT(*), MAX(key_id) FROM signalmeow_pre_keys WHERE is_signed=false GROUP BY 1, 2 + `, ` + DELETE FROM signalmeow_pre_keys WHERE account_id=$1 AND service_id=$2 AND is_signed=false AND key_id<$3 + `) + if err != nil { + return fmt.Errorf("failed to process EC: %w", err) + } + err = deleteExtraPrekeys(ctx, db, ` + SELECT account_id, service_id, COUNT(*), MAX(key_id) FROM signalmeow_kyber_pre_keys WHERE is_last_resort=false GROUP BY 1, 2 + `, ` + DELETE FROM signalmeow_kyber_pre_keys WHERE account_id=$1 AND service_id=$2 AND is_last_resort=false AND key_id<$3 + `) + if err != nil { + return fmt.Errorf("failed to process kyber: %w", err) + } + return nil +}) diff --git a/pkg/signalmeow/store/upgrades/20-fix-backup-chat-columns.go b/pkg/signalmeow/store/upgrades/20-fix-backup-chat-columns.go index d409fe6..1313f11 100644 --- a/pkg/signalmeow/store/upgrades/20-fix-backup-chat-columns.go +++ b/pkg/signalmeow/store/upgrades/20-fix-backup-chat-columns.go @@ -22,15 +22,13 @@ import ( "go.mau.fi/util/dbutil" ) -func init() { - Table.Register(-1, 20, 13, "Add missing columns for backup chat table", dbutil.TxnModeOn, func(ctx context.Context, db *dbutil.Database) (err error) { - var exists bool - if exists, err = db.ColumnExists(ctx, "signalmeow_backup_chat", "latest_message_id"); err == nil && !exists { - _, err = db.Exec(ctx, ` - ALTER TABLE signalmeow_backup_chat ADD COLUMN latest_message_id BIGINT; - ALTER TABLE signalmeow_backup_chat ADD COLUMN total_message_count INTEGER; - `) - } - return - }) -} +var upgradeV20 = dbutil.WrapUpgrade(-1, 20, 13, "Add missing columns for backup chat table", dbutil.TxnModeOn, func(ctx context.Context, db *dbutil.Database) (err error) { + var exists bool + if exists, err = db.ColumnExists(ctx, "signalmeow_backup_chat", "latest_message_id"); err == nil && !exists { + _, err = db.Exec(ctx, ` + ALTER TABLE signalmeow_backup_chat ADD COLUMN latest_message_id BIGINT; + ALTER TABLE signalmeow_backup_chat ADD COLUMN total_message_count INTEGER; + `) + } + return +}) diff --git a/pkg/signalmeow/store/upgrades/upgrades.go b/pkg/signalmeow/store/upgrades/upgrades.go index 19a6414..f9e6350 100644 --- a/pkg/signalmeow/store/upgrades/upgrades.go +++ b/pkg/signalmeow/store/upgrades/upgrades.go @@ -22,11 +22,11 @@ import ( "go.mau.fi/util/dbutil" ) -var Table dbutil.UpgradeTable - //go:embed *.sql var rawUpgrades embed.FS -func init() { - Table.RegisterFS(rawUpgrades) -} +var Table = dbutil.BuildUpgradeTable(). + WithFS(rawUpgrades). + With(upgradeV16). + With(upgradeV20). + Finish() From f25f588bc437c509b4f771d07cfb2e4978f83dc4 Mon Sep 17 00:00:00 2001 From: Nick Mills-Barrett Date: Tue, 21 Jul 2026 17:58:23 +0100 Subject: [PATCH 03/14] login: implement proper error handling (#657) --- pkg/connector/login.go | 93 +++++++++++++++++++++++++++++++--- pkg/signalmeow/provisioning.go | 13 ++++- 2 files changed, 96 insertions(+), 10 deletions(-) diff --git a/pkg/connector/login.go b/pkg/connector/login.go index 9116390..43a78d6 100644 --- a/pkg/connector/login.go +++ b/pkg/connector/login.go @@ -18,9 +18,12 @@ package connector import ( "context" + "errors" "fmt" + "net/http" "time" + "github.com/coder/websocket" "github.com/google/uuid" "maunium.net/go/mautrix/bridgev2" "maunium.net/go/mautrix/bridgev2/database" @@ -70,6 +73,75 @@ const ( LoginStepComplete = "fi.mau.signal.login.complete" ) +const ( + qrRefreshInterval = 45 * time.Second + maxQRRefreshes = 20 +) + +var ( + ErrLoginTimedOut = bridgev2.RespError{ + ErrCode: "FI.MAU.BRIDGE.LOGIN_TIMED_OUT", + Err: "The QR code wasn't scanned in time, please start a new login", + StatusCode: http.StatusGone, + } + ErrLoginCancelled = bridgev2.RespError{ + ErrCode: "FI.MAU.BRIDGE.LOGIN_CANCELLED", + Err: "Login process was cancelled", + StatusCode: http.StatusGone, + } + ErrDeviceLinkMissingCapability = bridgev2.RespError{ + ErrCode: "FI.MAU.SIGNAL.DEVICE_LINK_MISSING_CAPABILITY", + Err: "Signal rejected linking because the bridge is missing a capability required by your account's other devices. Please try again later", + StatusCode: http.StatusConflict, + } + ErrDeviceLimitReached = bridgev2.RespError{ + ErrCode: "FI.MAU.SIGNAL.DEVICE_LIMIT_REACHED", + Err: "Your Signal account already has the maximum number of linked devices. Remove one in the Signal app and try again", + StatusCode: http.StatusBadRequest, + } + ErrDeviceLinkCodeInvalid = bridgev2.RespError{ + ErrCode: "FI.MAU.SIGNAL.DEVICE_LINK_CODE_INVALID", + Err: "The scanned QR code was invalid or already used, please start a new login", + StatusCode: http.StatusForbidden, + } + ErrDeviceLinkRateLimited = bridgev2.RespError{ + ErrCode: "FI.MAU.SIGNAL.DEVICE_LINK_RATE_LIMITED", + Err: "Signal rate-limited the linking attempt, please wait a few minutes and try again", + StatusCode: http.StatusTooManyRequests, + } + ErrDeviceLinkRejected = bridgev2.RespError{ + ErrCode: "FI.MAU.SIGNAL.DEVICE_LINK_REJECTED", + Err: "Signal rejected linking the device", + StatusCode: http.StatusBadRequest, + } +) + +// Statuses of PUT /v1/devices/link, per Signal-Server's DeviceController +func wrapProvisioningError(err error) error { + var linkErr signalmeow.DeviceLinkError + if errors.As(err, &linkErr) { + switch linkErr.StatusCode { + case http.StatusConflict: + return ErrDeviceLinkMissingCapability + case http.StatusLengthRequired: + return ErrDeviceLimitReached + case http.StatusForbidden: + return ErrDeviceLinkCodeInvalid + case http.StatusTooManyRequests: + return ErrDeviceLinkRateLimited + default: + if linkErr.Message != "" { + return ErrDeviceLinkRejected.AppendMessage(" (HTTP %d: %s)", linkErr.StatusCode, linkErr.Message) + } + return ErrDeviceLinkRejected.AppendMessage(" (HTTP %d)", linkErr.StatusCode) + } + } + if websocket.CloseStatus(err) == websocket.StatusGoingAway { + return ErrLoginTimedOut + } + return err +} + func (qr *QRLogin) Start(ctx context.Context) (*bridgev2.LoginStep, error) { log := qr.Main.Bridge.Log.With(). Str("action", "login"). @@ -85,14 +157,16 @@ func (qr *QRLogin) Start(ctx context.Context) (*bridgev2.LoginStep, error) { select { case resp = <-qr.ProvChan: if resp.Err != nil { - return nil, resp.Err + return nil, wrapProvisioningError(resp.Err) } else if resp.State != signalmeow.StateProvisioningURLReceived { return nil, fmt.Errorf("unexpected state %v", resp.State) } case <-ctx.Done(): cancel() - return nil, ctx.Err() - // TODO separate timeout here? + if errors.Is(ctx.Err(), context.DeadlineExceeded) { + return nil, ErrLoginTimedOut + } + return nil, ErrLoginCancelled } return &bridgev2.LoginStep{ Type: bridgev2.LoginStepTypeDisplayAndWait, @@ -114,7 +188,7 @@ func (qr *QRLogin) Wait(ctx context.Context) (*bridgev2.LoginStep, error) { case resp := <-qr.ProvChan: if resp.Err != nil { qr.cancelChan() - return nil, resp.Err + return nil, wrapProvisioningError(resp.Err) } else if resp.State != signalmeow.StateProvisioningDataReceived { qr.cancelChan() return nil, fmt.Errorf("unexpected state %v", resp.State) @@ -126,17 +200,20 @@ func (qr *QRLogin) Wait(ctx context.Context) (*bridgev2.LoginStep, error) { // Server will timeout the request after 60 seconds, but Signal Desktop opens // a new socket and gets a new QR code after 45 seconds. We should do the same. - case <-time.After(45 * time.Second): + case <-time.After(qrRefreshInterval): qr.cancelChan() qr.newQRCount++ - if qr.newQRCount >= 6 { - return nil, fmt.Errorf("too many QR code refreshes") + if qr.newQRCount >= maxQRRefreshes { + return nil, ErrLoginTimedOut } return qr.Start(ctx) case <-ctx.Done(): qr.cancelChan() - return nil, ctx.Err() + if errors.Is(ctx.Err(), context.DeadlineExceeded) { + return nil, ErrLoginTimedOut + } + return nil, ErrLoginCancelled } } diff --git a/pkg/signalmeow/provisioning.go b/pkg/signalmeow/provisioning.go index 787e2d8..250e5d3 100644 --- a/pkg/signalmeow/provisioning.go +++ b/pkg/signalmeow/provisioning.go @@ -76,6 +76,15 @@ type ProvisioningResponse struct { Err error } +type DeviceLinkError struct { + StatusCode int + Message string +} + +func (dle DeviceLinkError) Error() string { + return fmt.Sprintf("non-200 status code (%d) from devices response: %s", dle.StatusCode, dle.Message) +} + func PerformProvisioning(ctx context.Context, deviceStore store.DeviceStore, deviceName string, allowBackup bool) chan ProvisioningResponse { log := zerolog.Ctx(ctx).With().Str("action", "perform provisioning").Logger() c := make(chan ProvisioningResponse, 4) @@ -441,9 +450,9 @@ func confirmDevice( return nil, fmt.Errorf("failed to read from websocket after devices call: %w", err) } - status := int(*receivedMsg.Response.Status) + status := int(receivedMsg.GetResponse().GetStatus()) if status < 200 || status >= 300 { - return nil, fmt.Errorf("non-200 status code (%d) from devices response: %s", status, *receivedMsg.Response.Message) + return nil, DeviceLinkError{StatusCode: status, Message: receivedMsg.GetResponse().GetMessage()} } // unmarshal JSON response into ConfirmDeviceResponse From 6e57bf3956e96a4e1664bb60c76972f7e92c85a8 Mon Sep 17 00:00:00 2001 From: Bradley Birch Date: Thu, 23 Jul 2026 14:46:26 +0100 Subject: [PATCH 04/14] capabilities: add more details for polls (#659) --- go.mod | 2 +- go.sum | 4 ++-- pkg/connector/capabilities.go | 33 +++++++++++++++++++-------------- 3 files changed, 22 insertions(+), 17 deletions(-) diff --git a/go.mod b/go.mod index df3521e..0c92e4c 100644 --- a/go.mod +++ b/go.mod @@ -21,7 +21,7 @@ require ( golang.org/x/sync v0.22.0 google.golang.org/protobuf v1.36.11 gopkg.in/yaml.v3 v3.0.1 - maunium.net/go/mautrix v0.29.1-0.20260719130752-5743d9b6f27e + maunium.net/go/mautrix v0.29.1-0.20260723095015-f7cfa8766d2b ) require ( diff --git a/go.sum b/go.sum index 409741f..d275694 100644 --- a/go.sum +++ b/go.sum @@ -91,5 +91,5 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= maunium.net/go/mauflag v1.0.0 h1:YiaRc0tEI3toYtJMRIfjP+jklH45uDHtT80nUamyD4M= maunium.net/go/mauflag v1.0.0/go.mod h1:nLivPOpTpHnpzEh8jEdSL9UqO9+/KBJFmNRlwKfkPeA= -maunium.net/go/mautrix v0.29.1-0.20260719130752-5743d9b6f27e h1:tPGnL/s5dfqhNoVLvmCKY3V60migQsNHBXAhUALBSd8= -maunium.net/go/mautrix v0.29.1-0.20260719130752-5743d9b6f27e/go.mod h1:PeLuIih5jnbwb2xKNNi0Te7AtINEQE2Uv3p6iG3RV80= +maunium.net/go/mautrix v0.29.1-0.20260723095015-f7cfa8766d2b h1:5ZKdE95/xcAGDUtS7IYhaa/ENdEmedG5CEjkgkzu6H8= +maunium.net/go/mautrix v0.29.1-0.20260723095015-f7cfa8766d2b/go.mod h1:PeLuIih5jnbwb2xKNNi0Te7AtINEQE2Uv3p6iG3RV80= diff --git a/pkg/connector/capabilities.go b/pkg/connector/capabilities.go index 803dc18..228ac94 100644 --- a/pkg/connector/capabilities.go +++ b/pkg/connector/capabilities.go @@ -38,7 +38,7 @@ func supportedIfFFmpeg() event.CapabilitySupportLevel { } func capID() string { - base := "fi.mau.signal.capabilities.2026_07_16" + base := "fi.mau.signal.capabilities.2026_07_22" if ffmpeg.Supported() { return base + "+ffmpeg" } @@ -154,18 +154,23 @@ var signalCaps = &event.RoomFeatures{ event.MemberActionBan: event.CapLevelFullySupported, event.MemberActionKick: event.CapLevelFullySupported, }, - MaxTextLength: MaxTextLength, // TODO support arbitrary sized text messages with files - LocationMessage: event.CapLevelPartialSupport, - Poll: event.CapLevelFullySupported, - Thread: event.CapLevelUnsupported, - Reply: event.CapLevelFullySupported, - Edit: event.CapLevelFullySupported, - EditMaxCount: 10, - EditMaxAge: ptr.Ptr(jsontime.S(24 * time.Hour)), - Delete: event.CapLevelFullySupported, - DeleteForMe: false, - DeleteMaxAge: ptr.Ptr(jsontime.S(24 * time.Hour)), - DisappearingTimer: signalDisappearingCap, + MaxTextLength: MaxTextLength, // TODO support arbitrary sized text messages with files + LocationMessage: event.CapLevelPartialSupport, + Poll: event.CapLevelFullySupported, + PollEnd: event.CapLevelUnsupported, + PollHiddenVotes: event.CapLevelUnsupported, + PollDuplicateOptions: event.CapLevelFullySupported, + PollMaxOptions: 10, + PollOptionMaxLength: 100, + Thread: event.CapLevelUnsupported, + Reply: event.CapLevelFullySupported, + Edit: event.CapLevelFullySupported, + EditMaxCount: 10, + EditMaxAge: ptr.Ptr(jsontime.S(24 * time.Hour)), + Delete: event.CapLevelFullySupported, + DeleteForMe: false, + DeleteMaxAge: ptr.Ptr(jsontime.S(24 * time.Hour)), + DisappearingTimer: signalDisappearingCap, Reaction: event.CapLevelFullySupported, ReactionCount: 1, @@ -240,5 +245,5 @@ func (s *SignalConnector) GetCapabilities() *bridgev2.NetworkGeneralCapabilities } func (s *SignalConnector) GetBridgeInfoVersion() (info, capabilities int) { - return 1, 10 + return 1, 11 } From 3ddb32dd23a3dc022324aa77f1670a900013949b Mon Sep 17 00:00:00 2001 From: Nick Mills-Barrett Date: Thu, 6 Aug 2026 17:15:21 +0100 Subject: [PATCH 05/14] handle*: insert stub message rows for old edit events (#661) Co-authored-by: Tulir Asokan --- pkg/connector/handlematrix.go | 31 +++++++++++++++++++++++++++++ pkg/connector/handlesignal.go | 37 +++++++++++++++++++++++++++++++++-- 2 files changed, 66 insertions(+), 2 deletions(-) diff --git a/pkg/connector/handlematrix.go b/pkg/connector/handlematrix.go index 9eb81c3..da7b863 100644 --- a/pkg/connector/handlematrix.go +++ b/pkg/connector/handlematrix.go @@ -180,12 +180,43 @@ func (s *SignalClient) HandleMatrixEdit(ctx context.Context, msg *bridgev2.Matri if err != nil { return bridgev2.WrapErrorInStatus(err).WithSendNotice(true) } + prevID := msg.EditTarget.ID msg.EditTarget.ID = signalid.MakeMessageID(s.Client.Store.ACI, ts) msg.EditTarget.Metadata = &signalid.MessageMetadata{ContainsAttachments: len(converted.Attachments) > 0} msg.EditTarget.EditCount++ + if prevID != msg.EditTarget.ID { + err = s.Main.Bridge.DB.Message.Update(ctx, msg.EditTarget) + if err != nil { + zerolog.Ctx(ctx).Err(err).Msg("Failed to save message after editing") + } else { + saveEditStub(ctx, s.Main.Bridge, prevID, msg.EditTarget) + } + } return nil } +// saveEditStub saves a placeholder message row pointing at the pre-edit ID of a message, such that +// duplicate checks on incoming edits find it and are dropped. This is necessary because the first +// time we see an edit it modifies the ID in place. +func saveEditStub(ctx context.Context, bridge *bridgev2.Bridge, prevID networkid.MessageID, target *database.Message) { + stub := &database.Message{ + ID: prevID, + PartID: editStubPartID, + Room: target.Room, + SenderID: target.SenderID, + SenderMXID: target.SenderMXID, + Timestamp: target.Timestamp, + } + stub.SetFakeMXID() + err := bridge.DB.Message.Insert(ctx, stub) + if err != nil { + zerolog.Ctx(ctx).Warn().Err(err). + Str("prev_message_id", string(prevID)). + Str("message_id", string(target.ID)). + Msg("Failed to save stub row for pre-edit message ID") + } +} + func (s *SignalClient) PreHandleMatrixReaction(ctx context.Context, msg *bridgev2.MatrixReaction) (bridgev2.MatrixReactionPreResponse, error) { return bridgev2.MatrixReactionPreResponse{ SenderID: signalid.MakeUserID(s.Client.Store.ACI), diff --git a/pkg/connector/handlesignal.go b/pkg/connector/handlesignal.go index 329b2cf..7618514 100644 --- a/pkg/connector/handlesignal.go +++ b/pkg/connector/handlesignal.go @@ -20,6 +20,7 @@ import ( "context" "encoding/base64" "fmt" + "slices" "strings" "time" @@ -358,20 +359,52 @@ func (evt *Bv2ChatEvent) ConvertMessage(ctx context.Context, portal *bridgev2.Po return converted, nil } +const editStubPartID networkid.PartID = "editstub" + +func isEditStub(msg *database.Message) bool { + return msg.PartID == editStubPartID +} + +// editStubMessage returns a non-bridged message part which is saved as a placeholder row pointing +// at the pre-edit ID of a message, such that duplicate checks on incoming edits find it and are +// dropped. This is necessary because the first time we see an edit it modifies the ID in place. +func editStubMessage() *bridgev2.ConvertedMessage { + return &bridgev2.ConvertedMessage{ + Parts: []*bridgev2.ConvertedMessagePart{{ + ID: editStubPartID, + Type: event.EventMessage, + Content: &event.MessageEventContent{}, + DontBridge: true, + }}, + } +} + func (evt *Bv2ChatEvent) ConvertEdit(ctx context.Context, portal *bridgev2.Portal, intent bridgev2.MatrixAPI, existing []*database.Message) (*bridgev2.ConvertedEdit, error) { editMsg, ok := evt.Event.(*signalpb.EditMessage) if !ok { return nil, fmt.Errorf("ConvertEdit() called for non-EditMessage event") } + existing = slices.DeleteFunc(slices.Clone(existing), isEditStub) + if len(existing) == 0 { + return nil, fmt.Errorf("%w: edit target has already been edited", bridgev2.ErrIgnoringRemoteEvent) + } // TODO tell converter about existing parts to avoid reupload? converted := evt.s.Main.MsgConv.ToMatrix(ctx, evt.s.Client, portal, evt.Info.Sender, intent, editMsg.GetDataMessage(), nil) // TODO can anything other than the text be edited? editPart := converted.Parts[len(converted.Parts)-1].ToEditPart(existing[len(existing)-1]) + prevID := editPart.Part.ID + // Clone the database message struct to avoid mutating the ID. + // The ID from the original struct is used for AddedParts (we specifically want the old ID for that) + editPart.Part = ptr.Clone(editPart.Part) editPart.Part.EditCount++ editPart.Part.ID = signalid.MakeMessageID(evt.Info.Sender, editMsg.GetDataMessage().GetTimestamp()) - return &bridgev2.ConvertedEdit{ + convertedEdit := &bridgev2.ConvertedEdit{ ModifiedParts: []*bridgev2.ConvertedEditPart{editPart}, - }, nil + } + if prevID != editPart.Part.ID { + convertedEdit.AddedParts = editStubMessage() + } + return convertedEdit, nil } func (evt *Bv2ChatEvent) GetStreamOrder() int64 { From 4f4f00423c69cee21da739615fbd98273869181a Mon Sep 17 00:00:00 2001 From: Tulir Asokan Date: Fri, 7 Aug 2026 13:27:02 +0300 Subject: [PATCH 06/14] login: remove unused step type constant --- pkg/connector/login.go | 1 - 1 file changed, 1 deletion(-) diff --git a/pkg/connector/login.go b/pkg/connector/login.go index 43a78d6..0446d23 100644 --- a/pkg/connector/login.go +++ b/pkg/connector/login.go @@ -69,7 +69,6 @@ func (qr *QRLogin) Cancel() { const ( LoginStepQR = "fi.mau.signal.login.qr" - LoginStepProcess = "fi.mau.signal.login.processing" LoginStepComplete = "fi.mau.signal.login.complete" ) From 542e5a3284512515117435bf4c58eeb8d2070df4 Mon Sep 17 00:00:00 2001 From: Tulir Asokan Date: Thu, 23 Jul 2026 21:07:01 +0300 Subject: [PATCH 07/14] msgconv/matrixfmt: fix bridging code blocks --- pkg/msgconv/matrixfmt/html.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/pkg/msgconv/matrixfmt/html.go b/pkg/msgconv/matrixfmt/html.go index 958ccc3..b60c0ad 100644 --- a/pkg/msgconv/matrixfmt/html.go +++ b/pkg/msgconv/matrixfmt/html.go @@ -404,17 +404,17 @@ func (parser *HTMLParser) tagToString(node *html.Node, ctx Context) *EntityStrin return NewEntityString("---") case "pre": var preStr *EntityString - //var language string + var language string if node.FirstChild != nil && node.FirstChild.Type == html.ElementNode && node.FirstChild.Data == "code" { - //class := parser.getAttribute(node.FirstChild, "class") - //if strings.HasPrefix(class, "language-") { - // language = class[len("language-"):] - //} + class := parser.getAttribute(node.FirstChild, "class") + if strings.HasPrefix(class, "language-") { + language = class[len("language-"):] + } preStr = parser.nodeToString(node.FirstChild.FirstChild, ctx.WithWhitespace()) } else { preStr = parser.nodeToString(node.FirstChild, ctx.WithWhitespace()) } - return preStr.Format(signalfmt.StyleMonospace) + return NewEntityString(fmt.Sprintf("```%s\n", language)).Append(preStr).AppendString("\n```") default: return parser.nodeToTagAwareString(node.FirstChild, ctx) } From 91427861576dc8c9b81bdf85261587c1d04222cf Mon Sep 17 00:00:00 2001 From: Tulir Asokan Date: Fri, 7 Aug 2026 14:54:56 +0300 Subject: [PATCH 08/14] libsignal: update to v0.100.0 --- pkg/libsignalgo/accountentropy.go | 14 +- pkg/libsignalgo/authcredential.go | 25 +- pkg/libsignalgo/backupkey.go | 54 +- pkg/libsignalgo/conversions.go | 5 +- pkg/libsignalgo/fixedarray.go | 159 + pkg/libsignalgo/fixedarray_clang.go | 24 + pkg/libsignalgo/fixedarray_gcc.go | 26 + pkg/libsignalgo/groupsecretparams.go | 145 +- pkg/libsignalgo/groupsendendorsement.go | 11 +- pkg/libsignalgo/libsignal | 2 +- pkg/libsignalgo/libsignal-ffi.h | 9232 +++++++++++++------- pkg/libsignalgo/logging.go | 2 +- pkg/libsignalgo/message.go | 4 +- pkg/libsignalgo/messagebackupkey.go | 35 +- pkg/libsignalgo/profilekey.go | 132 +- pkg/libsignalgo/serverpublicparams.go | 12 +- pkg/libsignalgo/serviceid.go | 21 +- pkg/libsignalgo/serviceid_clang.go | 11 - pkg/libsignalgo/serviceid_gcc.go | 14 - pkg/libsignalgo/sessionrecord.go | 1 - pkg/libsignalgo/update-ffi-docker-inner.sh | 5 +- pkg/libsignalgo/update-ffi.sh | 5 +- pkg/libsignalgo/version.go | 2 +- 23 files changed, 6556 insertions(+), 3385 deletions(-) create mode 100644 pkg/libsignalgo/fixedarray.go create mode 100644 pkg/libsignalgo/fixedarray_clang.go create mode 100644 pkg/libsignalgo/fixedarray_gcc.go delete mode 100644 pkg/libsignalgo/serviceid_clang.go delete mode 100644 pkg/libsignalgo/serviceid_gcc.go diff --git a/pkg/libsignalgo/accountentropy.go b/pkg/libsignalgo/accountentropy.go index c683b9b..712f886 100644 --- a/pkg/libsignalgo/accountentropy.go +++ b/pkg/libsignalgo/accountentropy.go @@ -20,19 +20,17 @@ package libsignalgo #include "./libsignal-ffi.h" */ import "C" -import ( - "runtime" - "unsafe" -) +import "runtime" type AccountEntropyPool string +type SVRKey = fixedArray32 func (aep AccountEntropyPool) DeriveSVRKey() ([]byte, error) { - var out [C.SignalSVR_KEY_LEN]byte + var out SVRKey aepC, free := GoStringToCString(string(aep)) defer free() signalFfiError := C.signal_account_entropy_pool_derive_svr_key( - (*[C.SignalSVR_KEY_LEN]C.uint8_t)(unsafe.Pointer(&out)), + out.cFixedArray(), aepC, ) runtime.KeepAlive(aep) @@ -43,11 +41,11 @@ func (aep AccountEntropyPool) DeriveSVRKey() ([]byte, error) { } func (aep AccountEntropyPool) DeriveBackupKey() ([]byte, error) { - var out [C.SignalBACKUP_KEY_LEN]byte + var out BackupKey aepC, free := GoStringToCString(string(aep)) defer free() signalFfiError := C.signal_account_entropy_pool_derive_backup_key( - (*[C.SignalBACKUP_KEY_LEN]C.uint8_t)(unsafe.Pointer(&out)), + out.cFixedArray(), aepC, ) runtime.KeepAlive(aep) diff --git a/pkg/libsignalgo/authcredential.go b/pkg/libsignalgo/authcredential.go index ab759b2..410eabd 100644 --- a/pkg/libsignalgo/authcredential.go +++ b/pkg/libsignalgo/authcredential.go @@ -24,15 +24,16 @@ package libsignalgo import "C" import ( "fmt" - "unsafe" "github.com/google/uuid" ) -// type AuthCredential [C.SignalAUTH_CREDENTIAL_LEN]byte -// type AuthCredentialResponse [C.SignalAUTH_CREDENTIAL_RESPONSE_LEN]byte -type AuthCredentialWithPni [C.SignalAUTH_CREDENTIAL_WITH_PNI_LEN]byte -type AuthCredentialWithPniResponse [C.SignalAUTH_CREDENTIAL_WITH_PNI_RESPONSE_LEN]byte +// type AuthCredential [181]byte +// type AuthCredentialResponse [361]byte +const AuthCredentialWithPniLength = 265 + +type AuthCredentialWithPni [AuthCredentialWithPniLength]byte +type AuthCredentialWithPniResponse [425]byte type AuthCredentialPresentation []byte func (ac *AuthCredentialWithPni) Slice() []byte { @@ -51,8 +52,8 @@ func ReceiveAuthCredentialWithPni( signalFfiError := C.signal_server_public_params_receive_auth_credential_with_pni_as_service_id( &c_result, C.SignalConstPointerServerPublicParams{serverPublicParams}, - NewACIServiceID(aci).CFixedBytes(), - NewPNIServiceID(pni).CFixedBytes(), + NewACIServiceID(aci).cConstFixedArray(), + NewPNIServiceID(pni).cConstFixedArray(), C.uint64_t(redemptionTime), BytesToBuffer(authCredResponse[:]), ) @@ -60,8 +61,8 @@ func ReceiveAuthCredentialWithPni( return nil, wrapError(signalFfiError) } resultBytes := CopySignalOwnedBufferToBytes(c_result) - if len(resultBytes) != C.SignalAUTH_CREDENTIAL_WITH_PNI_LEN { - return nil, fmt.Errorf("invalid response length %d (expected %d)", len(resultBytes), C.SignalAUTH_CREDENTIAL_WITH_PNI_LEN) + if len(resultBytes) != AuthCredentialWithPniLength { + return nil, fmt.Errorf("invalid response length %d (expected %d)", len(resultBytes), AuthCredentialWithPniLength) } return (*AuthCredentialWithPni)(resultBytes), nil } @@ -83,14 +84,12 @@ func CreateAuthCredentialWithPniPresentation( authCredWithPni AuthCredentialWithPni, ) (*AuthCredentialPresentation, error) { var c_result C.SignalOwnedBuffer = C.SignalOwnedBuffer{} - c_randomness := (*[C.SignalRANDOMNESS_LEN]C.uchar)(unsafe.Pointer(&randomness[0])) - c_groupSecretParams := (*[C.SignalGROUP_SECRET_PARAMS_LEN]C.uchar)(unsafe.Pointer(&groupSecretParams[0])) signalFfiError := C.signal_server_public_params_create_auth_credential_with_pni_presentation_deterministic( &c_result, C.SignalConstPointerServerPublicParams{serverPublicParams}, - c_randomness, - c_groupSecretParams, + randomness.cConstFixedArray(), + groupSecretParams.cConstFixedArray(), BytesToBuffer(authCredWithPni[:]), ) if signalFfiError != nil { diff --git a/pkg/libsignalgo/backupkey.go b/pkg/libsignalgo/backupkey.go index 72cf44d..b5f53f2 100644 --- a/pkg/libsignalgo/backupkey.go +++ b/pkg/libsignalgo/backupkey.go @@ -27,7 +27,9 @@ import ( "go.mau.fi/util/random" ) -type BackupKey [C.SignalBACKUP_KEY_LEN]byte +const BackupKeyLength = 32 + +type BackupKey [BackupKeyLength]byte func (bk *BackupKey) Slice() []byte { if bk == nil { @@ -38,17 +40,25 @@ func (bk *BackupKey) Slice() []byte { const BackupIDLength = 16 -type BackupID [BackupIDLength]byte -type BackupMetadataKey [C.SignalLOCAL_BACKUP_METADATA_KEY_LEN]byte -type BackupMediaID [C.SignalMEDIA_ID_LEN]byte -type BackupMediaKey [C.SignalMEDIA_ENCRYPTION_KEY_LEN]byte +type BackupID = fixedArray16 +type BackupMetadataKey = fixedArray32 +type BackupMediaID = fixedArray15 +type BackupMediaKey = fixedArray64 + +func (bk *BackupKey) cFixedArray() *C.SignalType_FixedArray32_uint8_t { + return (*C.SignalType_FixedArray32_uint8_t)(unsafe.Pointer(bk)) +} + +func (bk *BackupKey) cConstFixedArray() cFixedArray32Compat { + return cFixedArray32Compat(bk.cFixedArray()) +} func GenerateRandomBackupKey() *BackupKey { - return (*BackupKey)(random.Bytes(C.SignalBACKUP_KEY_LEN)) + return (*BackupKey)(random.Bytes(BackupKeyLength)) } func BytesToBackupKey(bytes []byte) *BackupKey { - if len(bytes) != C.SignalBACKUP_KEY_LEN { + if len(bytes) != BackupKeyLength { return nil } return (*BackupKey)(bytes) @@ -57,9 +67,9 @@ func BytesToBackupKey(bytes []byte) *BackupKey { func (bk *BackupKey) DeriveBackupID(aci ServiceID) (*BackupID, error) { var out BackupID signalFfiError := C.signal_backup_key_derive_backup_id( - (*[BackupIDLength]C.uint8_t)(unsafe.Pointer(&out)), - (*[C.SignalBACKUP_KEY_LEN]C.uint8_t)(unsafe.Pointer(bk)), - aci.CFixedBytes(), + out.cFixedArray(), + bk.cConstFixedArray(), + aci.cConstFixedArray(), ) runtime.KeepAlive(bk) if signalFfiError != nil { @@ -72,8 +82,8 @@ func (bk *BackupKey) DeriveECKey(aci ServiceID) (*PrivateKey, error) { var out C.SignalMutPointerPrivateKey signalFfiError := C.signal_backup_key_derive_ec_key( &out, - (*[C.SignalBACKUP_KEY_LEN]C.uint8_t)(unsafe.Pointer(&bk)), - aci.CFixedBytes(), + bk.cConstFixedArray(), + aci.cConstFixedArray(), ) runtime.KeepAlive(bk) if signalFfiError != nil { @@ -85,8 +95,8 @@ func (bk *BackupKey) DeriveECKey(aci ServiceID) (*PrivateKey, error) { func (bk *BackupKey) DeriveLocalBackupMetadataKey() (*BackupMetadataKey, error) { var out BackupMetadataKey signalFfiError := C.signal_backup_key_derive_local_backup_metadata_key( - (*[C.SignalLOCAL_BACKUP_METADATA_KEY_LEN]C.uint8_t)(unsafe.Pointer(&out)), - (*[C.SignalBACKUP_KEY_LEN]C.uint8_t)(unsafe.Pointer(bk)), + out.cFixedArray(), + bk.cConstFixedArray(), ) runtime.KeepAlive(bk) if signalFfiError != nil { @@ -100,8 +110,8 @@ func (bk *BackupKey) DeriveMediaID(mediaName string) (*BackupMediaID, error) { mediaNameStr, mediaNameFree := GoStringToCString(mediaName) defer mediaNameFree() signalFfiError := C.signal_backup_key_derive_media_id( - (*[C.SignalMEDIA_ID_LEN]C.uint8_t)(unsafe.Pointer(&out)), - (*[C.SignalBACKUP_KEY_LEN]C.uint8_t)(unsafe.Pointer(bk)), + out.cFixedArray(), + bk.cConstFixedArray(), mediaNameStr, ) runtime.KeepAlive(bk) @@ -114,9 +124,9 @@ func (bk *BackupKey) DeriveMediaID(mediaName string) (*BackupMediaID, error) { func (bk *BackupKey) DeriveMediaEncryptionKey(mediaID *BackupMediaID) (*BackupMediaKey, error) { var out BackupMediaKey signalFfiError := C.signal_backup_key_derive_media_encryption_key( - (*[C.SignalMEDIA_ENCRYPTION_KEY_LEN]C.uint8_t)(unsafe.Pointer(&out)), - (*[C.SignalBACKUP_KEY_LEN]C.uint8_t)(unsafe.Pointer(bk)), - (*[C.SignalMEDIA_ID_LEN]C.uint8_t)(unsafe.Pointer(mediaID)), + out.cFixedArray(), + bk.cConstFixedArray(), + mediaID.cConstFixedArray(), ) runtime.KeepAlive(bk) runtime.KeepAlive(mediaID) @@ -129,9 +139,9 @@ func (bk *BackupKey) DeriveMediaEncryptionKey(mediaID *BackupMediaID) (*BackupMe func (bk *BackupKey) DeriveThumbnailTransitEncryptionKey(mediaID *BackupMediaID) (*BackupMediaKey, error) { var out BackupMediaKey signalFfiError := C.signal_backup_key_derive_thumbnail_transit_encryption_key( - (*[C.SignalMEDIA_ENCRYPTION_KEY_LEN]C.uint8_t)(unsafe.Pointer(&out)), - (*[C.SignalBACKUP_KEY_LEN]C.uint8_t)(unsafe.Pointer(bk)), - (*[C.SignalMEDIA_ID_LEN]C.uint8_t)(unsafe.Pointer(mediaID)), + out.cFixedArray(), + bk.cConstFixedArray(), + mediaID.cConstFixedArray(), ) runtime.KeepAlive(bk) runtime.KeepAlive(mediaID) diff --git a/pkg/libsignalgo/conversions.go b/pkg/libsignalgo/conversions.go index 53f6916..3babfe8 100644 --- a/pkg/libsignalgo/conversions.go +++ b/pkg/libsignalgo/conversions.go @@ -18,19 +18,20 @@ package libsignalgo /* #include "./libsignal-ffi.h" +#include */ import "C" import "unsafe" func GoStringToCString(str string) (C.SignalCStringPtr, func()) { cStr := C.CString(str) - return cStr, func() { + return (*C.int8_t)(cStr), func() { C.free(unsafe.Pointer(cStr)) } } func CopyCStringToString(cString C.SignalCStringPtr) (s string) { - s = C.GoString(cString) + s = C.GoString((*C.char)(unsafe.Pointer(cString))) C.signal_free_string(cString) return } diff --git a/pkg/libsignalgo/fixedarray.go b/pkg/libsignalgo/fixedarray.go new file mode 100644 index 0000000..949e808 --- /dev/null +++ b/pkg/libsignalgo/fixedarray.go @@ -0,0 +1,159 @@ +// mautrix-signal - A Matrix-signal puppeting bridge. +// Copyright (C) 2026 Tulir Asokan +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +package libsignalgo + +/* +#include "./libsignal-ffi.h" +*/ +import "C" +import "unsafe" + +type fixedArray15 [15]byte +type fixedArray16 [16]byte +type fixedArray17 [17]byte +type fixedArray32 [32]byte +type fixedArray64 [64]byte +type fixedArray65 [65]byte +type fixedArray97 [97]byte +type fixedArray129 [129]byte +type fixedArray153 [153]byte +type fixedArray177 [177]byte +type fixedArray289 [289]byte +type fixedArray329 [329]byte +type fixedArray409 [409]byte +type fixedArray473 [473]byte +type fixedArray497 [497]byte + +func (a *fixedArray15) cFixedArray() *C.SignalType_FixedArray15_uint8_t { + return (*C.SignalType_FixedArray15_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray15) cConstFixedArray() cFixedArray15Compat { + return cFixedArray15Compat(a.cFixedArray()) +} + +func (a *fixedArray16) cFixedArray() *C.SignalType_FixedArray16_uint8_t { + return (*C.SignalType_FixedArray16_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray16) cConstFixedArray() cFixedArray16Compat { + return cFixedArray16Compat(a.cFixedArray()) +} + +func (a *fixedArray17) cFixedArray() *C.SignalType_FixedArray17_uint8_t { + return (*C.SignalType_FixedArray17_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray17) cConstFixedArray() cFixedArray17Compat { + return cFixedArray17Compat(a.cFixedArray()) +} + +func (a *fixedArray32) cFixedArray() *C.SignalType_FixedArray32_uint8_t { + return (*C.SignalType_FixedArray32_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray32) cConstFixedArray() cFixedArray32Compat { + return cFixedArray32Compat(a.cFixedArray()) +} + +func (a *fixedArray64) cFixedArray() *C.SignalType_FixedArray64_uint8_t { + return (*C.SignalType_FixedArray64_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray64) cConstFixedArray() cFixedArray64Compat { + return cFixedArray64Compat(a.cFixedArray()) +} + +func (a *fixedArray65) cFixedArray() *C.SignalType_FixedArray65_uint8_t { + return (*C.SignalType_FixedArray65_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray65) cConstFixedArray() cFixedArray65Compat { + return cFixedArray65Compat(a.cFixedArray()) +} + +func (a *fixedArray97) cFixedArray() *C.SignalType_FixedArray97_uint8_t { + return (*C.SignalType_FixedArray97_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray97) cConstFixedArray() cFixedArray97Compat { + return cFixedArray97Compat(a.cFixedArray()) +} + +func (a *fixedArray129) cFixedArray() *C.SignalType_FixedArray129_uint8_t { + return (*C.SignalType_FixedArray129_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray129) cConstFixedArray() cFixedArray129Compat { + return cFixedArray129Compat(a.cFixedArray()) +} + +func (a *fixedArray153) cFixedArray() *C.SignalType_FixedArray153_uint8_t { + return (*C.SignalType_FixedArray153_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray153) cConstFixedArray() cFixedArray153Compat { + return cFixedArray153Compat(a.cFixedArray()) +} + +func (a *fixedArray177) cFixedArray() *C.SignalType_FixedArray177_uint8_t { + return (*C.SignalType_FixedArray177_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray177) cConstFixedArray() cFixedArray177Compat { + return cFixedArray177Compat(a.cFixedArray()) +} + +func (a *fixedArray289) cFixedArray() *C.SignalType_FixedArray289_uint8_t { + return (*C.SignalType_FixedArray289_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray289) cConstFixedArray() cFixedArray289Compat { + return cFixedArray289Compat(a.cFixedArray()) +} + +func (a *fixedArray329) cFixedArray() *C.SignalType_FixedArray329_uint8_t { + return (*C.SignalType_FixedArray329_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray329) cConstFixedArray() cFixedArray329Compat { + return cFixedArray329Compat(a.cFixedArray()) +} + +func (a *fixedArray409) cFixedArray() *C.SignalType_FixedArray409_uint8_t { + return (*C.SignalType_FixedArray409_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray409) cConstFixedArray() cFixedArray409Compat { + return cFixedArray409Compat(a.cFixedArray()) +} + +func (a *fixedArray473) cFixedArray() *C.SignalType_FixedArray473_uint8_t { + return (*C.SignalType_FixedArray473_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray473) cConstFixedArray() cFixedArray473Compat { + return cFixedArray473Compat(a.cFixedArray()) +} + +func (a *fixedArray497) cFixedArray() *C.SignalType_FixedArray497_uint8_t { + return (*C.SignalType_FixedArray497_uint8_t)(unsafe.Pointer(a)) +} + +func (a *fixedArray497) cConstFixedArray() cFixedArray497Compat { + return cFixedArray497Compat(a.cFixedArray()) +} diff --git a/pkg/libsignalgo/fixedarray_clang.go b/pkg/libsignalgo/fixedarray_clang.go new file mode 100644 index 0000000..3dc0cd2 --- /dev/null +++ b/pkg/libsignalgo/fixedarray_clang.go @@ -0,0 +1,24 @@ +//go:build darwin || android || ios || (windows && arm64) + +package libsignalgo + +/* +#include "./libsignal-ffi.h" +*/ +import "C" + +type cFixedArray15Compat = *C.SignalType_FixedArray15_uint8_t +type cFixedArray16Compat = *C.SignalType_FixedArray16_uint8_t +type cFixedArray17Compat = *C.SignalType_FixedArray17_uint8_t +type cFixedArray32Compat = *C.SignalType_FixedArray32_uint8_t +type cFixedArray64Compat = *C.SignalType_FixedArray64_uint8_t +type cFixedArray65Compat = *C.SignalType_FixedArray65_uint8_t +type cFixedArray97Compat = *C.SignalType_FixedArray97_uint8_t +type cFixedArray129Compat = *C.SignalType_FixedArray129_uint8_t +type cFixedArray153Compat = *C.SignalType_FixedArray153_uint8_t +type cFixedArray177Compat = *C.SignalType_FixedArray177_uint8_t +type cFixedArray289Compat = *C.SignalType_FixedArray289_uint8_t +type cFixedArray329Compat = *C.SignalType_FixedArray329_uint8_t +type cFixedArray409Compat = *C.SignalType_FixedArray409_uint8_t +type cFixedArray473Compat = *C.SignalType_FixedArray473_uint8_t +type cFixedArray497Compat = *C.SignalType_FixedArray497_uint8_t diff --git a/pkg/libsignalgo/fixedarray_gcc.go b/pkg/libsignalgo/fixedarray_gcc.go new file mode 100644 index 0000000..6490494 --- /dev/null +++ b/pkg/libsignalgo/fixedarray_gcc.go @@ -0,0 +1,26 @@ +//go:build !(darwin || android || ios || (windows && arm64)) + +package libsignalgo + +/* +#include "./libsignal-ffi.h" +*/ +import "C" + +// Hack for https://github.com/golang/go/issues/7270 +// The clang version is more correct, but doesn't work with gcc. +type cFixedArray15Compat = *[15]C.uint8_t +type cFixedArray16Compat = *[16]C.uint8_t +type cFixedArray17Compat = *[17]C.uint8_t +type cFixedArray32Compat = *[32]C.uint8_t +type cFixedArray64Compat = *[64]C.uint8_t +type cFixedArray65Compat = *[65]C.uint8_t +type cFixedArray97Compat = *[97]C.uint8_t +type cFixedArray129Compat = *[129]C.uint8_t +type cFixedArray153Compat = *[153]C.uint8_t +type cFixedArray177Compat = *[177]C.uint8_t +type cFixedArray289Compat = *[289]C.uint8_t +type cFixedArray329Compat = *[329]C.uint8_t +type cFixedArray409Compat = *[409]C.uint8_t +type cFixedArray473Compat = *[473]C.uint8_t +type cFixedArray497Compat = *[497]C.uint8_t diff --git a/pkg/libsignalgo/groupsecretparams.go b/pkg/libsignalgo/groupsecretparams.go index a6b370c..eee983f 100644 --- a/pkg/libsignalgo/groupsecretparams.go +++ b/pkg/libsignalgo/groupsecretparams.go @@ -31,7 +31,9 @@ import ( "github.com/google/uuid" ) -type Randomness [C.SignalRANDOMNESS_LEN]byte +const RandomnessLength = 32 + +type Randomness = fixedArray32 func GenerateRandomness() Randomness { var randomness Randomness @@ -42,14 +44,39 @@ func GenerateRandomness() Randomness { return randomness } -const GroupMasterKeyLength = C.SignalGROUP_MASTER_KEY_LEN -const GroupIdentifierLength = C.SignalGROUP_IDENTIFIER_LEN +const GroupMasterKeyLength = 32 +const GroupIdentifierLength = 32 +const GroupSecretParamsLength = 289 type GroupMasterKey [GroupMasterKeyLength]byte -type GroupSecretParams [C.SignalGROUP_SECRET_PARAMS_LEN]byte -type GroupPublicParams [C.SignalGROUP_PUBLIC_PARAMS_LEN]byte +type GroupSecretParams [GroupSecretParamsLength]byte +type GroupPublicParams = fixedArray97 type GroupIdentifier [GroupIdentifierLength]byte +func (gmk *GroupMasterKey) cFixedArray() *C.SignalType_FixedArray32_uint8_t { + return (*C.SignalType_FixedArray32_uint8_t)(unsafe.Pointer(gmk)) +} + +func (gmk *GroupMasterKey) cConstFixedArray() cFixedArray32Compat { + return cFixedArray32Compat(gmk.cFixedArray()) +} + +func (gsp *GroupSecretParams) cFixedArray() *C.SignalType_FixedArray289_uint8_t { + return (*C.SignalType_FixedArray289_uint8_t)(unsafe.Pointer(gsp)) +} + +func (gsp *GroupSecretParams) cConstFixedArray() cFixedArray289Compat { + return cFixedArray289Compat(gsp.cFixedArray()) +} + +func (gid *GroupIdentifier) cFixedArray() *C.SignalType_FixedArray32_uint8_t { + return (*C.SignalType_FixedArray32_uint8_t)(unsafe.Pointer(gid)) +} + +func (gid *GroupIdentifier) cConstFixedArray() cFixedArray32Compat { + return cFixedArray32Compat(gid.cFixedArray()) +} + func (gid *GroupIdentifier) String() string { if gid == nil { return "" @@ -57,8 +84,8 @@ func (gid *GroupIdentifier) String() string { return base64.StdEncoding.EncodeToString(gid[:]) } -type UUIDCiphertext [C.SignalUUID_CIPHERTEXT_LEN]byte -type ProfileKeyCiphertext [C.SignalPROFILE_KEY_CIPHERTEXT_LEN]byte +type UUIDCiphertext = fixedArray65 +type ProfileKeyCiphertext = fixedArray65 func GenerateGroupSecretParams() (GroupSecretParams, error) { return GenerateGroupSecretParamsWithRandomness(GenerateRandomness()) @@ -81,51 +108,43 @@ func (gmk GroupMasterKey) SecretParams() (GroupSecretParams, error) { } func GenerateGroupSecretParamsWithRandomness(randomness Randomness) (GroupSecretParams, error) { - var params [C.SignalGROUP_SECRET_PARAMS_LEN]C.uchar - signalFfiError := C.signal_group_secret_params_generate_deterministic(¶ms, (*[C.SignalRANDOMNESS_LEN]C.uint8_t)(unsafe.Pointer(&randomness))) + var params GroupSecretParams + signalFfiError := C.signal_group_secret_params_generate_deterministic(params.cFixedArray(), randomness.cConstFixedArray()) runtime.KeepAlive(randomness) if signalFfiError != nil { return GroupSecretParams{}, wrapError(signalFfiError) } - var groupSecretParams GroupSecretParams - copy(groupSecretParams[:], C.GoBytes(unsafe.Pointer(¶ms), C.int(C.SignalGROUP_SECRET_PARAMS_LEN))) - return groupSecretParams, nil + return params, nil } func DeriveGroupSecretParamsFromMasterKey(groupMasterKey GroupMasterKey) (GroupSecretParams, error) { - var params [C.SignalGROUP_SECRET_PARAMS_LEN]C.uchar - signalFfiError := C.signal_group_secret_params_derive_from_master_key(¶ms, (*[C.SignalGROUP_MASTER_KEY_LEN]C.uint8_t)(unsafe.Pointer(&groupMasterKey))) + var params GroupSecretParams + signalFfiError := C.signal_group_secret_params_derive_from_master_key(params.cFixedArray(), groupMasterKey.cConstFixedArray()) runtime.KeepAlive(groupMasterKey) if signalFfiError != nil { return GroupSecretParams{}, wrapError(signalFfiError) } - var groupSecretParams GroupSecretParams - copy(groupSecretParams[:], C.GoBytes(unsafe.Pointer(¶ms), C.int(C.SignalGROUP_SECRET_PARAMS_LEN))) - return groupSecretParams, nil + return params, nil } func (gsp *GroupSecretParams) GetPublicParams() (*GroupPublicParams, error) { - var publicParams [C.SignalGROUP_PUBLIC_PARAMS_LEN]C.uchar - signalFfiError := C.signal_group_secret_params_get_public_params(&publicParams, (*[C.SignalGROUP_SECRET_PARAMS_LEN]C.uint8_t)(unsafe.Pointer(gsp))) + var publicParams GroupPublicParams + signalFfiError := C.signal_group_secret_params_get_public_params(publicParams.cFixedArray(), gsp.cConstFixedArray()) runtime.KeepAlive(gsp) if signalFfiError != nil { return nil, wrapError(signalFfiError) } - var groupPublicParams GroupPublicParams - copy(groupPublicParams[:], C.GoBytes(unsafe.Pointer(&publicParams), C.int(C.SignalGROUP_PUBLIC_PARAMS_LEN))) - return &groupPublicParams, nil + return &publicParams, nil } func GetGroupIdentifier(groupPublicParams GroupPublicParams) (*GroupIdentifier, error) { - var groupIdentifier [C.SignalGROUP_IDENTIFIER_LEN]C.uchar - signalFfiError := C.signal_group_public_params_get_group_identifier(&groupIdentifier, (*[C.SignalGROUP_PUBLIC_PARAMS_LEN]C.uint8_t)(unsafe.Pointer(&groupPublicParams))) + var groupIdentifier GroupIdentifier + signalFfiError := C.signal_group_public_params_get_group_identifier(groupIdentifier.cFixedArray(), groupPublicParams.cConstFixedArray()) runtime.KeepAlive(groupPublicParams) if signalFfiError != nil { return nil, wrapError(signalFfiError) } - var result GroupIdentifier - copy(result[:], C.GoBytes(unsafe.Pointer(&groupIdentifier), C.int(C.SignalGROUP_IDENTIFIER_LEN))) - return &result, nil + return &groupIdentifier, nil } func (gsp *GroupSecretParams) DecryptBlobWithPadding(blob []byte) ([]byte, error) { @@ -133,7 +152,7 @@ func (gsp *GroupSecretParams) DecryptBlobWithPadding(blob []byte) ([]byte, error borrowedBlob := BytesToBuffer(blob) signalFfiError := C.signal_group_secret_params_decrypt_blob_with_padding( &plaintext, - (*[C.SignalGROUP_SECRET_PARAMS_LEN]C.uint8_t)(unsafe.Pointer(gsp)), + gsp.cConstFixedArray(), borrowedBlob, ) runtime.KeepAlive(gsp) @@ -149,8 +168,8 @@ func (gsp *GroupSecretParams) EncryptBlobWithPaddingDeterministic(randomness Ran borrowedPlaintext := BytesToBuffer(plaintext) signalFfiError := C.signal_group_secret_params_encrypt_blob_with_padding_deterministic( &ciphertext, - (*[C.SignalGROUP_SECRET_PARAMS_LEN]C.uint8_t)(unsafe.Pointer(gsp)), - (*[C.SignalRANDOMNESS_LEN]C.uint8_t)(unsafe.Pointer(&randomness)), + gsp.cConstFixedArray(), + randomness.cConstFixedArray(), borrowedPlaintext, (C.uint32_t)(padding_len), ) @@ -165,11 +184,11 @@ func (gsp *GroupSecretParams) EncryptBlobWithPaddingDeterministic(randomness Ran } func (gsp *GroupSecretParams) DecryptServiceID(ciphertextServiceID UUIDCiphertext) (ServiceID, error) { - u := C.SignalServiceIdFixedWidthBinaryBytes{} + var serviceIDBytes ServiceIDFixedBytes signalFfiError := C.signal_group_secret_params_decrypt_service_id( - &u, - (*[C.SignalGROUP_SECRET_PARAMS_LEN]C.uint8_t)(unsafe.Pointer(gsp)), - (*[C.SignalUUID_CIPHERTEXT_LEN]C.uint8_t)(unsafe.Pointer(&ciphertextServiceID)), + serviceIDBytes.cFixedArray(), + gsp.cConstFixedArray(), + ciphertextServiceID.cConstFixedArray(), ) runtime.KeepAlive(gsp) runtime.KeepAlive(ciphertextServiceID) @@ -177,33 +196,31 @@ func (gsp *GroupSecretParams) DecryptServiceID(ciphertextServiceID UUIDCiphertex return EmptyServiceID, wrapError(signalFfiError) } - serviceID := ServiceIDFromCFixedBytes(&u) + serviceID := ServiceIDFromCFixedBytes(serviceIDBytes.cFixedArray()) return serviceID, nil } func (gsp *GroupSecretParams) EncryptServiceID(serviceID ServiceID) (*UUIDCiphertext, error) { - var cipherTextServiceID [C.SignalUUID_CIPHERTEXT_LEN]C.uchar + var cipherTextServiceID UUIDCiphertext signalFfiError := C.signal_group_secret_params_encrypt_service_id( - &cipherTextServiceID, - (*[C.SignalGROUP_SECRET_PARAMS_LEN]C.uint8_t)(unsafe.Pointer(gsp)), - serviceID.CFixedBytes(), + cipherTextServiceID.cFixedArray(), + gsp.cConstFixedArray(), + serviceID.cConstFixedArray(), ) runtime.KeepAlive(gsp) if signalFfiError != nil { return nil, wrapError(signalFfiError) } - var result UUIDCiphertext - copy(result[:], C.GoBytes(unsafe.Pointer(&cipherTextServiceID), C.int(C.SignalUUID_CIPHERTEXT_LEN))) - return &result, nil + return &cipherTextServiceID, nil } func (gsp *GroupSecretParams) DecryptProfileKey(ciphertextProfileKey ProfileKeyCiphertext, u uuid.UUID) (*ProfileKey, error) { - profileKey := [C.SignalPROFILE_KEY_LEN]C.uchar{} + var profileKey ProfileKey signalFfiError := C.signal_group_secret_params_decrypt_profile_key( - &profileKey, - (*[C.SignalGROUP_SECRET_PARAMS_LEN]C.uint8_t)(unsafe.Pointer(gsp)), - (*[C.SignalPROFILE_KEY_CIPHERTEXT_LEN]C.uint8_t)(unsafe.Pointer(&ciphertextProfileKey)), - NewACIServiceID(u).CFixedBytes(), + profileKey.cFixedArray(), + gsp.cConstFixedArray(), + ciphertextProfileKey.cConstFixedArray(), + NewACIServiceID(u).cConstFixedArray(), ) runtime.KeepAlive(gsp) runtime.KeepAlive(ciphertextProfileKey) @@ -211,27 +228,23 @@ func (gsp *GroupSecretParams) DecryptProfileKey(ciphertextProfileKey ProfileKeyC if signalFfiError != nil { return nil, wrapError(signalFfiError) } - var result ProfileKey - copy(result[:], C.GoBytes(unsafe.Pointer(&profileKey), C.int(C.SignalPROFILE_KEY_LEN))) - return &result, nil + return &profileKey, nil } func (gsp *GroupSecretParams) EncryptProfileKey(profileKey ProfileKey, u uuid.UUID) (*ProfileKeyCiphertext, error) { - ciphertextProfileKey := [C.SignalPROFILE_KEY_CIPHERTEXT_LEN]C.uchar{} + var ciphertextProfileKey ProfileKeyCiphertext signalFfiError := C.signal_group_secret_params_encrypt_profile_key( - &ciphertextProfileKey, - (*[C.SignalGROUP_SECRET_PARAMS_LEN]C.uint8_t)(unsafe.Pointer(gsp)), - (*[C.SignalPROFILE_KEY_LEN]C.uint8_t)(unsafe.Pointer(&profileKey)), - NewACIServiceID(u).CFixedBytes(), + ciphertextProfileKey.cFixedArray(), + gsp.cConstFixedArray(), + profileKey.cConstFixedArray(), + NewACIServiceID(u).cConstFixedArray(), ) runtime.KeepAlive(gsp) runtime.KeepAlive(profileKey) if signalFfiError != nil { return nil, wrapError(signalFfiError) } - var result ProfileKeyCiphertext - copy(result[:], C.GoBytes(unsafe.Pointer(&ciphertextProfileKey), C.int(C.SignalPROFILE_KEY_CIPHERTEXT_LEN))) - return &result, nil + return &ciphertextProfileKey, nil } func (gsp *GroupSecretParams) CreateExpiringProfileKeyCredentialPresentation(spp *ServerPublicParams, credential ExpiringProfileKeyCredential) (*ProfileKeyCredentialPresentation, error) { @@ -240,9 +253,9 @@ func (gsp *GroupSecretParams) CreateExpiringProfileKeyCredentialPresentation(spp signalFfiError := C.signal_server_public_params_create_expiring_profile_key_credential_presentation_deterministic( &out, C.SignalConstPointerServerPublicParams{spp}, - (*[C.SignalRANDOMNESS_LEN]C.uint8_t)(unsafe.Pointer(&randomness)), - (*[C.SignalGROUP_SECRET_PARAMS_LEN]C.uchar)(unsafe.Pointer(gsp)), - (*[C.SignalEXPIRING_PROFILE_KEY_CREDENTIAL_LEN]C.uchar)(unsafe.Pointer(&credential)), + randomness.cConstFixedArray(), + gsp.cConstFixedArray(), + credential.cConstFixedArray(), ) runtime.KeepAlive(gsp) runtime.KeepAlive(credential) @@ -256,16 +269,14 @@ func (gsp *GroupSecretParams) CreateExpiringProfileKeyCredentialPresentation(spp } func (gsp *GroupSecretParams) GetMasterKey() (*GroupMasterKey, error) { - masterKeyBytes := [C.SignalGROUP_MASTER_KEY_LEN]C.uchar{} + var masterKey GroupMasterKey signalFfiError := C.signal_group_secret_params_get_master_key( - &masterKeyBytes, - (*[C.SignalGROUP_SECRET_PARAMS_LEN]C.uchar)(unsafe.Pointer(gsp)), + masterKey.cFixedArray(), + gsp.cConstFixedArray(), ) runtime.KeepAlive(gsp) if signalFfiError != nil { return nil, wrapError(signalFfiError) } - var groupMasterKey GroupMasterKey - copy(groupMasterKey[:], C.GoBytes(unsafe.Pointer(&masterKeyBytes), C.int(C.SignalGROUP_MASTER_KEY_LEN))) - return &groupMasterKey, nil + return &masterKey, nil } diff --git a/pkg/libsignalgo/groupsendendorsement.go b/pkg/libsignalgo/groupsendendorsement.go index 73f175e..afc359f 100644 --- a/pkg/libsignalgo/groupsendendorsement.go +++ b/pkg/libsignalgo/groupsendendorsement.go @@ -24,7 +24,6 @@ import ( "encoding/base64" "runtime" "time" - "unsafe" ) type GroupSendFullToken []byte @@ -91,7 +90,7 @@ func (gse GroupSendEndorsement) ToToken(groupSecretParams *GroupSecretParams) (G signalFfiError := C.signal_group_send_endorsement_to_token( &token, BytesToBuffer(gse), - (*[C.SignalGROUP_SECRET_PARAMS_LEN]C.uint8_t)(unsafe.Pointer(groupSecretParams)), + groupSecretParams.cConstFixedArray(), ) runtime.KeepAlive(gse) runtime.KeepAlive(groupSecretParams) @@ -180,17 +179,17 @@ func (gser GroupSendEndorsementsResponse) ReceiveWithServiceIDs( groupMembers []ServiceID, localUser ServiceID, params *GroupSecretParams, spp *ServerPublicParams, ) (GroupSendEndorsement, map[ServiceID]GroupSendEndorsement, error) { var out C.SignalBytestringArray = C.SignalBytestringArray{} - concatenatedMembers := make([]byte, len(groupMembers)*17) + concatenatedMembers := make([]byte, len(groupMembers)*ServiceIDFixedBytesLength) for i, member := range groupMembers { - copy(concatenatedMembers[i*17:(i+1)*17], member.FixedBytes()[:]) + copy(concatenatedMembers[i*ServiceIDFixedBytesLength:(i+1)*ServiceIDFixedBytesLength], member.FixedBytes()[:]) } signalFfiError := C.signal_group_send_endorsements_response_receive_and_combine_with_service_ids( &out, BytesToBuffer(gser), BytesToBuffer(concatenatedMembers), - localUser.CFixedBytes(), + localUser.cConstFixedArray(), C.uint64_t(time.Now().Unix()), - (*[C.SignalGROUP_SECRET_PARAMS_LEN]C.uint8_t)(unsafe.Pointer(params)), + params.cConstFixedArray(), C.SignalConstPointerServerPublicParams{spp}, ) runtime.KeepAlive(gser) diff --git a/pkg/libsignalgo/libsignal b/pkg/libsignalgo/libsignal index 4e9bd5d..857c4dc 160000 --- a/pkg/libsignalgo/libsignal +++ b/pkg/libsignalgo/libsignal @@ -1 +1 @@ -Subproject commit 4e9bd5d7feca2f61cf2ce0c7d99a60eb8b9e0102 +Subproject commit 857c4dca03537dc5e395a5e1eda6bf18f59c3601 diff --git a/pkg/libsignalgo/libsignal-ffi.h b/pkg/libsignalgo/libsignal-ffi.h index 3aecf05..0979410 100644 --- a/pkg/libsignalgo/libsignal-ffi.h +++ b/pkg/libsignalgo/libsignal-ffi.h @@ -1,204 +1,2943 @@ -/* -Copyright (C) 2020-2021 Signal Messenger, LLC. -SPDX-License-Identifier: AGPL-3.0-only -*/ - - -#ifndef SIGNAL_FFI_H_ -#define SIGNAL_FFI_H_ - -/* This file was automatically generated by cbindgen */ - -#include +// Copyright (C) 2026 Signal Messenger, LLC. +// SPDX-License-Identifier: AGPL-3.0-only +// AUTOGENERATED! Do not modify! +#pragma once +#include +#include #include #include #include -#include - -#define SignalSVR_KEY_LEN 32 - -#define SignalBACKUP_KEY_LEN 32 - -#define SignalLOCAL_BACKUP_METADATA_KEY_LEN 32 - -#define SignalMEDIA_ID_LEN 15 - -#define SignalBACKUP_FORWARD_SECRECY_TOKEN_LEN 32 - -#define SignalMEDIA_ENCRYPTION_AES_KEY_LEN 32 - -#define SignalMEDIA_ENCRYPTION_HMAC_KEY_LEN 32 - -#define SignalMEDIA_ENCRYPTION_KEY_LEN (SignalMEDIA_ENCRYPTION_AES_KEY_LEN + SignalMEDIA_ENCRYPTION_HMAC_KEY_LEN) - -#define SignalBackupId_LEN 16 - -#define SignalAes256GcmEncryption_TAG_SIZE SignalTAG_SIZE - -#define SignalAes256GcmEncryption_NONCE_SIZE SignalNONCE_SIZE - -#define SignalAes256GcmDecryption_TAG_SIZE SignalTAG_SIZE - -#define SignalAes256GcmDecryption_NONCE_SIZE SignalNONCE_SIZE - -/** - * A "reasonable" default value to use for bulk-polled streaming network APIs. - * - * Chosen only for being neither too small (thus wasting time in the bridge layer processing many - * small chunks) nor too large (thus allocating a bunch of memory at once). - */ -#define SignalBULK_POLLED_STREAM_DEFAULT_CHUNK_SIZE 64 - -#define SignalCallLinkSecretParams_ROOT_KEY_MAX_BYTES_FOR_SHO 16 - -#define SignalNUM_AUTH_CRED_ATTRIBUTES 3 - -#define SignalNUM_PROFILE_KEY_CRED_ATTRIBUTES 4 - -#define SignalNUM_RECEIPT_CRED_ATTRIBUTES 2 - -#define SignalPRESENTATION_VERSION_1 0 - -#define SignalPRESENTATION_VERSION_2 1 - -#define SignalPRESENTATION_VERSION_3 2 - -#define SignalPRESENTATION_VERSION_4 3 - -#define SignalAES_KEY_LEN 32 - -#define SignalAESGCM_NONCE_LEN 12 - -#define SignalAESGCM_TAG_LEN 16 - -#define SignalGROUP_MASTER_KEY_LEN 32 - -#define SignalGROUP_SECRET_PARAMS_LEN 289 - -#define SignalGROUP_PUBLIC_PARAMS_LEN 97 - -#define SignalGROUP_IDENTIFIER_LEN 32 - -#define SignalAUTH_CREDENTIAL_LEN 181 - -#define SignalAUTH_CREDENTIAL_PRESENTATION_V2_LEN 461 - -#define SignalAUTH_CREDENTIAL_RESPONSE_LEN 361 - -#define SignalAUTH_CREDENTIAL_WITH_PNI_LEN 265 - -#define SignalAUTH_CREDENTIAL_WITH_PNI_RESPONSE_LEN 425 - -#define SignalPROFILE_KEY_LEN 32 - -#define SignalPROFILE_KEY_CIPHERTEXT_LEN 65 - -#define SignalPROFILE_KEY_COMMITMENT_LEN 97 - -#define SignalEXPIRING_PROFILE_KEY_CREDENTIAL_LEN 153 - -#define SignalPROFILE_KEY_CREDENTIAL_PRESENTATION_V2_LEN 713 - -#define SignalPROFILE_KEY_CREDENTIAL_REQUEST_LEN 329 - -#define SignalPROFILE_KEY_CREDENTIAL_REQUEST_CONTEXT_LEN 473 - -#define SignalEXPIRING_PROFILE_KEY_CREDENTIAL_RESPONSE_LEN 497 - -#define SignalPROFILE_KEY_VERSION_LEN 32 - -#define SignalPROFILE_KEY_VERSION_ENCODED_LEN 64 - -#define SignalRECEIPT_CREDENTIAL_LEN 129 - -#define SignalRECEIPT_CREDENTIAL_PRESENTATION_LEN 329 - -#define SignalRECEIPT_CREDENTIAL_REQUEST_LEN 97 - -#define SignalRECEIPT_CREDENTIAL_REQUEST_CONTEXT_LEN 177 - -#define SignalRECEIPT_CREDENTIAL_RESPONSE_LEN 409 - -#define SignalRECEIPT_SERIAL_LEN 16 - -#define SignalRESERVED_LEN 1 - -#define SignalSERVER_SECRET_PARAMS_LEN 2721 - -#define SignalSERVER_PUBLIC_PARAMS_LEN 673 - -#define SignalUUID_CIPHERTEXT_LEN 65 - -#define SignalRANDOMNESS_LEN 32 - -#define SignalSIGNATURE_LEN 64 - -#define SignalUUID_LEN 16 - -#define SignalACCESS_KEY_LEN 16 - -/** - * Seconds in a 24-hour cycle (ignoring leap seconds). - */ -#define SignalSECONDS_PER_DAY 86400 - -/** - * The encoded length of a [`FourCC`], in bytes. - */ -#define SignalFourCC_ENCODED_LEN 4 - +// A static assert that's only enabled for 64-bit platforms. +#define static_assert_64bit(flag) static_assert((sizeof(void*) == 8) ? (flag) : 1, "") +static_assert_64bit(sizeof(uint8_t) == 1); +static_assert_64bit(alignof(uint8_t) == 1); +typedef uint8_t SignalType_FixedArray32_uint8_t[32]; +static_assert_64bit(sizeof(SignalType_FixedArray32_uint8_t) == 32); +static_assert_64bit(alignof(SignalType_FixedArray32_uint8_t) == 1); +typedef const SignalType_FixedArray32_uint8_t* SignalType_ConstPointer_SignalType_FixedArray32_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray32_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray32_uint8_t) == 8); +typedef const SignalType_ConstPointer_SignalType_FixedArray32_uint8_t* SignalType_ConstPointer_SignalType_ConstPointer_SignalType_FixedArray32_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_ConstPointer_SignalType_FixedArray32_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_ConstPointer_SignalType_FixedArray32_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray129_uint8_t[129]; +static_assert_64bit(sizeof(SignalType_FixedArray129_uint8_t) == 129); +static_assert_64bit(alignof(SignalType_FixedArray129_uint8_t) == 1); +typedef const SignalType_FixedArray129_uint8_t* SignalType_ConstPointer_SignalType_FixedArray129_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray129_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray129_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray153_uint8_t[153]; +static_assert_64bit(sizeof(SignalType_FixedArray153_uint8_t) == 153); +static_assert_64bit(alignof(SignalType_FixedArray153_uint8_t) == 1); +typedef const SignalType_FixedArray153_uint8_t* SignalType_ConstPointer_SignalType_FixedArray153_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray153_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray153_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray15_uint8_t[15]; +static_assert_64bit(sizeof(SignalType_FixedArray15_uint8_t) == 15); +static_assert_64bit(alignof(SignalType_FixedArray15_uint8_t) == 1); +typedef const SignalType_FixedArray15_uint8_t* SignalType_ConstPointer_SignalType_FixedArray15_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray15_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray15_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray16_uint8_t[16]; +static_assert_64bit(sizeof(SignalType_FixedArray16_uint8_t) == 16); +static_assert_64bit(alignof(SignalType_FixedArray16_uint8_t) == 1); +typedef const SignalType_FixedArray16_uint8_t* SignalType_ConstPointer_SignalType_FixedArray16_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray16_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray16_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray177_uint8_t[177]; +static_assert_64bit(sizeof(SignalType_FixedArray177_uint8_t) == 177); +static_assert_64bit(alignof(SignalType_FixedArray177_uint8_t) == 1); +typedef const SignalType_FixedArray177_uint8_t* SignalType_ConstPointer_SignalType_FixedArray177_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray177_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray177_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray17_uint8_t[17]; +static_assert_64bit(sizeof(SignalType_FixedArray17_uint8_t) == 17); +static_assert_64bit(alignof(SignalType_FixedArray17_uint8_t) == 1); +typedef const SignalType_FixedArray17_uint8_t* SignalType_ConstPointer_SignalType_FixedArray17_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray17_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray17_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray289_uint8_t[289]; +static_assert_64bit(sizeof(SignalType_FixedArray289_uint8_t) == 289); +static_assert_64bit(alignof(SignalType_FixedArray289_uint8_t) == 1); +typedef const SignalType_FixedArray289_uint8_t* SignalType_ConstPointer_SignalType_FixedArray289_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray289_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray289_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray329_uint8_t[329]; +static_assert_64bit(sizeof(SignalType_FixedArray329_uint8_t) == 329); +static_assert_64bit(alignof(SignalType_FixedArray329_uint8_t) == 1); +typedef const SignalType_FixedArray329_uint8_t* SignalType_ConstPointer_SignalType_FixedArray329_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray329_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray329_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray409_uint8_t[409]; +static_assert_64bit(sizeof(SignalType_FixedArray409_uint8_t) == 409); +static_assert_64bit(alignof(SignalType_FixedArray409_uint8_t) == 1); +typedef const SignalType_FixedArray409_uint8_t* SignalType_ConstPointer_SignalType_FixedArray409_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray409_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray409_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray473_uint8_t[473]; +static_assert_64bit(sizeof(SignalType_FixedArray473_uint8_t) == 473); +static_assert_64bit(alignof(SignalType_FixedArray473_uint8_t) == 1); +typedef const SignalType_FixedArray473_uint8_t* SignalType_ConstPointer_SignalType_FixedArray473_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray473_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray473_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray497_uint8_t[497]; +static_assert_64bit(sizeof(SignalType_FixedArray497_uint8_t) == 497); +static_assert_64bit(alignof(SignalType_FixedArray497_uint8_t) == 1); +typedef const SignalType_FixedArray497_uint8_t* SignalType_ConstPointer_SignalType_FixedArray497_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray497_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray497_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray64_uint8_t[64]; +static_assert_64bit(sizeof(SignalType_FixedArray64_uint8_t) == 64); +static_assert_64bit(alignof(SignalType_FixedArray64_uint8_t) == 1); +typedef const SignalType_FixedArray64_uint8_t* SignalType_ConstPointer_SignalType_FixedArray64_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray64_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray64_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray65_uint8_t[65]; +static_assert_64bit(sizeof(SignalType_FixedArray65_uint8_t) == 65); +static_assert_64bit(alignof(SignalType_FixedArray65_uint8_t) == 1); +typedef const SignalType_FixedArray65_uint8_t* SignalType_ConstPointer_SignalType_FixedArray65_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray65_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray65_uint8_t) == 8); +typedef uint8_t SignalType_FixedArray97_uint8_t[97]; +static_assert_64bit(sizeof(SignalType_FixedArray97_uint8_t) == 97); +static_assert_64bit(alignof(SignalType_FixedArray97_uint8_t) == 1); +typedef const SignalType_FixedArray97_uint8_t* SignalType_ConstPointer_SignalType_FixedArray97_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalType_FixedArray97_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalType_FixedArray97_uint8_t) == 8); +static_assert_64bit(sizeof(bool) == 1); +static_assert_64bit(alignof(bool) == 1); +typedef const bool* SignalType_ConstPointer_bool; +static_assert_64bit(sizeof(SignalType_ConstPointer_bool) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_bool) == 8); +typedef const void* SignalType_ConstPointer_void; +static_assert_64bit(sizeof(SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_void) == 8); +static_assert_64bit(sizeof(int8_t) == 1); +static_assert_64bit(alignof(int8_t) == 1); +typedef const int8_t* SignalCStringPtr; +static_assert_64bit(sizeof(SignalCStringPtr) == 8); +static_assert_64bit(alignof(SignalCStringPtr) == 8); +typedef struct SignalPinHash SignalPinHash; +typedef const SignalPinHash* SignalType_ConstPointer_SignalPinHash; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalPinHash) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalPinHash) == 8); +typedef struct SignalAes256GcmSiv SignalAes256GcmSiv; +typedef const SignalAes256GcmSiv* SignalType_ConstPointer_SignalAes256GcmSiv; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalAes256GcmSiv) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalAes256GcmSiv) == 8); +typedef const uint8_t* SignalType_ConstPointer_uint8_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_uint8_t) == 8); +static_assert_64bit(sizeof(size_t) == 8); +static_assert_64bit(alignof(size_t) == 8); +typedef struct { + const uint8_t* base; + size_t length; +} SignalBorrowedBuffer; +static_assert_64bit(offsetof(SignalBorrowedBuffer, base) == 0); +static_assert_64bit(offsetof(SignalBorrowedBuffer, length) == 8); +static_assert_64bit(sizeof(SignalBorrowedBuffer) == 16); +static_assert_64bit(alignof(SignalBorrowedBuffer) == 8); +typedef const SignalBorrowedBuffer* SignalType_ConstPointer_SignalBorrowedBuffer; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalBorrowedBuffer) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalBorrowedBuffer) == 8); +typedef struct SignalProtocolAddress SignalProtocolAddress; +typedef const SignalProtocolAddress* SignalType_ConstPointer_SignalProtocolAddress; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalProtocolAddress) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalProtocolAddress) == 8); +typedef struct { + const SignalProtocolAddress* raw; +} SignalConstPointerProtocolAddress; +static_assert_64bit(offsetof(SignalConstPointerProtocolAddress, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerProtocolAddress) == 8); +static_assert_64bit(alignof(SignalConstPointerProtocolAddress) == 8); +typedef const SignalConstPointerProtocolAddress* SignalType_ConstPointer_SignalConstPointerProtocolAddress; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalConstPointerProtocolAddress) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalConstPointerProtocolAddress) == 8); +typedef struct SignalPublicKey SignalPublicKey; +typedef const SignalPublicKey* SignalType_ConstPointer_SignalPublicKey; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalPublicKey) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalPublicKey) == 8); +typedef struct { + const SignalPublicKey* raw; +} SignalConstPointerPublicKey; +static_assert_64bit(offsetof(SignalConstPointerPublicKey, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerPublicKey) == 8); +static_assert_64bit(alignof(SignalConstPointerPublicKey) == 8); +typedef const SignalConstPointerPublicKey* SignalType_ConstPointer_SignalConstPointerPublicKey; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalConstPointerPublicKey) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalConstPointerPublicKey) == 8); +typedef struct SignalCiphertextMessage SignalCiphertextMessage; +typedef const SignalCiphertextMessage* SignalType_ConstPointer_SignalCiphertextMessage; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalCiphertextMessage) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalCiphertextMessage) == 8); +typedef struct { + const SignalCiphertextMessage* raw; +} SignalConstPointerCiphertextMessage; +static_assert_64bit(offsetof(SignalConstPointerCiphertextMessage, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerCiphertextMessage) == 8); +static_assert_64bit(alignof(SignalConstPointerCiphertextMessage) == 8); +typedef const SignalConstPointerCiphertextMessage* SignalType_ConstPointer_SignalConstPointerCiphertextMessage; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalConstPointerCiphertextMessage) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalConstPointerCiphertextMessage) == 8); +typedef struct SignalSessionRecord SignalSessionRecord; +typedef const SignalSessionRecord* SignalType_ConstPointer_SignalSessionRecord; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalSessionRecord) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalSessionRecord) == 8); +typedef struct { + const SignalSessionRecord* raw; +} SignalConstPointerSessionRecord; +static_assert_64bit(offsetof(SignalConstPointerSessionRecord, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerSessionRecord) == 8); +static_assert_64bit(alignof(SignalConstPointerSessionRecord) == 8); +typedef const SignalConstPointerSessionRecord* SignalType_ConstPointer_SignalConstPointerSessionRecord; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalConstPointerSessionRecord) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalConstPointerSessionRecord) == 8); +static_assert_64bit(sizeof(int32_t) == 4); +static_assert_64bit(alignof(int32_t) == 4); +static_assert_64bit(sizeof(uint64_t) == 8); +static_assert_64bit(alignof(uint64_t) == 8); +typedef struct { + uint64_t e164; + SignalType_FixedArray16_uint8_t rawAciUuid; + SignalType_FixedArray16_uint8_t rawPniUuid; +} SignalFfiCdsiLookupResponseEntry; +static_assert_64bit(offsetof(SignalFfiCdsiLookupResponseEntry, e164) == 0); +static_assert_64bit(offsetof(SignalFfiCdsiLookupResponseEntry, rawAciUuid) == 8); +static_assert_64bit(offsetof(SignalFfiCdsiLookupResponseEntry, rawPniUuid) == 24); +static_assert_64bit(sizeof(SignalFfiCdsiLookupResponseEntry) == 40); +static_assert_64bit(alignof(SignalFfiCdsiLookupResponseEntry) == 8); +typedef SignalFfiCdsiLookupResponseEntry* SignalType_MutPointer_SignalFfiCdsiLookupResponseEntry; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalFfiCdsiLookupResponseEntry) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalFfiCdsiLookupResponseEntry) == 8); +typedef struct { + SignalFfiCdsiLookupResponseEntry* base; + size_t length; +} SignalOwnedLookupResponseEntryList; +static_assert_64bit(offsetof(SignalOwnedLookupResponseEntryList, base) == 0); +static_assert_64bit(offsetof(SignalOwnedLookupResponseEntryList, length) == 8); +static_assert_64bit(sizeof(SignalOwnedLookupResponseEntryList) == 16); +static_assert_64bit(alignof(SignalOwnedLookupResponseEntryList) == 8); +typedef struct { + SignalOwnedLookupResponseEntryList entries; + int32_t debug_permits_used; +} SignalFfiCdsiLookupResponse; +static_assert_64bit(offsetof(SignalFfiCdsiLookupResponse, entries) == 0); +static_assert_64bit(offsetof(SignalFfiCdsiLookupResponse, debug_permits_used) == 16); +static_assert_64bit(sizeof(SignalFfiCdsiLookupResponse) == 24); +static_assert_64bit(alignof(SignalFfiCdsiLookupResponse) == 8); +typedef const SignalFfiCdsiLookupResponse* SignalType_ConstPointer_SignalFfiCdsiLookupResponse; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiCdsiLookupResponse) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiCdsiLookupResponse) == 8); +typedef SignalCStringPtr* SignalType_MutPointer_SignalCStringPtr; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCStringPtr) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCStringPtr) == 8); +typedef struct { + SignalCStringPtr* base; + size_t length; +} SignalOwnedBufferOfCStringPtr; +static_assert_64bit(offsetof(SignalOwnedBufferOfCStringPtr, base) == 0); +static_assert_64bit(offsetof(SignalOwnedBufferOfCStringPtr, length) == 8); +static_assert_64bit(sizeof(SignalOwnedBufferOfCStringPtr) == 16); +static_assert_64bit(alignof(SignalOwnedBufferOfCStringPtr) == 8); +typedef uint8_t* SignalType_MutPointer_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_uint8_t) == 8); +typedef struct { + uint8_t* base; + size_t length; +} SignalOwnedBuffer; +static_assert_64bit(offsetof(SignalOwnedBuffer, base) == 0); +static_assert_64bit(offsetof(SignalOwnedBuffer, length) == 8); +static_assert_64bit(sizeof(SignalOwnedBuffer) == 16); +static_assert_64bit(alignof(SignalOwnedBuffer) == 8); +static_assert_64bit(sizeof(uint16_t) == 2); +static_assert_64bit(alignof(uint16_t) == 2); +typedef struct { + uint16_t status; + const int8_t* message; + SignalOwnedBufferOfCStringPtr headers; + SignalOwnedBuffer body; +} SignalFfiChatResponse; +static_assert_64bit(offsetof(SignalFfiChatResponse, status) == 0); +static_assert_64bit(offsetof(SignalFfiChatResponse, message) == 8); +static_assert_64bit(offsetof(SignalFfiChatResponse, headers) == 16); +static_assert_64bit(offsetof(SignalFfiChatResponse, body) == 32); +static_assert_64bit(sizeof(SignalFfiChatResponse) == 48); +static_assert_64bit(alignof(SignalFfiChatResponse) == 8); +typedef const SignalFfiChatResponse* SignalType_ConstPointer_SignalFfiChatResponse; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiChatResponse) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiChatResponse) == 8); +typedef size_t* SignalType_MutPointer_size_t; +static_assert_64bit(sizeof(SignalType_MutPointer_size_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_size_t) == 8); +typedef struct { + size_t* base; + size_t length; +} SignalOwnedBufferOfusize; +static_assert_64bit(offsetof(SignalOwnedBufferOfusize, base) == 0); +static_assert_64bit(offsetof(SignalOwnedBufferOfusize, length) == 8); +static_assert_64bit(sizeof(SignalOwnedBufferOfusize) == 16); +static_assert_64bit(alignof(SignalOwnedBufferOfusize) == 8); +typedef struct { + SignalOwnedBuffer bytes; + SignalOwnedBufferOfusize lengths; +} SignalBytestringArray; +static_assert_64bit(offsetof(SignalBytestringArray, bytes) == 0); +static_assert_64bit(offsetof(SignalBytestringArray, lengths) == 16); +static_assert_64bit(sizeof(SignalBytestringArray) == 32); +static_assert_64bit(alignof(SignalBytestringArray) == 8); +typedef struct { + SignalBytestringArray entries; +} SignalFfiCheckSvr2CredentialsResponse; +static_assert_64bit(offsetof(SignalFfiCheckSvr2CredentialsResponse, entries) == 0); +static_assert_64bit(sizeof(SignalFfiCheckSvr2CredentialsResponse) == 32); +static_assert_64bit(alignof(SignalFfiCheckSvr2CredentialsResponse) == 8); +typedef const SignalFfiCheckSvr2CredentialsResponse* SignalType_ConstPointer_SignalFfiCheckSvr2CredentialsResponse; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiCheckSvr2CredentialsResponse) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiCheckSvr2CredentialsResponse) == 8); +typedef SignalPublicKey* SignalType_MutPointer_SignalPublicKey; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalPublicKey) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalPublicKey) == 8); +typedef struct { + SignalPublicKey* raw; +} SignalMutPointerPublicKey; +static_assert_64bit(offsetof(SignalMutPointerPublicKey, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerPublicKey) == 8); +static_assert_64bit(alignof(SignalMutPointerPublicKey) == 8); +typedef struct SignalPreKeyBundle SignalPreKeyBundle; +typedef SignalPreKeyBundle* SignalType_MutPointer_SignalPreKeyBundle; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalPreKeyBundle) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalPreKeyBundle) == 8); +typedef struct { + SignalPreKeyBundle* raw; +} SignalMutPointerPreKeyBundle; +static_assert_64bit(offsetof(SignalMutPointerPreKeyBundle, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerPreKeyBundle) == 8); +static_assert_64bit(alignof(SignalMutPointerPreKeyBundle) == 8); +typedef SignalMutPointerPreKeyBundle* SignalType_MutPointer_SignalMutPointerPreKeyBundle; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerPreKeyBundle) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerPreKeyBundle) == 8); +typedef struct { + SignalMutPointerPreKeyBundle* base; + size_t length; +} SignalOwnedBufferOfMutPointerPreKeyBundle; +static_assert_64bit(offsetof(SignalOwnedBufferOfMutPointerPreKeyBundle, base) == 0); +static_assert_64bit(offsetof(SignalOwnedBufferOfMutPointerPreKeyBundle, length) == 8); +static_assert_64bit(sizeof(SignalOwnedBufferOfMutPointerPreKeyBundle) == 16); +static_assert_64bit(alignof(SignalOwnedBufferOfMutPointerPreKeyBundle) == 8); +typedef struct { + SignalMutPointerPublicKey identity_key; + SignalOwnedBufferOfMutPointerPreKeyBundle pre_key_bundles; +} SignalFfiPreKeysResponse; +static_assert_64bit(offsetof(SignalFfiPreKeysResponse, identity_key) == 0); +static_assert_64bit(offsetof(SignalFfiPreKeysResponse, pre_key_bundles) == 8); +static_assert_64bit(sizeof(SignalFfiPreKeysResponse) == 24); +static_assert_64bit(alignof(SignalFfiPreKeysResponse) == 8); +typedef const SignalFfiPreKeysResponse* SignalType_ConstPointer_SignalFfiPreKeysResponse; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiPreKeysResponse) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiPreKeysResponse) == 8); +static_assert_64bit(sizeof(uint32_t) == 4); +static_assert_64bit(alignof(uint32_t) == 4); +typedef struct { + uint32_t cdn; + const int8_t* key; + SignalOwnedBufferOfCStringPtr header_keys; + SignalOwnedBufferOfCStringPtr header_values; + const int8_t* signed_upload_url; +} SignalFfiUploadForm; +static_assert_64bit(offsetof(SignalFfiUploadForm, cdn) == 0); +static_assert_64bit(offsetof(SignalFfiUploadForm, key) == 8); +static_assert_64bit(offsetof(SignalFfiUploadForm, header_keys) == 16); +static_assert_64bit(offsetof(SignalFfiUploadForm, header_values) == 32); +static_assert_64bit(offsetof(SignalFfiUploadForm, signed_upload_url) == 48); +static_assert_64bit(sizeof(SignalFfiUploadForm) == 56); +static_assert_64bit(alignof(SignalFfiUploadForm) == 8); +typedef const SignalFfiUploadForm* SignalType_ConstPointer_SignalFfiUploadForm; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiUploadForm) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiUploadForm) == 8); +typedef struct SignalCdsiLookup SignalCdsiLookup; +typedef SignalCdsiLookup* SignalType_MutPointer_SignalCdsiLookup; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCdsiLookup) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCdsiLookup) == 8); +typedef struct { + SignalCdsiLookup* raw; +} SignalMutPointerCdsiLookup; +static_assert_64bit(offsetof(SignalMutPointerCdsiLookup, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerCdsiLookup) == 8); +static_assert_64bit(alignof(SignalMutPointerCdsiLookup) == 8); +typedef const SignalMutPointerCdsiLookup* SignalType_ConstPointer_SignalMutPointerCdsiLookup; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalMutPointerCdsiLookup) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalMutPointerCdsiLookup) == 8); +typedef struct SignalAuthenticatedChatConnection SignalAuthenticatedChatConnection; +typedef SignalAuthenticatedChatConnection* SignalType_MutPointer_SignalAuthenticatedChatConnection; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalAuthenticatedChatConnection) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalAuthenticatedChatConnection) == 8); +typedef struct { + SignalAuthenticatedChatConnection* raw; +} SignalMutPointerAuthenticatedChatConnection; +static_assert_64bit(offsetof(SignalMutPointerAuthenticatedChatConnection, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerAuthenticatedChatConnection) == 8); +static_assert_64bit(alignof(SignalMutPointerAuthenticatedChatConnection) == 8); +typedef const SignalMutPointerAuthenticatedChatConnection* SignalType_ConstPointer_SignalMutPointerAuthenticatedChatConnection; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalMutPointerAuthenticatedChatConnection) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalMutPointerAuthenticatedChatConnection) == 8); +typedef struct SignalProvisioningChatConnection SignalProvisioningChatConnection; +typedef SignalProvisioningChatConnection* SignalType_MutPointer_SignalProvisioningChatConnection; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalProvisioningChatConnection) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalProvisioningChatConnection) == 8); +typedef struct { + SignalProvisioningChatConnection* raw; +} SignalMutPointerProvisioningChatConnection; +static_assert_64bit(offsetof(SignalMutPointerProvisioningChatConnection, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerProvisioningChatConnection) == 8); +static_assert_64bit(alignof(SignalMutPointerProvisioningChatConnection) == 8); +typedef const SignalMutPointerProvisioningChatConnection* SignalType_ConstPointer_SignalMutPointerProvisioningChatConnection; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalMutPointerProvisioningChatConnection) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalMutPointerProvisioningChatConnection) == 8); +typedef struct SignalUnauthenticatedChatConnection SignalUnauthenticatedChatConnection; +typedef SignalUnauthenticatedChatConnection* SignalType_MutPointer_SignalUnauthenticatedChatConnection; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalUnauthenticatedChatConnection) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalUnauthenticatedChatConnection) == 8); +typedef struct { + SignalUnauthenticatedChatConnection* raw; +} SignalMutPointerUnauthenticatedChatConnection; +static_assert_64bit(offsetof(SignalMutPointerUnauthenticatedChatConnection, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerUnauthenticatedChatConnection) == 8); +static_assert_64bit(alignof(SignalMutPointerUnauthenticatedChatConnection) == 8); +typedef const SignalMutPointerUnauthenticatedChatConnection* SignalType_ConstPointer_SignalMutPointerUnauthenticatedChatConnection; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalMutPointerUnauthenticatedChatConnection) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalMutPointerUnauthenticatedChatConnection) == 8); +typedef struct SignalRegistrationService SignalRegistrationService; +typedef SignalRegistrationService* SignalType_MutPointer_SignalRegistrationService; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalRegistrationService) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalRegistrationService) == 8); +typedef struct { + SignalRegistrationService* raw; +} SignalMutPointerRegistrationService; +static_assert_64bit(offsetof(SignalMutPointerRegistrationService, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerRegistrationService) == 8); +static_assert_64bit(alignof(SignalMutPointerRegistrationService) == 8); +typedef const SignalMutPointerRegistrationService* SignalType_ConstPointer_SignalMutPointerRegistrationService; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalMutPointerRegistrationService) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalMutPointerRegistrationService) == 8); +typedef struct SignalBackupRestoreResponse SignalBackupRestoreResponse; +typedef SignalBackupRestoreResponse* SignalType_MutPointer_SignalBackupRestoreResponse; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalBackupRestoreResponse) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalBackupRestoreResponse) == 8); +typedef struct { + SignalBackupRestoreResponse* raw; +} SignalMutPointerBackupRestoreResponse; +static_assert_64bit(offsetof(SignalMutPointerBackupRestoreResponse, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerBackupRestoreResponse) == 8); +static_assert_64bit(alignof(SignalMutPointerBackupRestoreResponse) == 8); +typedef const SignalMutPointerBackupRestoreResponse* SignalType_ConstPointer_SignalMutPointerBackupRestoreResponse; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalMutPointerBackupRestoreResponse) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalMutPointerBackupRestoreResponse) == 8); +typedef struct SignalBackupStoreResponse SignalBackupStoreResponse; +typedef SignalBackupStoreResponse* SignalType_MutPointer_SignalBackupStoreResponse; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalBackupStoreResponse) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalBackupStoreResponse) == 8); +typedef struct { + SignalBackupStoreResponse* raw; +} SignalMutPointerBackupStoreResponse; +static_assert_64bit(offsetof(SignalMutPointerBackupStoreResponse, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerBackupStoreResponse) == 8); +static_assert_64bit(alignof(SignalMutPointerBackupStoreResponse) == 8); +typedef const SignalMutPointerBackupStoreResponse* SignalType_ConstPointer_SignalMutPointerBackupStoreResponse; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalMutPointerBackupStoreResponse) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalMutPointerBackupStoreResponse) == 8); +typedef struct SignalRegisterAccountResponse SignalRegisterAccountResponse; +typedef SignalRegisterAccountResponse* SignalType_MutPointer_SignalRegisterAccountResponse; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalRegisterAccountResponse) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalRegisterAccountResponse) == 8); +typedef struct { + SignalRegisterAccountResponse* raw; +} SignalMutPointerRegisterAccountResponse; +static_assert_64bit(offsetof(SignalMutPointerRegisterAccountResponse, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerRegisterAccountResponse) == 8); +static_assert_64bit(alignof(SignalMutPointerRegisterAccountResponse) == 8); +typedef const SignalMutPointerRegisterAccountResponse* SignalType_ConstPointer_SignalMutPointerRegisterAccountResponse; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalMutPointerRegisterAccountResponse) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalMutPointerRegisterAccountResponse) == 8); +typedef struct { + bool present; + const int8_t* first; + SignalType_FixedArray32_uint8_t second; +} SignalOptionalPairOfCStringPtrc_uchar32; +static_assert_64bit(offsetof(SignalOptionalPairOfCStringPtrc_uchar32, present) == 0); +static_assert_64bit(offsetof(SignalOptionalPairOfCStringPtrc_uchar32, first) == 8); +static_assert_64bit(offsetof(SignalOptionalPairOfCStringPtrc_uchar32, second) == 16); +static_assert_64bit(sizeof(SignalOptionalPairOfCStringPtrc_uchar32) == 48); +static_assert_64bit(alignof(SignalOptionalPairOfCStringPtrc_uchar32) == 8); +typedef const SignalOptionalPairOfCStringPtrc_uchar32* SignalType_ConstPointer_SignalOptionalPairOfCStringPtrc_uchar32; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalOptionalPairOfCStringPtrc_uchar32) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalOptionalPairOfCStringPtrc_uchar32) == 8); +typedef struct { + bool present; + SignalType_FixedArray16_uint8_t bytes; +} SignalOptionalUuid; +static_assert_64bit(offsetof(SignalOptionalUuid, present) == 0); +static_assert_64bit(offsetof(SignalOptionalUuid, bytes) == 1); +static_assert_64bit(sizeof(SignalOptionalUuid) == 17); +static_assert_64bit(alignof(SignalOptionalUuid) == 1); +typedef const SignalOptionalUuid* SignalType_ConstPointer_SignalOptionalUuid; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalOptionalUuid) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalOptionalUuid) == 8); +typedef SignalType_FixedArray17_uint8_t* SignalType_MutPointer_SignalType_FixedArray17_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray17_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray17_uint8_t) == 8); +typedef struct { + SignalType_FixedArray17_uint8_t* base; + size_t length; +} SignalOwnedBufferOfc_uchar17; +static_assert_64bit(offsetof(SignalOwnedBufferOfc_uchar17, base) == 0); +static_assert_64bit(offsetof(SignalOwnedBufferOfc_uchar17, length) == 8); +static_assert_64bit(sizeof(SignalOwnedBufferOfc_uchar17) == 16); +static_assert_64bit(alignof(SignalOwnedBufferOfc_uchar17) == 8); +typedef const SignalOwnedBufferOfc_uchar17* SignalType_ConstPointer_SignalOwnedBufferOfc_uchar17; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalOwnedBufferOfc_uchar17) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalOwnedBufferOfc_uchar17) == 8); +typedef const SignalOwnedBuffer* SignalType_ConstPointer_SignalOwnedBuffer; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalOwnedBuffer) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalOwnedBuffer) == 8); +typedef struct { + uint8_t id; + SignalOwnedBuffer encrypted_name; + uint64_t last_seen; + uint16_t registration_id; + SignalOwnedBuffer created_at_ciphertext; +} SignalLinkedDeviceInternalFfiResult; +static_assert_64bit(offsetof(SignalLinkedDeviceInternalFfiResult, id) == 0); +static_assert_64bit(offsetof(SignalLinkedDeviceInternalFfiResult, encrypted_name) == 8); +static_assert_64bit(offsetof(SignalLinkedDeviceInternalFfiResult, last_seen) == 24); +static_assert_64bit(offsetof(SignalLinkedDeviceInternalFfiResult, registration_id) == 32); +static_assert_64bit(offsetof(SignalLinkedDeviceInternalFfiResult, created_at_ciphertext) == 40); +static_assert_64bit(sizeof(SignalLinkedDeviceInternalFfiResult) == 56); +static_assert_64bit(alignof(SignalLinkedDeviceInternalFfiResult) == 8); +typedef SignalLinkedDeviceInternalFfiResult* SignalType_MutPointer_SignalLinkedDeviceInternalFfiResult; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalLinkedDeviceInternalFfiResult) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalLinkedDeviceInternalFfiResult) == 8); +typedef struct { + SignalLinkedDeviceInternalFfiResult* base; + size_t length; + size_t size_bytes; +} SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult; +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult, base) == 0); +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult, length) == 8); +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult, size_bytes) == 16); +static_assert_64bit(sizeof(SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult) == 24); +static_assert_64bit(alignof(SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult) == 8); +typedef const SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult* SignalType_ConstPointer_SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult) == 8); +typedef struct { + const int8_t* first; + const int8_t* second; +} SignalPairOfCStringPtrCStringPtr; +static_assert_64bit(offsetof(SignalPairOfCStringPtrCStringPtr, first) == 0); +static_assert_64bit(offsetof(SignalPairOfCStringPtrCStringPtr, second) == 8); +static_assert_64bit(sizeof(SignalPairOfCStringPtrCStringPtr) == 16); +static_assert_64bit(alignof(SignalPairOfCStringPtrCStringPtr) == 8); +typedef const SignalPairOfCStringPtrCStringPtr* SignalType_ConstPointer_SignalPairOfCStringPtrCStringPtr; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalPairOfCStringPtrCStringPtr) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalPairOfCStringPtrCStringPtr) == 8); +typedef struct { + SignalOwnedBufferOfCStringPtr first; + SignalOwnedBufferOfCStringPtr second; +} SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr; +static_assert_64bit(offsetof(SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr, first) == 0); +static_assert_64bit(offsetof(SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr, second) == 16); +static_assert_64bit(sizeof(SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr) == 32); +static_assert_64bit(alignof(SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr) == 8); +typedef const SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr* SignalType_ConstPointer_SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr) == 8); +typedef struct { + SignalOwnedBuffer first; + SignalOwnedBuffer second; +} SignalPairOfOwnedBufferOwnedBuffer; +static_assert_64bit(offsetof(SignalPairOfOwnedBufferOwnedBuffer, first) == 0); +static_assert_64bit(offsetof(SignalPairOfOwnedBufferOwnedBuffer, second) == 16); +static_assert_64bit(sizeof(SignalPairOfOwnedBufferOwnedBuffer) == 32); +static_assert_64bit(alignof(SignalPairOfOwnedBufferOwnedBuffer) == 8); +typedef const SignalPairOfOwnedBufferOwnedBuffer* SignalType_ConstPointer_SignalPairOfOwnedBufferOwnedBuffer; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalPairOfOwnedBufferOwnedBuffer) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalPairOfOwnedBufferOwnedBuffer) == 8); +typedef struct { + SignalType_FixedArray16_uint8_t bytes; +} SignalUuid; +static_assert_64bit(offsetof(SignalUuid, bytes) == 0); +static_assert_64bit(sizeof(SignalUuid) == 16); +static_assert_64bit(alignof(SignalUuid) == 1); +typedef const SignalUuid* SignalType_ConstPointer_SignalUuid; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalUuid) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalUuid) == 8); +typedef void* SignalType_MutPointer_void; +static_assert_64bit(sizeof(SignalType_MutPointer_void) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_void) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_void)(SignalType_MutPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_void) == 8); +typedef struct SignalConnectionManager SignalConnectionManager; +typedef const SignalConnectionManager* SignalType_ConstPointer_SignalConnectionManager; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalConnectionManager) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalConnectionManager) == 8); +typedef SignalType_ConstPointer_SignalConnectionManager (*SignalType_FunctionPointer_SignalType_ConstPointer_SignalConnectionManager_SignalType_MutPointer_void)(SignalType_MutPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_SignalType_ConstPointer_SignalConnectionManager_SignalType_MutPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_SignalType_ConstPointer_SignalConnectionManager_SignalType_MutPointer_void) == 8); +typedef struct { + void* ctx; + SignalType_FunctionPointer_SignalType_ConstPointer_SignalConnectionManager_SignalType_MutPointer_void get_connection_manager; + SignalType_FunctionPointer_void_SignalType_MutPointer_void destroy; +} SignalFfiConnectChatBridgeStruct; +static_assert_64bit(offsetof(SignalFfiConnectChatBridgeStruct, ctx) == 0); +static_assert_64bit(offsetof(SignalFfiConnectChatBridgeStruct, get_connection_manager) == 8); +static_assert_64bit(offsetof(SignalFfiConnectChatBridgeStruct, destroy) == 16); +static_assert_64bit(sizeof(SignalFfiConnectChatBridgeStruct) == 24); +static_assert_64bit(alignof(SignalFfiConnectChatBridgeStruct) == 8); +typedef const SignalFfiConnectChatBridgeStruct* SignalType_ConstPointer_SignalFfiConnectChatBridgeStruct; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiConnectChatBridgeStruct) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiConnectChatBridgeStruct) == 8); +typedef struct SignalFfiError SignalFfiError; +typedef const SignalFfiError* SignalType_ConstPointer_SignalFfiError; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiError) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiError) == 8); +typedef struct SignalHsmEnclaveClient SignalHsmEnclaveClient; +typedef const SignalHsmEnclaveClient* SignalType_ConstPointer_SignalHsmEnclaveClient; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalHsmEnclaveClient) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalHsmEnclaveClient) == 8); +typedef struct { + uint8_t* base; + size_t length; +} SignalBorrowedMutableBuffer; +static_assert_64bit(offsetof(SignalBorrowedMutableBuffer, base) == 0); +static_assert_64bit(offsetof(SignalBorrowedMutableBuffer, length) == 8); +static_assert_64bit(sizeof(SignalBorrowedMutableBuffer) == 16); +static_assert_64bit(alignof(SignalBorrowedMutableBuffer) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_size_t_SignalBorrowedMutableBuffer)(SignalType_MutPointer_void, SignalType_MutPointer_size_t, SignalBorrowedMutableBuffer); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_size_t_SignalBorrowedMutableBuffer) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_size_t_SignalBorrowedMutableBuffer) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint64_t)(SignalType_MutPointer_void, uint64_t); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint64_t) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint64_t) == 8); +typedef struct { + void* ctx; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_size_t_SignalBorrowedMutableBuffer read; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint64_t skip; + SignalType_FunctionPointer_void_SignalType_MutPointer_void destroy; +} SignalFfiSyncInputStreamStruct; +static_assert_64bit(offsetof(SignalFfiSyncInputStreamStruct, ctx) == 0); +static_assert_64bit(offsetof(SignalFfiSyncInputStreamStruct, read) == 8); +static_assert_64bit(offsetof(SignalFfiSyncInputStreamStruct, skip) == 16); +static_assert_64bit(offsetof(SignalFfiSyncInputStreamStruct, destroy) == 24); +static_assert_64bit(sizeof(SignalFfiSyncInputStreamStruct) == 32); +static_assert_64bit(alignof(SignalFfiSyncInputStreamStruct) == 8); +typedef const SignalFfiSyncInputStreamStruct* SignalType_ConstPointer_SignalFfiSyncInputStreamStruct; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiSyncInputStreamStruct) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiSyncInputStreamStruct) == 8); +typedef struct SignalMessageBackupKey SignalMessageBackupKey; +typedef const SignalMessageBackupKey* SignalType_ConstPointer_SignalMessageBackupKey; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalMessageBackupKey) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalMessageBackupKey) == 8); +typedef struct SignalMessageBackupValidationOutcome SignalMessageBackupValidationOutcome; +typedef const SignalMessageBackupValidationOutcome* SignalType_ConstPointer_SignalMessageBackupValidationOutcome; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalMessageBackupValidationOutcome) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalMessageBackupValidationOutcome) == 8); +typedef const SignalCdsiLookup* SignalType_ConstPointer_SignalCdsiLookup; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalCdsiLookup) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalCdsiLookup) == 8); +typedef struct SignalLookupRequest SignalLookupRequest; +typedef const SignalLookupRequest* SignalType_ConstPointer_SignalLookupRequest; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalLookupRequest) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalLookupRequest) == 8); +typedef const SignalAuthenticatedChatConnection* SignalType_ConstPointer_SignalAuthenticatedChatConnection; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalAuthenticatedChatConnection) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalAuthenticatedChatConnection) == 8); +static_assert_64bit(sizeof(int64_t) == 8); +static_assert_64bit(alignof(int64_t) == 8); +typedef struct { + int32_t source_attachment_cdn; + const int8_t* source_key; + int64_t object_length; + const SignalType_FixedArray15_uint8_t* media_id; + const SignalType_FixedArray64_uint8_t* encryption_key; +} SignalBridgeCopyBackupMediaItemFfiArg; +static_assert_64bit(offsetof(SignalBridgeCopyBackupMediaItemFfiArg, source_attachment_cdn) == 0); +static_assert_64bit(offsetof(SignalBridgeCopyBackupMediaItemFfiArg, source_key) == 8); +static_assert_64bit(offsetof(SignalBridgeCopyBackupMediaItemFfiArg, object_length) == 16); +static_assert_64bit(offsetof(SignalBridgeCopyBackupMediaItemFfiArg, media_id) == 24); +static_assert_64bit(offsetof(SignalBridgeCopyBackupMediaItemFfiArg, encryption_key) == 32); +static_assert_64bit(sizeof(SignalBridgeCopyBackupMediaItemFfiArg) == 40); +static_assert_64bit(alignof(SignalBridgeCopyBackupMediaItemFfiArg) == 8); +typedef const SignalBridgeCopyBackupMediaItemFfiArg* SignalType_ConstPointer_SignalBridgeCopyBackupMediaItemFfiArg; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalBridgeCopyBackupMediaItemFfiArg) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalBridgeCopyBackupMediaItemFfiArg) == 8); +typedef struct { + const SignalType_FixedArray15_uint8_t* media_id; + int32_t cdn; +} SignalBridgeDeleteBackupMediaItemFfiArg; +static_assert_64bit(offsetof(SignalBridgeDeleteBackupMediaItemFfiArg, media_id) == 0); +static_assert_64bit(offsetof(SignalBridgeDeleteBackupMediaItemFfiArg, cdn) == 8); +static_assert_64bit(sizeof(SignalBridgeDeleteBackupMediaItemFfiArg) == 16); +static_assert_64bit(alignof(SignalBridgeDeleteBackupMediaItemFfiArg) == 8); +typedef const SignalBridgeDeleteBackupMediaItemFfiArg* SignalType_ConstPointer_SignalBridgeDeleteBackupMediaItemFfiArg; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalBridgeDeleteBackupMediaItemFfiArg) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalBridgeDeleteBackupMediaItemFfiArg) == 8); +typedef struct { + const int8_t* backup_dir; + const int8_t* media_dir; + int64_t used_space; +} SignalBridgeMediaBackupInfoFfiResult; +static_assert_64bit(offsetof(SignalBridgeMediaBackupInfoFfiResult, backup_dir) == 0); +static_assert_64bit(offsetof(SignalBridgeMediaBackupInfoFfiResult, media_dir) == 8); +static_assert_64bit(offsetof(SignalBridgeMediaBackupInfoFfiResult, used_space) == 16); +static_assert_64bit(sizeof(SignalBridgeMediaBackupInfoFfiResult) == 24); +static_assert_64bit(alignof(SignalBridgeMediaBackupInfoFfiResult) == 8); +typedef const SignalBridgeMediaBackupInfoFfiResult* SignalType_ConstPointer_SignalBridgeMediaBackupInfoFfiResult; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalBridgeMediaBackupInfoFfiResult) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalBridgeMediaBackupInfoFfiResult) == 8); +typedef struct { + const int8_t* backup_dir; + int32_t cdn; + const int8_t* backup_name; +} SignalBridgeMessageBackupInfoFfiResult; +static_assert_64bit(offsetof(SignalBridgeMessageBackupInfoFfiResult, backup_dir) == 0); +static_assert_64bit(offsetof(SignalBridgeMessageBackupInfoFfiResult, cdn) == 8); +static_assert_64bit(offsetof(SignalBridgeMessageBackupInfoFfiResult, backup_name) == 16); +static_assert_64bit(sizeof(SignalBridgeMessageBackupInfoFfiResult) == 24); +static_assert_64bit(alignof(SignalBridgeMessageBackupInfoFfiResult) == 8); +typedef const SignalBridgeMessageBackupInfoFfiResult* SignalType_ConstPointer_SignalBridgeMessageBackupInfoFfiResult; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalBridgeMessageBackupInfoFfiResult) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalBridgeMessageBackupInfoFfiResult) == 8); +typedef enum { + SignalBridgeCopyBackupMediaResultFfiResultSuccess, + SignalBridgeCopyBackupMediaResultFfiResultSourceNotFound, + SignalBridgeCopyBackupMediaResultFfiResultWrongSourceLength, + SignalBridgeCopyBackupMediaResultFfiResultOutOfSpace, +} SignalBridgeCopyBackupMediaResultFfiResult_Tag; +typedef struct { + int32_t cdn; +} SignalBridgeCopyBackupMediaResultFfiResultSignalSuccess_Body; +typedef struct { + SignalBridgeCopyBackupMediaResultFfiResult_Tag tag; + union { + SignalBridgeCopyBackupMediaResultFfiResultSignalSuccess_Body success; + }; +} SignalBridgeCopyBackupMediaResultFfiResult; +static_assert_64bit(sizeof(SignalBridgeCopyBackupMediaResultFfiResult) == 8); +static_assert_64bit(alignof(SignalBridgeCopyBackupMediaResultFfiResult) == 4); +typedef struct { + SignalType_FixedArray15_uint8_t media_id; + SignalBridgeCopyBackupMediaResultFfiResult result; +} SignalBridgeCopyBackupMediaOutcomeFfiResult; +static_assert_64bit(offsetof(SignalBridgeCopyBackupMediaOutcomeFfiResult, media_id) == 0); +static_assert_64bit(offsetof(SignalBridgeCopyBackupMediaOutcomeFfiResult, result) == 16); +static_assert_64bit(sizeof(SignalBridgeCopyBackupMediaOutcomeFfiResult) == 24); +static_assert_64bit(alignof(SignalBridgeCopyBackupMediaOutcomeFfiResult) == 4); +typedef SignalBridgeCopyBackupMediaOutcomeFfiResult* SignalType_MutPointer_SignalBridgeCopyBackupMediaOutcomeFfiResult; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalBridgeCopyBackupMediaOutcomeFfiResult) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalBridgeCopyBackupMediaOutcomeFfiResult) == 8); +typedef struct { + SignalBridgeCopyBackupMediaOutcomeFfiResult* base; + size_t length; + size_t size_bytes; +} SignalOwnedBufferOfMaxAlignedBridgeCopyBackupMediaOutcomeFfiResult; +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedBridgeCopyBackupMediaOutcomeFfiResult, base) == 0); +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedBridgeCopyBackupMediaOutcomeFfiResult, length) == 8); +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedBridgeCopyBackupMediaOutcomeFfiResult, size_bytes) == 16); +static_assert_64bit(sizeof(SignalOwnedBufferOfMaxAlignedBridgeCopyBackupMediaOutcomeFfiResult) == 24); +static_assert_64bit(alignof(SignalOwnedBufferOfMaxAlignedBridgeCopyBackupMediaOutcomeFfiResult) == 8); +typedef SignalFfiError* SignalType_MutPointer_SignalFfiError; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalFfiError) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalFfiError) == 8); +typedef struct { + SignalFfiError* raw; +} SignalFfiBulkPolledStreamTerminationReason; +static_assert_64bit(offsetof(SignalFfiBulkPolledStreamTerminationReason, raw) == 0); +static_assert_64bit(sizeof(SignalFfiBulkPolledStreamTerminationReason) == 8); +static_assert_64bit(alignof(SignalFfiBulkPolledStreamTerminationReason) == 8); +typedef struct { + SignalOwnedBufferOfMaxAlignedBridgeCopyBackupMediaOutcomeFfiResult chunk; + SignalFfiBulkPolledStreamTerminationReason termination; +} SignalCopyBackupMediaNextChunkFfiResult; +static_assert_64bit(offsetof(SignalCopyBackupMediaNextChunkFfiResult, chunk) == 0); +static_assert_64bit(offsetof(SignalCopyBackupMediaNextChunkFfiResult, termination) == 24); +static_assert_64bit(sizeof(SignalCopyBackupMediaNextChunkFfiResult) == 32); +static_assert_64bit(alignof(SignalCopyBackupMediaNextChunkFfiResult) == 8); +typedef const SignalCopyBackupMediaNextChunkFfiResult* SignalType_ConstPointer_SignalCopyBackupMediaNextChunkFfiResult; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalCopyBackupMediaNextChunkFfiResult) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalCopyBackupMediaNextChunkFfiResult) == 8); +typedef struct SignalCopyBackupMediaStream SignalCopyBackupMediaStream; +typedef const SignalCopyBackupMediaStream* SignalType_ConstPointer_SignalCopyBackupMediaStream; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalCopyBackupMediaStream) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalCopyBackupMediaStream) == 8); +typedef struct { + SignalType_FixedArray15_uint8_t media_id; + int32_t cdn; +} SignalBridgeDeleteBackupMediaItemFfiResult; +static_assert_64bit(offsetof(SignalBridgeDeleteBackupMediaItemFfiResult, media_id) == 0); +static_assert_64bit(offsetof(SignalBridgeDeleteBackupMediaItemFfiResult, cdn) == 16); +static_assert_64bit(sizeof(SignalBridgeDeleteBackupMediaItemFfiResult) == 20); +static_assert_64bit(alignof(SignalBridgeDeleteBackupMediaItemFfiResult) == 4); +typedef SignalBridgeDeleteBackupMediaItemFfiResult* SignalType_MutPointer_SignalBridgeDeleteBackupMediaItemFfiResult; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalBridgeDeleteBackupMediaItemFfiResult) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalBridgeDeleteBackupMediaItemFfiResult) == 8); +typedef struct { + SignalBridgeDeleteBackupMediaItemFfiResult* base; + size_t length; + size_t size_bytes; +} SignalOwnedBufferOfMaxAlignedBridgeDeleteBackupMediaItemFfiResult; +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedBridgeDeleteBackupMediaItemFfiResult, base) == 0); +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedBridgeDeleteBackupMediaItemFfiResult, length) == 8); +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedBridgeDeleteBackupMediaItemFfiResult, size_bytes) == 16); +static_assert_64bit(sizeof(SignalOwnedBufferOfMaxAlignedBridgeDeleteBackupMediaItemFfiResult) == 24); +static_assert_64bit(alignof(SignalOwnedBufferOfMaxAlignedBridgeDeleteBackupMediaItemFfiResult) == 8); +typedef struct { + SignalOwnedBufferOfMaxAlignedBridgeDeleteBackupMediaItemFfiResult chunk; + SignalFfiBulkPolledStreamTerminationReason termination; +} SignalDeleteBackupMediaNextChunkFfiResult; +static_assert_64bit(offsetof(SignalDeleteBackupMediaNextChunkFfiResult, chunk) == 0); +static_assert_64bit(offsetof(SignalDeleteBackupMediaNextChunkFfiResult, termination) == 24); +static_assert_64bit(sizeof(SignalDeleteBackupMediaNextChunkFfiResult) == 32); +static_assert_64bit(alignof(SignalDeleteBackupMediaNextChunkFfiResult) == 8); +typedef const SignalDeleteBackupMediaNextChunkFfiResult* SignalType_ConstPointer_SignalDeleteBackupMediaNextChunkFfiResult; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalDeleteBackupMediaNextChunkFfiResult) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalDeleteBackupMediaNextChunkFfiResult) == 8); +typedef struct SignalDeleteBackupMediaStream SignalDeleteBackupMediaStream; +typedef const SignalDeleteBackupMediaStream* SignalType_ConstPointer_SignalDeleteBackupMediaStream; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalDeleteBackupMediaStream) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalDeleteBackupMediaStream) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void)(SignalType_MutPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalFfiError)(SignalType_MutPointer_void, SignalType_MutPointer_SignalFfiError); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalFfiError) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalFfiError) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalBytestringArray)(SignalType_MutPointer_void, SignalBytestringArray); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalBytestringArray) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalBytestringArray) == 8); +typedef struct SignalServerMessageAck SignalServerMessageAck; +typedef SignalServerMessageAck* SignalType_MutPointer_SignalServerMessageAck; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalServerMessageAck) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalServerMessageAck) == 8); +typedef struct { + SignalServerMessageAck* raw; +} SignalMutPointerServerMessageAck; +static_assert_64bit(offsetof(SignalMutPointerServerMessageAck, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerServerMessageAck) == 8); +static_assert_64bit(alignof(SignalMutPointerServerMessageAck) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalOwnedBuffer_uint64_t_SignalMutPointerServerMessageAck)(SignalType_MutPointer_void, SignalOwnedBuffer, uint64_t, SignalMutPointerServerMessageAck); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalOwnedBuffer_uint64_t_SignalMutPointerServerMessageAck) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalOwnedBuffer_uint64_t_SignalMutPointerServerMessageAck) == 8); +typedef struct { + void* ctx; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalOwnedBuffer_uint64_t_SignalMutPointerServerMessageAck received_incoming_message; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void received_queue_empty; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalBytestringArray received_alerts; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint64_t received_server_timestamp; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalFfiError connection_interrupted; + SignalType_FunctionPointer_void_SignalType_MutPointer_void destroy; +} SignalFfiChatListenerStruct; +static_assert_64bit(offsetof(SignalFfiChatListenerStruct, ctx) == 0); +static_assert_64bit(offsetof(SignalFfiChatListenerStruct, received_incoming_message) == 8); +static_assert_64bit(offsetof(SignalFfiChatListenerStruct, received_queue_empty) == 16); +static_assert_64bit(offsetof(SignalFfiChatListenerStruct, received_alerts) == 24); +static_assert_64bit(offsetof(SignalFfiChatListenerStruct, received_server_timestamp) == 32); +static_assert_64bit(offsetof(SignalFfiChatListenerStruct, connection_interrupted) == 40); +static_assert_64bit(offsetof(SignalFfiChatListenerStruct, destroy) == 48); +static_assert_64bit(sizeof(SignalFfiChatListenerStruct) == 56); +static_assert_64bit(alignof(SignalFfiChatListenerStruct) == 8); +typedef const SignalFfiChatListenerStruct* SignalType_ConstPointer_SignalFfiChatListenerStruct; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiChatListenerStruct) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiChatListenerStruct) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalCStringPtr_SignalMutPointerServerMessageAck)(SignalType_MutPointer_void, SignalCStringPtr, SignalMutPointerServerMessageAck); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalCStringPtr_SignalMutPointerServerMessageAck) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalCStringPtr_SignalMutPointerServerMessageAck) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalOwnedBuffer_SignalMutPointerServerMessageAck)(SignalType_MutPointer_void, SignalOwnedBuffer, SignalMutPointerServerMessageAck); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalOwnedBuffer_SignalMutPointerServerMessageAck) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalOwnedBuffer_SignalMutPointerServerMessageAck) == 8); +typedef struct { + void* ctx; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalCStringPtr_SignalMutPointerServerMessageAck received_address; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalOwnedBuffer_SignalMutPointerServerMessageAck received_envelope; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalFfiError connection_interrupted; + SignalType_FunctionPointer_void_SignalType_MutPointer_void destroy; +} SignalFfiProvisioningListenerStruct; +static_assert_64bit(offsetof(SignalFfiProvisioningListenerStruct, ctx) == 0); +static_assert_64bit(offsetof(SignalFfiProvisioningListenerStruct, received_address) == 8); +static_assert_64bit(offsetof(SignalFfiProvisioningListenerStruct, received_envelope) == 16); +static_assert_64bit(offsetof(SignalFfiProvisioningListenerStruct, connection_interrupted) == 24); +static_assert_64bit(offsetof(SignalFfiProvisioningListenerStruct, destroy) == 32); +static_assert_64bit(sizeof(SignalFfiProvisioningListenerStruct) == 40); +static_assert_64bit(alignof(SignalFfiProvisioningListenerStruct) == 8); +typedef const SignalFfiProvisioningListenerStruct* SignalType_ConstPointer_SignalFfiProvisioningListenerStruct; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiProvisioningListenerStruct) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiProvisioningListenerStruct) == 8); +typedef struct SignalHttpRequest SignalHttpRequest; +typedef const SignalHttpRequest* SignalType_ConstPointer_SignalHttpRequest; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalHttpRequest) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalHttpRequest) == 8); +typedef const SignalProvisioningChatConnection* SignalType_ConstPointer_SignalProvisioningChatConnection; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalProvisioningChatConnection) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalProvisioningChatConnection) == 8); +typedef const SignalServerMessageAck* SignalType_ConstPointer_SignalServerMessageAck; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalServerMessageAck) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalServerMessageAck) == 8); +typedef const SignalUnauthenticatedChatConnection* SignalType_ConstPointer_SignalUnauthenticatedChatConnection; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalUnauthenticatedChatConnection) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalUnauthenticatedChatConnection) == 8); +typedef struct { + int32_t cdn; + SignalType_FixedArray15_uint8_t media_id; + int64_t object_length; +} SignalListMediaItemFfiResult; +static_assert_64bit(offsetof(SignalListMediaItemFfiResult, cdn) == 0); +static_assert_64bit(offsetof(SignalListMediaItemFfiResult, media_id) == 4); +static_assert_64bit(offsetof(SignalListMediaItemFfiResult, object_length) == 24); +static_assert_64bit(sizeof(SignalListMediaItemFfiResult) == 32); +static_assert_64bit(alignof(SignalListMediaItemFfiResult) == 8); +typedef SignalListMediaItemFfiResult* SignalType_MutPointer_SignalListMediaItemFfiResult; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalListMediaItemFfiResult) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalListMediaItemFfiResult) == 8); +typedef struct { + SignalListMediaItemFfiResult* base; + size_t length; + size_t size_bytes; +} SignalOwnedBufferOfMaxAlignedListMediaItemFfiResult; +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedListMediaItemFfiResult, base) == 0); +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedListMediaItemFfiResult, length) == 8); +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedListMediaItemFfiResult, size_bytes) == 16); +static_assert_64bit(sizeof(SignalOwnedBufferOfMaxAlignedListMediaItemFfiResult) == 24); +static_assert_64bit(alignof(SignalOwnedBufferOfMaxAlignedListMediaItemFfiResult) == 8); +typedef struct { + SignalOwnedBufferOfMaxAlignedListMediaItemFfiResult items; + const int8_t* backup_dir; + const int8_t* media_dir; + const int8_t* cursor; +} SignalListMediaResponseFfiResult; +static_assert_64bit(offsetof(SignalListMediaResponseFfiResult, items) == 0); +static_assert_64bit(offsetof(SignalListMediaResponseFfiResult, backup_dir) == 24); +static_assert_64bit(offsetof(SignalListMediaResponseFfiResult, media_dir) == 32); +static_assert_64bit(offsetof(SignalListMediaResponseFfiResult, cursor) == 40); +static_assert_64bit(sizeof(SignalListMediaResponseFfiResult) == 48); +static_assert_64bit(alignof(SignalListMediaResponseFfiResult) == 8); +typedef const SignalListMediaResponseFfiResult* SignalType_ConstPointer_SignalListMediaResponseFfiResult; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalListMediaResponseFfiResult) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalListMediaResponseFfiResult) == 8); +typedef struct SignalRegistrationAccountAttributes SignalRegistrationAccountAttributes; +typedef const SignalRegistrationAccountAttributes* SignalType_ConstPointer_SignalRegistrationAccountAttributes; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalRegistrationAccountAttributes) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalRegistrationAccountAttributes) == 8); +typedef struct SignalRegisterAccountRequest SignalRegisterAccountRequest; +typedef const SignalRegisterAccountRequest* SignalType_ConstPointer_SignalRegisterAccountRequest; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalRegisterAccountRequest) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalRegisterAccountRequest) == 8); +typedef const SignalRegistrationService* SignalType_ConstPointer_SignalRegistrationService; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalRegistrationService) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalRegistrationService) == 8); +typedef struct SignalTokioAsyncContext SignalTokioAsyncContext; +typedef const SignalTokioAsyncContext* SignalType_ConstPointer_SignalTokioAsyncContext; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalTokioAsyncContext) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalTokioAsyncContext) == 8); +typedef bool* SignalType_MutPointer_bool; +static_assert_64bit(sizeof(SignalType_MutPointer_bool) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_bool) == 8); +typedef SignalProtocolAddress* SignalType_MutPointer_SignalProtocolAddress; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalProtocolAddress) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalProtocolAddress) == 8); +typedef struct { + SignalProtocolAddress* raw; +} SignalMutPointerProtocolAddress; +static_assert_64bit(offsetof(SignalMutPointerProtocolAddress, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerProtocolAddress) == 8); +static_assert_64bit(alignof(SignalMutPointerProtocolAddress) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_bool_SignalMutPointerProtocolAddress_SignalMutPointerPublicKey_uint32_t)(SignalType_MutPointer_void, SignalType_MutPointer_bool, SignalMutPointerProtocolAddress, SignalMutPointerPublicKey, uint32_t); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_bool_SignalMutPointerProtocolAddress_SignalMutPointerPublicKey_uint32_t) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_bool_SignalMutPointerProtocolAddress_SignalMutPointerPublicKey_uint32_t) == 8); +typedef SignalMutPointerPublicKey* SignalType_MutPointer_SignalMutPointerPublicKey; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerPublicKey) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerPublicKey) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerPublicKey_SignalMutPointerProtocolAddress)(SignalType_MutPointer_void, SignalType_MutPointer_SignalMutPointerPublicKey, SignalMutPointerProtocolAddress); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerPublicKey_SignalMutPointerProtocolAddress) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerPublicKey_SignalMutPointerProtocolAddress) == 8); +typedef struct SignalPrivateKey SignalPrivateKey; +typedef SignalPrivateKey* SignalType_MutPointer_SignalPrivateKey; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalPrivateKey) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalPrivateKey) == 8); +typedef struct { + SignalPrivateKey* raw; +} SignalMutPointerPrivateKey; +static_assert_64bit(offsetof(SignalMutPointerPrivateKey, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerPrivateKey) == 8); +static_assert_64bit(alignof(SignalMutPointerPrivateKey) == 8); +typedef struct { + SignalMutPointerPrivateKey first; + SignalMutPointerPublicKey second; +} SignalPairOfMutPointerPrivateKeyMutPointerPublicKey; +static_assert_64bit(offsetof(SignalPairOfMutPointerPrivateKeyMutPointerPublicKey, first) == 0); +static_assert_64bit(offsetof(SignalPairOfMutPointerPrivateKeyMutPointerPublicKey, second) == 8); +static_assert_64bit(sizeof(SignalPairOfMutPointerPrivateKeyMutPointerPublicKey) == 16); +static_assert_64bit(alignof(SignalPairOfMutPointerPrivateKeyMutPointerPublicKey) == 8); +typedef SignalPairOfMutPointerPrivateKeyMutPointerPublicKey* SignalType_MutPointer_SignalPairOfMutPointerPrivateKeyMutPointerPublicKey; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalPairOfMutPointerPrivateKeyMutPointerPublicKey) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalPairOfMutPointerPrivateKeyMutPointerPublicKey) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalPairOfMutPointerPrivateKeyMutPointerPublicKey)(SignalType_MutPointer_void, SignalType_MutPointer_SignalPairOfMutPointerPrivateKeyMutPointerPublicKey); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalPairOfMutPointerPrivateKeyMutPointerPublicKey) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalPairOfMutPointerPrivateKeyMutPointerPublicKey) == 8); +typedef uint32_t* SignalType_MutPointer_uint32_t; +static_assert_64bit(sizeof(SignalType_MutPointer_uint32_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_uint32_t) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_uint32_t)(SignalType_MutPointer_void, SignalType_MutPointer_uint32_t); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_uint32_t) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_uint32_t) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_uint8_t_SignalMutPointerProtocolAddress_SignalMutPointerPublicKey)(SignalType_MutPointer_void, SignalType_MutPointer_uint8_t, SignalMutPointerProtocolAddress, SignalMutPointerPublicKey); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_uint8_t_SignalMutPointerProtocolAddress_SignalMutPointerPublicKey) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_uint8_t_SignalMutPointerProtocolAddress_SignalMutPointerPublicKey) == 8); +typedef struct { + void* ctx; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalPairOfMutPointerPrivateKeyMutPointerPublicKey get_local_identity_key_pair; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_uint32_t get_local_registration_id; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerPublicKey_SignalMutPointerProtocolAddress get_identity_key; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_uint8_t_SignalMutPointerProtocolAddress_SignalMutPointerPublicKey save_identity_key; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_bool_SignalMutPointerProtocolAddress_SignalMutPointerPublicKey_uint32_t is_trusted_identity; + SignalType_FunctionPointer_void_SignalType_MutPointer_void destroy; +} SignalFfiIdentityKeyStoreStruct; +static_assert_64bit(offsetof(SignalFfiIdentityKeyStoreStruct, ctx) == 0); +static_assert_64bit(offsetof(SignalFfiIdentityKeyStoreStruct, get_local_identity_key_pair) == 8); +static_assert_64bit(offsetof(SignalFfiIdentityKeyStoreStruct, get_local_registration_id) == 16); +static_assert_64bit(offsetof(SignalFfiIdentityKeyStoreStruct, get_identity_key) == 24); +static_assert_64bit(offsetof(SignalFfiIdentityKeyStoreStruct, save_identity_key) == 32); +static_assert_64bit(offsetof(SignalFfiIdentityKeyStoreStruct, is_trusted_identity) == 40); +static_assert_64bit(offsetof(SignalFfiIdentityKeyStoreStruct, destroy) == 48); +static_assert_64bit(sizeof(SignalFfiIdentityKeyStoreStruct) == 56); +static_assert_64bit(alignof(SignalFfiIdentityKeyStoreStruct) == 8); +typedef const SignalFfiIdentityKeyStoreStruct* SignalType_ConstPointer_SignalFfiIdentityKeyStoreStruct; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiIdentityKeyStoreStruct) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiIdentityKeyStoreStruct) == 8); +typedef struct SignalKyberPreKeyRecord SignalKyberPreKeyRecord; +typedef SignalKyberPreKeyRecord* SignalType_MutPointer_SignalKyberPreKeyRecord; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalKyberPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalKyberPreKeyRecord) == 8); +typedef struct { + SignalKyberPreKeyRecord* raw; +} SignalMutPointerKyberPreKeyRecord; +static_assert_64bit(offsetof(SignalMutPointerKyberPreKeyRecord, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerKyberPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalMutPointerKyberPreKeyRecord) == 8); +typedef SignalMutPointerKyberPreKeyRecord* SignalType_MutPointer_SignalMutPointerKyberPreKeyRecord; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerKyberPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerKyberPreKeyRecord) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerKyberPreKeyRecord_uint32_t)(SignalType_MutPointer_void, SignalType_MutPointer_SignalMutPointerKyberPreKeyRecord, uint32_t); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerKyberPreKeyRecord_uint32_t) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerKyberPreKeyRecord_uint32_t) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerKyberPreKeyRecord)(SignalType_MutPointer_void, uint32_t, SignalMutPointerKyberPreKeyRecord); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerKyberPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerKyberPreKeyRecord) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_uint32_t_SignalMutPointerPublicKey)(SignalType_MutPointer_void, uint32_t, uint32_t, SignalMutPointerPublicKey); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_uint32_t_SignalMutPointerPublicKey) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_uint32_t_SignalMutPointerPublicKey) == 8); +typedef struct { + void* ctx; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerKyberPreKeyRecord_uint32_t load_kyber_pre_key; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerKyberPreKeyRecord store_kyber_pre_key; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_uint32_t_SignalMutPointerPublicKey mark_kyber_pre_key_used; + SignalType_FunctionPointer_void_SignalType_MutPointer_void destroy; +} SignalFfiKyberPreKeyStoreStruct; +static_assert_64bit(offsetof(SignalFfiKyberPreKeyStoreStruct, ctx) == 0); +static_assert_64bit(offsetof(SignalFfiKyberPreKeyStoreStruct, load_kyber_pre_key) == 8); +static_assert_64bit(offsetof(SignalFfiKyberPreKeyStoreStruct, store_kyber_pre_key) == 16); +static_assert_64bit(offsetof(SignalFfiKyberPreKeyStoreStruct, mark_kyber_pre_key_used) == 24); +static_assert_64bit(offsetof(SignalFfiKyberPreKeyStoreStruct, destroy) == 32); +static_assert_64bit(sizeof(SignalFfiKyberPreKeyStoreStruct) == 40); +static_assert_64bit(alignof(SignalFfiKyberPreKeyStoreStruct) == 8); +typedef const SignalFfiKyberPreKeyStoreStruct* SignalType_ConstPointer_SignalFfiKyberPreKeyStoreStruct; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiKyberPreKeyStoreStruct) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiKyberPreKeyStoreStruct) == 8); +typedef struct SignalPreKeyRecord SignalPreKeyRecord; +typedef SignalPreKeyRecord* SignalType_MutPointer_SignalPreKeyRecord; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalPreKeyRecord) == 8); +typedef struct { + SignalPreKeyRecord* raw; +} SignalMutPointerPreKeyRecord; +static_assert_64bit(offsetof(SignalMutPointerPreKeyRecord, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalMutPointerPreKeyRecord) == 8); +typedef SignalMutPointerPreKeyRecord* SignalType_MutPointer_SignalMutPointerPreKeyRecord; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerPreKeyRecord) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerPreKeyRecord_uint32_t)(SignalType_MutPointer_void, SignalType_MutPointer_SignalMutPointerPreKeyRecord, uint32_t); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerPreKeyRecord_uint32_t) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerPreKeyRecord_uint32_t) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t)(SignalType_MutPointer_void, uint32_t); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerPreKeyRecord)(SignalType_MutPointer_void, uint32_t, SignalMutPointerPreKeyRecord); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerPreKeyRecord) == 8); +typedef struct { + void* ctx; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerPreKeyRecord_uint32_t load_pre_key; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerPreKeyRecord store_pre_key; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t remove_pre_key; + SignalType_FunctionPointer_void_SignalType_MutPointer_void destroy; +} SignalFfiPreKeyStoreStruct; +static_assert_64bit(offsetof(SignalFfiPreKeyStoreStruct, ctx) == 0); +static_assert_64bit(offsetof(SignalFfiPreKeyStoreStruct, load_pre_key) == 8); +static_assert_64bit(offsetof(SignalFfiPreKeyStoreStruct, store_pre_key) == 16); +static_assert_64bit(offsetof(SignalFfiPreKeyStoreStruct, remove_pre_key) == 24); +static_assert_64bit(offsetof(SignalFfiPreKeyStoreStruct, destroy) == 32); +static_assert_64bit(sizeof(SignalFfiPreKeyStoreStruct) == 40); +static_assert_64bit(alignof(SignalFfiPreKeyStoreStruct) == 8); +typedef const SignalFfiPreKeyStoreStruct* SignalType_ConstPointer_SignalFfiPreKeyStoreStruct; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiPreKeyStoreStruct) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiPreKeyStoreStruct) == 8); +typedef struct SignalSenderKeyRecord SignalSenderKeyRecord; +typedef SignalSenderKeyRecord* SignalType_MutPointer_SignalSenderKeyRecord; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalSenderKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalSenderKeyRecord) == 8); +typedef struct { + SignalSenderKeyRecord* raw; +} SignalMutPointerSenderKeyRecord; +static_assert_64bit(offsetof(SignalMutPointerSenderKeyRecord, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerSenderKeyRecord) == 8); +static_assert_64bit(alignof(SignalMutPointerSenderKeyRecord) == 8); +typedef SignalMutPointerSenderKeyRecord* SignalType_MutPointer_SignalMutPointerSenderKeyRecord; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerSenderKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerSenderKeyRecord) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSenderKeyRecord_SignalMutPointerProtocolAddress_SignalUuid)(SignalType_MutPointer_void, SignalType_MutPointer_SignalMutPointerSenderKeyRecord, SignalMutPointerProtocolAddress, SignalUuid); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSenderKeyRecord_SignalMutPointerProtocolAddress_SignalUuid) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSenderKeyRecord_SignalMutPointerProtocolAddress_SignalUuid) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalMutPointerProtocolAddress_SignalUuid_SignalMutPointerSenderKeyRecord)(SignalType_MutPointer_void, SignalMutPointerProtocolAddress, SignalUuid, SignalMutPointerSenderKeyRecord); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalMutPointerProtocolAddress_SignalUuid_SignalMutPointerSenderKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalMutPointerProtocolAddress_SignalUuid_SignalMutPointerSenderKeyRecord) == 8); +typedef struct { + void* ctx; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSenderKeyRecord_SignalMutPointerProtocolAddress_SignalUuid load_sender_key; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalMutPointerProtocolAddress_SignalUuid_SignalMutPointerSenderKeyRecord store_sender_key; + SignalType_FunctionPointer_void_SignalType_MutPointer_void destroy; +} SignalFfiSenderKeyStoreStruct; +static_assert_64bit(offsetof(SignalFfiSenderKeyStoreStruct, ctx) == 0); +static_assert_64bit(offsetof(SignalFfiSenderKeyStoreStruct, load_sender_key) == 8); +static_assert_64bit(offsetof(SignalFfiSenderKeyStoreStruct, store_sender_key) == 16); +static_assert_64bit(offsetof(SignalFfiSenderKeyStoreStruct, destroy) == 24); +static_assert_64bit(sizeof(SignalFfiSenderKeyStoreStruct) == 32); +static_assert_64bit(alignof(SignalFfiSenderKeyStoreStruct) == 8); +typedef const SignalFfiSenderKeyStoreStruct* SignalType_ConstPointer_SignalFfiSenderKeyStoreStruct; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiSenderKeyStoreStruct) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiSenderKeyStoreStruct) == 8); +typedef SignalSessionRecord* SignalType_MutPointer_SignalSessionRecord; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalSessionRecord) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalSessionRecord) == 8); +typedef struct { + SignalSessionRecord* raw; +} SignalMutPointerSessionRecord; +static_assert_64bit(offsetof(SignalMutPointerSessionRecord, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerSessionRecord) == 8); +static_assert_64bit(alignof(SignalMutPointerSessionRecord) == 8); +typedef SignalMutPointerSessionRecord* SignalType_MutPointer_SignalMutPointerSessionRecord; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerSessionRecord) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerSessionRecord) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSessionRecord_SignalMutPointerProtocolAddress)(SignalType_MutPointer_void, SignalType_MutPointer_SignalMutPointerSessionRecord, SignalMutPointerProtocolAddress); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSessionRecord_SignalMutPointerProtocolAddress) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSessionRecord_SignalMutPointerProtocolAddress) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalMutPointerProtocolAddress_SignalMutPointerSessionRecord)(SignalType_MutPointer_void, SignalMutPointerProtocolAddress, SignalMutPointerSessionRecord); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalMutPointerProtocolAddress_SignalMutPointerSessionRecord) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalMutPointerProtocolAddress_SignalMutPointerSessionRecord) == 8); +typedef struct { + void* ctx; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSessionRecord_SignalMutPointerProtocolAddress load_session; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalMutPointerProtocolAddress_SignalMutPointerSessionRecord store_session; + SignalType_FunctionPointer_void_SignalType_MutPointer_void destroy; +} SignalFfiSessionStoreStruct; +static_assert_64bit(offsetof(SignalFfiSessionStoreStruct, ctx) == 0); +static_assert_64bit(offsetof(SignalFfiSessionStoreStruct, load_session) == 8); +static_assert_64bit(offsetof(SignalFfiSessionStoreStruct, store_session) == 16); +static_assert_64bit(offsetof(SignalFfiSessionStoreStruct, destroy) == 24); +static_assert_64bit(sizeof(SignalFfiSessionStoreStruct) == 32); +static_assert_64bit(alignof(SignalFfiSessionStoreStruct) == 8); +typedef const SignalFfiSessionStoreStruct* SignalType_ConstPointer_SignalFfiSessionStoreStruct; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiSessionStoreStruct) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiSessionStoreStruct) == 8); +typedef struct SignalSignedPreKeyRecord SignalSignedPreKeyRecord; +typedef SignalSignedPreKeyRecord* SignalType_MutPointer_SignalSignedPreKeyRecord; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalSignedPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalSignedPreKeyRecord) == 8); +typedef struct { + SignalSignedPreKeyRecord* raw; +} SignalMutPointerSignedPreKeyRecord; +static_assert_64bit(offsetof(SignalMutPointerSignedPreKeyRecord, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerSignedPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalMutPointerSignedPreKeyRecord) == 8); +typedef SignalMutPointerSignedPreKeyRecord* SignalType_MutPointer_SignalMutPointerSignedPreKeyRecord; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerSignedPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerSignedPreKeyRecord) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSignedPreKeyRecord_uint32_t)(SignalType_MutPointer_void, SignalType_MutPointer_SignalMutPointerSignedPreKeyRecord, uint32_t); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSignedPreKeyRecord_uint32_t) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSignedPreKeyRecord_uint32_t) == 8); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerSignedPreKeyRecord)(SignalType_MutPointer_void, uint32_t, SignalMutPointerSignedPreKeyRecord); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerSignedPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerSignedPreKeyRecord) == 8); +typedef struct { + void* ctx; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSignedPreKeyRecord_uint32_t load_signed_pre_key; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerSignedPreKeyRecord store_signed_pre_key; + SignalType_FunctionPointer_void_SignalType_MutPointer_void destroy; +} SignalFfiSignedPreKeyStoreStruct; +static_assert_64bit(offsetof(SignalFfiSignedPreKeyStoreStruct, ctx) == 0); +static_assert_64bit(offsetof(SignalFfiSignedPreKeyStoreStruct, load_signed_pre_key) == 8); +static_assert_64bit(offsetof(SignalFfiSignedPreKeyStoreStruct, store_signed_pre_key) == 16); +static_assert_64bit(offsetof(SignalFfiSignedPreKeyStoreStruct, destroy) == 24); +static_assert_64bit(sizeof(SignalFfiSignedPreKeyStoreStruct) == 32); +static_assert_64bit(alignof(SignalFfiSignedPreKeyStoreStruct) == 8); +typedef const SignalFfiSignedPreKeyStoreStruct* SignalType_ConstPointer_SignalFfiSignedPreKeyStoreStruct; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFfiSignedPreKeyStoreStruct) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFfiSignedPreKeyStoreStruct) == 8); +typedef struct SignalSgxClientState SignalSgxClientState; +typedef const SignalSgxClientState* SignalType_ConstPointer_SignalSgxClientState; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalSgxClientState) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalSgxClientState) == 8); +typedef struct SignalBridgedStringMap SignalBridgedStringMap; +typedef const SignalBridgedStringMap* SignalType_ConstPointer_SignalBridgedStringMap; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalBridgedStringMap) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalBridgedStringMap) == 8); +typedef const SignalPrivateKey* SignalType_ConstPointer_SignalPrivateKey; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalPrivateKey) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalPrivateKey) == 8); +typedef struct SignalChatConnectionInfo SignalChatConnectionInfo; +typedef const SignalChatConnectionInfo* SignalType_ConstPointer_SignalChatConnectionInfo; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalChatConnectionInfo) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalChatConnectionInfo) == 8); +typedef const SignalBackupRestoreResponse* SignalType_ConstPointer_SignalBackupRestoreResponse; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalBackupRestoreResponse) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalBackupRestoreResponse) == 8); +typedef const SignalBackupStoreResponse* SignalType_ConstPointer_SignalBackupStoreResponse; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalBackupStoreResponse) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalBackupStoreResponse) == 8); +typedef const SignalRegisterAccountResponse* SignalType_ConstPointer_SignalRegisterAccountResponse; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalRegisterAccountResponse) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalRegisterAccountResponse) == 8); +typedef struct SignalRegistrationSession SignalRegistrationSession; +typedef const SignalRegistrationSession* SignalType_ConstPointer_SignalRegistrationSession; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalRegistrationSession) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalRegistrationSession) == 8); +typedef struct SignalConnectionProxyConfig SignalConnectionProxyConfig; +typedef const SignalConnectionProxyConfig* SignalType_ConstPointer_SignalConnectionProxyConfig; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalConnectionProxyConfig) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalConnectionProxyConfig) == 8); +typedef struct SignalFingerprint SignalFingerprint; +typedef const SignalFingerprint* SignalType_ConstPointer_SignalFingerprint; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalFingerprint) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalFingerprint) == 8); +typedef struct SignalKyberPublicKey SignalKyberPublicKey; +typedef const SignalKyberPublicKey* SignalType_ConstPointer_SignalKyberPublicKey; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalKyberPublicKey) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalKyberPublicKey) == 8); +typedef struct SignalKyberSecretKey SignalKyberSecretKey; +typedef const SignalKyberSecretKey* SignalType_ConstPointer_SignalKyberSecretKey; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalKyberSecretKey) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalKyberSecretKey) == 8); +typedef struct SignalKyberKeyPair SignalKyberKeyPair; +typedef const SignalKyberKeyPair* SignalType_ConstPointer_SignalKyberKeyPair; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalKyberKeyPair) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalKyberKeyPair) == 8); +typedef struct SignalDecryptionErrorMessage SignalDecryptionErrorMessage; +typedef const SignalDecryptionErrorMessage* SignalType_ConstPointer_SignalDecryptionErrorMessage; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalDecryptionErrorMessage) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalDecryptionErrorMessage) == 8); +typedef struct SignalPlaintextContent SignalPlaintextContent; +typedef const SignalPlaintextContent* SignalType_ConstPointer_SignalPlaintextContent; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalPlaintextContent) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalPlaintextContent) == 8); +typedef struct SignalPreKeySignalMessage SignalPreKeySignalMessage; +typedef const SignalPreKeySignalMessage* SignalType_ConstPointer_SignalPreKeySignalMessage; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalPreKeySignalMessage) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalPreKeySignalMessage) == 8); +typedef struct SignalSenderKeyDistributionMessage SignalSenderKeyDistributionMessage; +typedef const SignalSenderKeyDistributionMessage* SignalType_ConstPointer_SignalSenderKeyDistributionMessage; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalSenderKeyDistributionMessage) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalSenderKeyDistributionMessage) == 8); +typedef struct SignalSenderKeyMessage SignalSenderKeyMessage; +typedef const SignalSenderKeyMessage* SignalType_ConstPointer_SignalSenderKeyMessage; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalSenderKeyMessage) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalSenderKeyMessage) == 8); +typedef struct SignalSignalMessage SignalSignalMessage; +typedef const SignalSignalMessage* SignalType_ConstPointer_SignalSignalMessage; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalSignalMessage) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalSignalMessage) == 8); +typedef struct SignalSenderCertificate SignalSenderCertificate; +typedef const SignalSenderCertificate* SignalType_ConstPointer_SignalSenderCertificate; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalSenderCertificate) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalSenderCertificate) == 8); +typedef struct SignalServerCertificate SignalServerCertificate; +typedef const SignalServerCertificate* SignalType_ConstPointer_SignalServerCertificate; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalServerCertificate) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalServerCertificate) == 8); +typedef struct SignalUnidentifiedSenderMessageContent SignalUnidentifiedSenderMessageContent; +typedef const SignalUnidentifiedSenderMessageContent* SignalType_ConstPointer_SignalUnidentifiedSenderMessageContent; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalUnidentifiedSenderMessageContent) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalUnidentifiedSenderMessageContent) == 8); +typedef const SignalSenderKeyRecord* SignalType_ConstPointer_SignalSenderKeyRecord; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalSenderKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalSenderKeyRecord) == 8); +typedef const SignalPreKeyBundle* SignalType_ConstPointer_SignalPreKeyBundle; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalPreKeyBundle) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalPreKeyBundle) == 8); +typedef const SignalKyberPreKeyRecord* SignalType_ConstPointer_SignalKyberPreKeyRecord; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalKyberPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalKyberPreKeyRecord) == 8); +typedef const SignalPreKeyRecord* SignalType_ConstPointer_SignalPreKeyRecord; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalPreKeyRecord) == 8); +typedef const SignalSignedPreKeyRecord* SignalType_ConstPointer_SignalSignedPreKeyRecord; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalSignedPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalSignedPreKeyRecord) == 8); +typedef const uint32_t* SignalType_ConstPointer_uint32_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_uint32_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_uint32_t) == 8); +typedef const size_t* SignalType_ConstPointer_size_t; +static_assert_64bit(sizeof(SignalType_ConstPointer_size_t) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_size_t) == 8); +typedef struct SignalServerPublicParams SignalServerPublicParams; +typedef const SignalServerPublicParams* SignalType_ConstPointer_SignalServerPublicParams; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalServerPublicParams) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalServerPublicParams) == 8); +typedef struct SignalServerSecretParams SignalServerSecretParams; +typedef const SignalServerSecretParams* SignalType_ConstPointer_SignalServerSecretParams; +static_assert_64bit(sizeof(SignalType_ConstPointer_SignalServerSecretParams) == 8); +static_assert_64bit(alignof(SignalType_ConstPointer_SignalServerSecretParams) == 8); +typedef SignalType_FixedArray129_uint8_t* SignalType_MutPointer_SignalType_FixedArray129_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray129_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray129_uint8_t) == 8); +typedef SignalType_FixedArray153_uint8_t* SignalType_MutPointer_SignalType_FixedArray153_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray153_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray153_uint8_t) == 8); +typedef SignalType_FixedArray15_uint8_t* SignalType_MutPointer_SignalType_FixedArray15_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray15_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray15_uint8_t) == 8); +typedef SignalType_FixedArray16_uint8_t* SignalType_MutPointer_SignalType_FixedArray16_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray16_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray16_uint8_t) == 8); +typedef SignalType_FixedArray177_uint8_t* SignalType_MutPointer_SignalType_FixedArray177_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray177_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray177_uint8_t) == 8); +typedef SignalType_FixedArray289_uint8_t* SignalType_MutPointer_SignalType_FixedArray289_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray289_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray289_uint8_t) == 8); +typedef SignalType_FixedArray329_uint8_t* SignalType_MutPointer_SignalType_FixedArray329_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray329_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray329_uint8_t) == 8); +typedef SignalType_FixedArray32_uint8_t* SignalType_MutPointer_SignalType_FixedArray32_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray32_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray32_uint8_t) == 8); +typedef SignalType_FixedArray409_uint8_t* SignalType_MutPointer_SignalType_FixedArray409_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray409_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray409_uint8_t) == 8); +typedef SignalType_FixedArray473_uint8_t* SignalType_MutPointer_SignalType_FixedArray473_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray473_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray473_uint8_t) == 8); +typedef SignalType_FixedArray497_uint8_t* SignalType_MutPointer_SignalType_FixedArray497_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray497_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray497_uint8_t) == 8); +typedef SignalType_FixedArray64_uint8_t* SignalType_MutPointer_SignalType_FixedArray64_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray64_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray64_uint8_t) == 8); +typedef SignalType_FixedArray65_uint8_t* SignalType_MutPointer_SignalType_FixedArray65_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray65_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray65_uint8_t) == 8); +typedef SignalType_FixedArray97_uint8_t* SignalType_MutPointer_SignalType_FixedArray97_uint8_t; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalType_FixedArray97_uint8_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalType_FixedArray97_uint8_t) == 8); +typedef int32_t* SignalType_MutPointer_int32_t; +static_assert_64bit(sizeof(SignalType_MutPointer_int32_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_int32_t) == 8); +typedef SignalPinHash* SignalType_MutPointer_SignalPinHash; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalPinHash) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalPinHash) == 8); +typedef struct SignalAes256GcmDecryption SignalAes256GcmDecryption; +typedef SignalAes256GcmDecryption* SignalType_MutPointer_SignalAes256GcmDecryption; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalAes256GcmDecryption) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalAes256GcmDecryption) == 8); +typedef struct SignalAes256GcmEncryption SignalAes256GcmEncryption; +typedef SignalAes256GcmEncryption* SignalType_MutPointer_SignalAes256GcmEncryption; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalAes256GcmEncryption) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalAes256GcmEncryption) == 8); +typedef SignalAes256GcmSiv* SignalType_MutPointer_SignalAes256GcmSiv; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalAes256GcmSiv) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalAes256GcmSiv) == 8); +typedef SignalBytestringArray* SignalType_MutPointer_SignalBytestringArray; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalBytestringArray) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalBytestringArray) == 8); +typedef struct { + uint32_t* base; + size_t length; +} SignalOwnedBufferOfu32; +static_assert_64bit(offsetof(SignalOwnedBufferOfu32, base) == 0); +static_assert_64bit(offsetof(SignalOwnedBufferOfu32, length) == 8); +static_assert_64bit(sizeof(SignalOwnedBufferOfu32) == 16); +static_assert_64bit(alignof(SignalOwnedBufferOfu32) == 8); +typedef struct { + SignalType_FixedArray17_uint8_t account; + SignalOwnedBufferOfu32 missing_devices; + SignalOwnedBufferOfu32 extra_devices; + SignalOwnedBufferOfu32 stale_devices; +} SignalFfiMismatchedDevicesError; +static_assert_64bit(offsetof(SignalFfiMismatchedDevicesError, account) == 0); +static_assert_64bit(offsetof(SignalFfiMismatchedDevicesError, missing_devices) == 24); +static_assert_64bit(offsetof(SignalFfiMismatchedDevicesError, extra_devices) == 40); +static_assert_64bit(offsetof(SignalFfiMismatchedDevicesError, stale_devices) == 56); +static_assert_64bit(sizeof(SignalFfiMismatchedDevicesError) == 72); +static_assert_64bit(alignof(SignalFfiMismatchedDevicesError) == 8); +typedef SignalFfiMismatchedDevicesError* SignalType_MutPointer_SignalFfiMismatchedDevicesError; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalFfiMismatchedDevicesError) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalFfiMismatchedDevicesError) == 8); +static_assert_64bit(sizeof(double) == 8); +static_assert_64bit(alignof(double) == 8); +typedef struct { + const int8_t* id; + bool visible; + double expiration_secs; +} SignalFfiRegisterResponseBadge; +static_assert_64bit(offsetof(SignalFfiRegisterResponseBadge, id) == 0); +static_assert_64bit(offsetof(SignalFfiRegisterResponseBadge, visible) == 8); +static_assert_64bit(offsetof(SignalFfiRegisterResponseBadge, expiration_secs) == 16); +static_assert_64bit(sizeof(SignalFfiRegisterResponseBadge) == 24); +static_assert_64bit(alignof(SignalFfiRegisterResponseBadge) == 8); +typedef SignalFfiRegisterResponseBadge* SignalType_MutPointer_SignalFfiRegisterResponseBadge; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalFfiRegisterResponseBadge) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalFfiRegisterResponseBadge) == 8); +typedef struct { + SignalPinHash* raw; +} SignalMutPointerPinHash; +static_assert_64bit(offsetof(SignalMutPointerPinHash, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerPinHash) == 8); +static_assert_64bit(alignof(SignalMutPointerPinHash) == 8); +typedef SignalMutPointerPinHash* SignalType_MutPointer_SignalMutPointerPinHash; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerPinHash) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerPinHash) == 8); +typedef struct { + SignalAes256GcmDecryption* raw; +} SignalMutPointerAes256GcmDecryption; +static_assert_64bit(offsetof(SignalMutPointerAes256GcmDecryption, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerAes256GcmDecryption) == 8); +static_assert_64bit(alignof(SignalMutPointerAes256GcmDecryption) == 8); +typedef SignalMutPointerAes256GcmDecryption* SignalType_MutPointer_SignalMutPointerAes256GcmDecryption; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerAes256GcmDecryption) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerAes256GcmDecryption) == 8); +typedef struct { + SignalAes256GcmEncryption* raw; +} SignalMutPointerAes256GcmEncryption; +static_assert_64bit(offsetof(SignalMutPointerAes256GcmEncryption, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerAes256GcmEncryption) == 8); +static_assert_64bit(alignof(SignalMutPointerAes256GcmEncryption) == 8); +typedef SignalMutPointerAes256GcmEncryption* SignalType_MutPointer_SignalMutPointerAes256GcmEncryption; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerAes256GcmEncryption) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerAes256GcmEncryption) == 8); +typedef struct { + SignalAes256GcmSiv* raw; +} SignalMutPointerAes256GcmSiv; +static_assert_64bit(offsetof(SignalMutPointerAes256GcmSiv, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerAes256GcmSiv) == 8); +static_assert_64bit(alignof(SignalMutPointerAes256GcmSiv) == 8); +typedef SignalMutPointerAes256GcmSiv* SignalType_MutPointer_SignalMutPointerAes256GcmSiv; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerAes256GcmSiv) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerAes256GcmSiv) == 8); +typedef SignalHsmEnclaveClient* SignalType_MutPointer_SignalHsmEnclaveClient; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalHsmEnclaveClient) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalHsmEnclaveClient) == 8); +typedef struct { + SignalHsmEnclaveClient* raw; +} SignalMutPointerHsmEnclaveClient; +static_assert_64bit(offsetof(SignalMutPointerHsmEnclaveClient, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerHsmEnclaveClient) == 8); +static_assert_64bit(alignof(SignalMutPointerHsmEnclaveClient) == 8); +typedef SignalMutPointerHsmEnclaveClient* SignalType_MutPointer_SignalMutPointerHsmEnclaveClient; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerHsmEnclaveClient) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerHsmEnclaveClient) == 8); +typedef struct SignalIncrementalMac SignalIncrementalMac; +typedef SignalIncrementalMac* SignalType_MutPointer_SignalIncrementalMac; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalIncrementalMac) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalIncrementalMac) == 8); +typedef struct { + SignalIncrementalMac* raw; +} SignalMutPointerIncrementalMac; +static_assert_64bit(offsetof(SignalMutPointerIncrementalMac, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerIncrementalMac) == 8); +static_assert_64bit(alignof(SignalMutPointerIncrementalMac) == 8); +typedef SignalMutPointerIncrementalMac* SignalType_MutPointer_SignalMutPointerIncrementalMac; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerIncrementalMac) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerIncrementalMac) == 8); +typedef struct SignalValidatingMac SignalValidatingMac; +typedef SignalValidatingMac* SignalType_MutPointer_SignalValidatingMac; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalValidatingMac) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalValidatingMac) == 8); +typedef struct { + SignalValidatingMac* raw; +} SignalMutPointerValidatingMac; +static_assert_64bit(offsetof(SignalMutPointerValidatingMac, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerValidatingMac) == 8); +static_assert_64bit(alignof(SignalMutPointerValidatingMac) == 8); +typedef SignalMutPointerValidatingMac* SignalType_MutPointer_SignalMutPointerValidatingMac; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerValidatingMac) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerValidatingMac) == 8); +typedef SignalMessageBackupKey* SignalType_MutPointer_SignalMessageBackupKey; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMessageBackupKey) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMessageBackupKey) == 8); +typedef struct { + SignalMessageBackupKey* raw; +} SignalMutPointerMessageBackupKey; +static_assert_64bit(offsetof(SignalMutPointerMessageBackupKey, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerMessageBackupKey) == 8); +static_assert_64bit(alignof(SignalMutPointerMessageBackupKey) == 8); +typedef SignalMutPointerMessageBackupKey* SignalType_MutPointer_SignalMutPointerMessageBackupKey; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerMessageBackupKey) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerMessageBackupKey) == 8); +typedef SignalMessageBackupValidationOutcome* SignalType_MutPointer_SignalMessageBackupValidationOutcome; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMessageBackupValidationOutcome) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMessageBackupValidationOutcome) == 8); +typedef struct { + SignalMessageBackupValidationOutcome* raw; +} SignalMutPointerMessageBackupValidationOutcome; +static_assert_64bit(offsetof(SignalMutPointerMessageBackupValidationOutcome, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerMessageBackupValidationOutcome) == 8); +static_assert_64bit(alignof(SignalMutPointerMessageBackupValidationOutcome) == 8); +typedef SignalMutPointerMessageBackupValidationOutcome* SignalType_MutPointer_SignalMutPointerMessageBackupValidationOutcome; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerMessageBackupValidationOutcome) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerMessageBackupValidationOutcome) == 8); +typedef struct SignalOnlineBackupValidator SignalOnlineBackupValidator; +typedef SignalOnlineBackupValidator* SignalType_MutPointer_SignalOnlineBackupValidator; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalOnlineBackupValidator) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalOnlineBackupValidator) == 8); +typedef struct { + SignalOnlineBackupValidator* raw; +} SignalMutPointerOnlineBackupValidator; +static_assert_64bit(offsetof(SignalMutPointerOnlineBackupValidator, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerOnlineBackupValidator) == 8); +static_assert_64bit(alignof(SignalMutPointerOnlineBackupValidator) == 8); +typedef SignalMutPointerOnlineBackupValidator* SignalType_MutPointer_SignalMutPointerOnlineBackupValidator; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerOnlineBackupValidator) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerOnlineBackupValidator) == 8); +typedef SignalConnectionManager* SignalType_MutPointer_SignalConnectionManager; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalConnectionManager) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalConnectionManager) == 8); +typedef struct { + SignalConnectionManager* raw; +} SignalMutPointerConnectionManager; +static_assert_64bit(offsetof(SignalMutPointerConnectionManager, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerConnectionManager) == 8); +static_assert_64bit(alignof(SignalMutPointerConnectionManager) == 8); +typedef SignalMutPointerConnectionManager* SignalType_MutPointer_SignalMutPointerConnectionManager; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerConnectionManager) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerConnectionManager) == 8); +typedef SignalLookupRequest* SignalType_MutPointer_SignalLookupRequest; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalLookupRequest) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalLookupRequest) == 8); +typedef struct { + SignalLookupRequest* raw; +} SignalMutPointerLookupRequest; +static_assert_64bit(offsetof(SignalMutPointerLookupRequest, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerLookupRequest) == 8); +static_assert_64bit(alignof(SignalMutPointerLookupRequest) == 8); +typedef SignalMutPointerLookupRequest* SignalType_MutPointer_SignalMutPointerLookupRequest; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerLookupRequest) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerLookupRequest) == 8); +typedef SignalCopyBackupMediaStream* SignalType_MutPointer_SignalCopyBackupMediaStream; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCopyBackupMediaStream) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCopyBackupMediaStream) == 8); +typedef struct { + SignalCopyBackupMediaStream* raw; +} SignalMutPointerCopyBackupMediaStream; +static_assert_64bit(offsetof(SignalMutPointerCopyBackupMediaStream, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerCopyBackupMediaStream) == 8); +static_assert_64bit(alignof(SignalMutPointerCopyBackupMediaStream) == 8); +typedef SignalMutPointerCopyBackupMediaStream* SignalType_MutPointer_SignalMutPointerCopyBackupMediaStream; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerCopyBackupMediaStream) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerCopyBackupMediaStream) == 8); +typedef SignalDeleteBackupMediaStream* SignalType_MutPointer_SignalDeleteBackupMediaStream; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalDeleteBackupMediaStream) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalDeleteBackupMediaStream) == 8); +typedef struct { + SignalDeleteBackupMediaStream* raw; +} SignalMutPointerDeleteBackupMediaStream; +static_assert_64bit(offsetof(SignalMutPointerDeleteBackupMediaStream, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerDeleteBackupMediaStream) == 8); +static_assert_64bit(alignof(SignalMutPointerDeleteBackupMediaStream) == 8); +typedef SignalMutPointerDeleteBackupMediaStream* SignalType_MutPointer_SignalMutPointerDeleteBackupMediaStream; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerDeleteBackupMediaStream) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerDeleteBackupMediaStream) == 8); +typedef SignalHttpRequest* SignalType_MutPointer_SignalHttpRequest; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalHttpRequest) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalHttpRequest) == 8); +typedef struct { + SignalHttpRequest* raw; +} SignalMutPointerHttpRequest; +static_assert_64bit(offsetof(SignalMutPointerHttpRequest, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerHttpRequest) == 8); +static_assert_64bit(alignof(SignalMutPointerHttpRequest) == 8); +typedef SignalMutPointerHttpRequest* SignalType_MutPointer_SignalMutPointerHttpRequest; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerHttpRequest) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerHttpRequest) == 8); +typedef SignalRegistrationAccountAttributes* SignalType_MutPointer_SignalRegistrationAccountAttributes; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalRegistrationAccountAttributes) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalRegistrationAccountAttributes) == 8); +typedef struct { + SignalRegistrationAccountAttributes* raw; +} SignalMutPointerRegistrationAccountAttributes; +static_assert_64bit(offsetof(SignalMutPointerRegistrationAccountAttributes, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerRegistrationAccountAttributes) == 8); +static_assert_64bit(alignof(SignalMutPointerRegistrationAccountAttributes) == 8); +typedef SignalMutPointerRegistrationAccountAttributes* SignalType_MutPointer_SignalMutPointerRegistrationAccountAttributes; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerRegistrationAccountAttributes) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerRegistrationAccountAttributes) == 8); +typedef SignalRegisterAccountRequest* SignalType_MutPointer_SignalRegisterAccountRequest; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalRegisterAccountRequest) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalRegisterAccountRequest) == 8); +typedef struct { + SignalRegisterAccountRequest* raw; +} SignalMutPointerRegisterAccountRequest; +static_assert_64bit(offsetof(SignalMutPointerRegisterAccountRequest, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerRegisterAccountRequest) == 8); +static_assert_64bit(alignof(SignalMutPointerRegisterAccountRequest) == 8); +typedef SignalMutPointerRegisterAccountRequest* SignalType_MutPointer_SignalMutPointerRegisterAccountRequest; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerRegisterAccountRequest) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerRegisterAccountRequest) == 8); +typedef SignalTokioAsyncContext* SignalType_MutPointer_SignalTokioAsyncContext; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalTokioAsyncContext) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalTokioAsyncContext) == 8); +typedef struct { + SignalTokioAsyncContext* raw; +} SignalMutPointerTokioAsyncContext; +static_assert_64bit(offsetof(SignalMutPointerTokioAsyncContext, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerTokioAsyncContext) == 8); +static_assert_64bit(alignof(SignalMutPointerTokioAsyncContext) == 8); +typedef SignalMutPointerTokioAsyncContext* SignalType_MutPointer_SignalMutPointerTokioAsyncContext; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerTokioAsyncContext) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerTokioAsyncContext) == 8); +typedef SignalSgxClientState* SignalType_MutPointer_SignalSgxClientState; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalSgxClientState) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalSgxClientState) == 8); +typedef struct { + SignalSgxClientState* raw; +} SignalMutPointerSgxClientState; +static_assert_64bit(offsetof(SignalMutPointerSgxClientState, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerSgxClientState) == 8); +static_assert_64bit(alignof(SignalMutPointerSgxClientState) == 8); +typedef SignalMutPointerSgxClientState* SignalType_MutPointer_SignalMutPointerSgxClientState; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerSgxClientState) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerSgxClientState) == 8); +typedef SignalBridgedStringMap* SignalType_MutPointer_SignalBridgedStringMap; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalBridgedStringMap) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalBridgedStringMap) == 8); +typedef struct { + SignalBridgedStringMap* raw; +} SignalMutPointerBridgedStringMap; +static_assert_64bit(offsetof(SignalMutPointerBridgedStringMap, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerBridgedStringMap) == 8); +static_assert_64bit(alignof(SignalMutPointerBridgedStringMap) == 8); +typedef SignalMutPointerBridgedStringMap* SignalType_MutPointer_SignalMutPointerBridgedStringMap; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerBridgedStringMap) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerBridgedStringMap) == 8); +typedef SignalMutPointerProtocolAddress* SignalType_MutPointer_SignalMutPointerProtocolAddress; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerProtocolAddress) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerProtocolAddress) == 8); +typedef SignalMutPointerPrivateKey* SignalType_MutPointer_SignalMutPointerPrivateKey; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerPrivateKey) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerPrivateKey) == 8); +typedef SignalChatConnectionInfo* SignalType_MutPointer_SignalChatConnectionInfo; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalChatConnectionInfo) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalChatConnectionInfo) == 8); +typedef struct { + SignalChatConnectionInfo* raw; +} SignalMutPointerChatConnectionInfo; +static_assert_64bit(offsetof(SignalMutPointerChatConnectionInfo, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerChatConnectionInfo) == 8); +static_assert_64bit(alignof(SignalMutPointerChatConnectionInfo) == 8); +typedef SignalMutPointerChatConnectionInfo* SignalType_MutPointer_SignalMutPointerChatConnectionInfo; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerChatConnectionInfo) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerChatConnectionInfo) == 8); +typedef SignalRegistrationSession* SignalType_MutPointer_SignalRegistrationSession; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalRegistrationSession) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalRegistrationSession) == 8); +typedef struct { + SignalRegistrationSession* raw; +} SignalMutPointerRegistrationSession; +static_assert_64bit(offsetof(SignalMutPointerRegistrationSession, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerRegistrationSession) == 8); +static_assert_64bit(alignof(SignalMutPointerRegistrationSession) == 8); +typedef SignalMutPointerRegistrationSession* SignalType_MutPointer_SignalMutPointerRegistrationSession; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerRegistrationSession) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerRegistrationSession) == 8); +typedef SignalConnectionProxyConfig* SignalType_MutPointer_SignalConnectionProxyConfig; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalConnectionProxyConfig) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalConnectionProxyConfig) == 8); +typedef struct { + SignalConnectionProxyConfig* raw; +} SignalMutPointerConnectionProxyConfig; +static_assert_64bit(offsetof(SignalMutPointerConnectionProxyConfig, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerConnectionProxyConfig) == 8); +static_assert_64bit(alignof(SignalMutPointerConnectionProxyConfig) == 8); +typedef SignalMutPointerConnectionProxyConfig* SignalType_MutPointer_SignalMutPointerConnectionProxyConfig; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerConnectionProxyConfig) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerConnectionProxyConfig) == 8); +typedef SignalFingerprint* SignalType_MutPointer_SignalFingerprint; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalFingerprint) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalFingerprint) == 8); +typedef struct { + SignalFingerprint* raw; +} SignalMutPointerFingerprint; +static_assert_64bit(offsetof(SignalMutPointerFingerprint, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerFingerprint) == 8); +static_assert_64bit(alignof(SignalMutPointerFingerprint) == 8); +typedef SignalMutPointerFingerprint* SignalType_MutPointer_SignalMutPointerFingerprint; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerFingerprint) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerFingerprint) == 8); +typedef SignalKyberPublicKey* SignalType_MutPointer_SignalKyberPublicKey; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalKyberPublicKey) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalKyberPublicKey) == 8); +typedef struct { + SignalKyberPublicKey* raw; +} SignalMutPointerKyberPublicKey; +static_assert_64bit(offsetof(SignalMutPointerKyberPublicKey, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerKyberPublicKey) == 8); +static_assert_64bit(alignof(SignalMutPointerKyberPublicKey) == 8); +typedef SignalMutPointerKyberPublicKey* SignalType_MutPointer_SignalMutPointerKyberPublicKey; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerKyberPublicKey) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerKyberPublicKey) == 8); +typedef SignalKyberSecretKey* SignalType_MutPointer_SignalKyberSecretKey; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalKyberSecretKey) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalKyberSecretKey) == 8); +typedef struct { + SignalKyberSecretKey* raw; +} SignalMutPointerKyberSecretKey; +static_assert_64bit(offsetof(SignalMutPointerKyberSecretKey, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerKyberSecretKey) == 8); +static_assert_64bit(alignof(SignalMutPointerKyberSecretKey) == 8); +typedef SignalMutPointerKyberSecretKey* SignalType_MutPointer_SignalMutPointerKyberSecretKey; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerKyberSecretKey) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerKyberSecretKey) == 8); +typedef SignalKyberKeyPair* SignalType_MutPointer_SignalKyberKeyPair; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalKyberKeyPair) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalKyberKeyPair) == 8); +typedef struct { + SignalKyberKeyPair* raw; +} SignalMutPointerKyberKeyPair; +static_assert_64bit(offsetof(SignalMutPointerKyberKeyPair, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerKyberKeyPair) == 8); +static_assert_64bit(alignof(SignalMutPointerKyberKeyPair) == 8); +typedef SignalMutPointerKyberKeyPair* SignalType_MutPointer_SignalMutPointerKyberKeyPair; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerKyberKeyPair) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerKyberKeyPair) == 8); +typedef SignalCiphertextMessage* SignalType_MutPointer_SignalCiphertextMessage; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCiphertextMessage) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCiphertextMessage) == 8); +typedef struct { + SignalCiphertextMessage* raw; +} SignalMutPointerCiphertextMessage; +static_assert_64bit(offsetof(SignalMutPointerCiphertextMessage, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerCiphertextMessage) == 8); +static_assert_64bit(alignof(SignalMutPointerCiphertextMessage) == 8); +typedef SignalMutPointerCiphertextMessage* SignalType_MutPointer_SignalMutPointerCiphertextMessage; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerCiphertextMessage) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerCiphertextMessage) == 8); +typedef SignalDecryptionErrorMessage* SignalType_MutPointer_SignalDecryptionErrorMessage; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalDecryptionErrorMessage) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalDecryptionErrorMessage) == 8); +typedef struct { + SignalDecryptionErrorMessage* raw; +} SignalMutPointerDecryptionErrorMessage; +static_assert_64bit(offsetof(SignalMutPointerDecryptionErrorMessage, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerDecryptionErrorMessage) == 8); +static_assert_64bit(alignof(SignalMutPointerDecryptionErrorMessage) == 8); +typedef SignalMutPointerDecryptionErrorMessage* SignalType_MutPointer_SignalMutPointerDecryptionErrorMessage; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerDecryptionErrorMessage) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerDecryptionErrorMessage) == 8); +typedef SignalPlaintextContent* SignalType_MutPointer_SignalPlaintextContent; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalPlaintextContent) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalPlaintextContent) == 8); +typedef struct { + SignalPlaintextContent* raw; +} SignalMutPointerPlaintextContent; +static_assert_64bit(offsetof(SignalMutPointerPlaintextContent, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerPlaintextContent) == 8); +static_assert_64bit(alignof(SignalMutPointerPlaintextContent) == 8); +typedef SignalMutPointerPlaintextContent* SignalType_MutPointer_SignalMutPointerPlaintextContent; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerPlaintextContent) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerPlaintextContent) == 8); +typedef SignalPreKeySignalMessage* SignalType_MutPointer_SignalPreKeySignalMessage; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalPreKeySignalMessage) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalPreKeySignalMessage) == 8); +typedef struct { + SignalPreKeySignalMessage* raw; +} SignalMutPointerPreKeySignalMessage; +static_assert_64bit(offsetof(SignalMutPointerPreKeySignalMessage, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerPreKeySignalMessage) == 8); +static_assert_64bit(alignof(SignalMutPointerPreKeySignalMessage) == 8); +typedef SignalMutPointerPreKeySignalMessage* SignalType_MutPointer_SignalMutPointerPreKeySignalMessage; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerPreKeySignalMessage) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerPreKeySignalMessage) == 8); +typedef SignalSenderKeyDistributionMessage* SignalType_MutPointer_SignalSenderKeyDistributionMessage; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalSenderKeyDistributionMessage) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalSenderKeyDistributionMessage) == 8); +typedef struct { + SignalSenderKeyDistributionMessage* raw; +} SignalMutPointerSenderKeyDistributionMessage; +static_assert_64bit(offsetof(SignalMutPointerSenderKeyDistributionMessage, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerSenderKeyDistributionMessage) == 8); +static_assert_64bit(alignof(SignalMutPointerSenderKeyDistributionMessage) == 8); +typedef SignalMutPointerSenderKeyDistributionMessage* SignalType_MutPointer_SignalMutPointerSenderKeyDistributionMessage; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerSenderKeyDistributionMessage) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerSenderKeyDistributionMessage) == 8); +typedef SignalSenderKeyMessage* SignalType_MutPointer_SignalSenderKeyMessage; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalSenderKeyMessage) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalSenderKeyMessage) == 8); +typedef struct { + SignalSenderKeyMessage* raw; +} SignalMutPointerSenderKeyMessage; +static_assert_64bit(offsetof(SignalMutPointerSenderKeyMessage, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerSenderKeyMessage) == 8); +static_assert_64bit(alignof(SignalMutPointerSenderKeyMessage) == 8); +typedef SignalMutPointerSenderKeyMessage* SignalType_MutPointer_SignalMutPointerSenderKeyMessage; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerSenderKeyMessage) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerSenderKeyMessage) == 8); +typedef SignalSignalMessage* SignalType_MutPointer_SignalSignalMessage; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalSignalMessage) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalSignalMessage) == 8); +typedef struct { + SignalSignalMessage* raw; +} SignalMutPointerSignalMessage; +static_assert_64bit(offsetof(SignalMutPointerSignalMessage, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerSignalMessage) == 8); +static_assert_64bit(alignof(SignalMutPointerSignalMessage) == 8); +typedef SignalMutPointerSignalMessage* SignalType_MutPointer_SignalMutPointerSignalMessage; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerSignalMessage) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerSignalMessage) == 8); +typedef SignalSenderCertificate* SignalType_MutPointer_SignalSenderCertificate; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalSenderCertificate) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalSenderCertificate) == 8); +typedef struct { + SignalSenderCertificate* raw; +} SignalMutPointerSenderCertificate; +static_assert_64bit(offsetof(SignalMutPointerSenderCertificate, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerSenderCertificate) == 8); +static_assert_64bit(alignof(SignalMutPointerSenderCertificate) == 8); +typedef SignalMutPointerSenderCertificate* SignalType_MutPointer_SignalMutPointerSenderCertificate; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerSenderCertificate) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerSenderCertificate) == 8); +typedef SignalServerCertificate* SignalType_MutPointer_SignalServerCertificate; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalServerCertificate) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalServerCertificate) == 8); +typedef struct { + SignalServerCertificate* raw; +} SignalMutPointerServerCertificate; +static_assert_64bit(offsetof(SignalMutPointerServerCertificate, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerServerCertificate) == 8); +static_assert_64bit(alignof(SignalMutPointerServerCertificate) == 8); +typedef SignalMutPointerServerCertificate* SignalType_MutPointer_SignalMutPointerServerCertificate; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerServerCertificate) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerServerCertificate) == 8); +typedef SignalUnidentifiedSenderMessageContent* SignalType_MutPointer_SignalUnidentifiedSenderMessageContent; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalUnidentifiedSenderMessageContent) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalUnidentifiedSenderMessageContent) == 8); +typedef struct { + SignalUnidentifiedSenderMessageContent* raw; +} SignalMutPointerUnidentifiedSenderMessageContent; +static_assert_64bit(offsetof(SignalMutPointerUnidentifiedSenderMessageContent, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerUnidentifiedSenderMessageContent) == 8); +static_assert_64bit(alignof(SignalMutPointerUnidentifiedSenderMessageContent) == 8); +typedef SignalMutPointerUnidentifiedSenderMessageContent* SignalType_MutPointer_SignalMutPointerUnidentifiedSenderMessageContent; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerUnidentifiedSenderMessageContent) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerUnidentifiedSenderMessageContent) == 8); +typedef struct SignalAes256Ctr32 SignalAes256Ctr32; +typedef SignalAes256Ctr32* SignalType_MutPointer_SignalAes256Ctr32; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalAes256Ctr32) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalAes256Ctr32) == 8); +typedef struct { + SignalAes256Ctr32* raw; +} SignalMutPointerAes256Ctr32; +static_assert_64bit(offsetof(SignalMutPointerAes256Ctr32, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerAes256Ctr32) == 8); +static_assert_64bit(alignof(SignalMutPointerAes256Ctr32) == 8); +typedef SignalMutPointerAes256Ctr32* SignalType_MutPointer_SignalMutPointerAes256Ctr32; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerAes256Ctr32) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerAes256Ctr32) == 8); +typedef SignalServerPublicParams* SignalType_MutPointer_SignalServerPublicParams; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalServerPublicParams) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalServerPublicParams) == 8); +typedef struct { + SignalServerPublicParams* raw; +} SignalMutPointerServerPublicParams; +static_assert_64bit(offsetof(SignalMutPointerServerPublicParams, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerServerPublicParams) == 8); +static_assert_64bit(alignof(SignalMutPointerServerPublicParams) == 8); +typedef SignalMutPointerServerPublicParams* SignalType_MutPointer_SignalMutPointerServerPublicParams; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerServerPublicParams) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerServerPublicParams) == 8); +typedef SignalServerSecretParams* SignalType_MutPointer_SignalServerSecretParams; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalServerSecretParams) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalServerSecretParams) == 8); +typedef struct { + SignalServerSecretParams* raw; +} SignalMutPointerServerSecretParams; +static_assert_64bit(offsetof(SignalMutPointerServerSecretParams, raw) == 0); +static_assert_64bit(sizeof(SignalMutPointerServerSecretParams) == 8); +static_assert_64bit(alignof(SignalMutPointerServerSecretParams) == 8); +typedef SignalMutPointerServerSecretParams* SignalType_MutPointer_SignalMutPointerServerSecretParams; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalMutPointerServerSecretParams) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalMutPointerServerSecretParams) == 8); +typedef SignalOptionalUuid* SignalType_MutPointer_SignalOptionalUuid; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalOptionalUuid) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalOptionalUuid) == 8); +typedef struct { + SignalFfiMismatchedDevicesError* base; + size_t length; +} SignalOwnedBufferOfFfiMismatchedDevicesError; +static_assert_64bit(offsetof(SignalOwnedBufferOfFfiMismatchedDevicesError, base) == 0); +static_assert_64bit(offsetof(SignalOwnedBufferOfFfiMismatchedDevicesError, length) == 8); +static_assert_64bit(sizeof(SignalOwnedBufferOfFfiMismatchedDevicesError) == 16); +static_assert_64bit(alignof(SignalOwnedBufferOfFfiMismatchedDevicesError) == 8); +typedef SignalOwnedBufferOfFfiMismatchedDevicesError* SignalType_MutPointer_SignalOwnedBufferOfFfiMismatchedDevicesError; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalOwnedBufferOfFfiMismatchedDevicesError) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalOwnedBufferOfFfiMismatchedDevicesError) == 8); +typedef struct { + SignalFfiRegisterResponseBadge* base; + size_t length; +} SignalOwnedBufferOfFfiRegisterResponseBadge; +static_assert_64bit(offsetof(SignalOwnedBufferOfFfiRegisterResponseBadge, base) == 0); +static_assert_64bit(offsetof(SignalOwnedBufferOfFfiRegisterResponseBadge, length) == 8); +static_assert_64bit(sizeof(SignalOwnedBufferOfFfiRegisterResponseBadge) == 16); +static_assert_64bit(alignof(SignalOwnedBufferOfFfiRegisterResponseBadge) == 8); +typedef SignalOwnedBufferOfFfiRegisterResponseBadge* SignalType_MutPointer_SignalOwnedBufferOfFfiRegisterResponseBadge; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalOwnedBufferOfFfiRegisterResponseBadge) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalOwnedBufferOfFfiRegisterResponseBadge) == 8); +typedef SignalOwnedBuffer* SignalType_MutPointer_SignalOwnedBuffer; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalOwnedBuffer) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalOwnedBuffer) == 8); +typedef SignalPairOfCStringPtrCStringPtr* SignalType_MutPointer_SignalPairOfCStringPtrCStringPtr; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalPairOfCStringPtrCStringPtr) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalPairOfCStringPtrCStringPtr) == 8); +typedef struct { + const int8_t* first; + bool second; +} SignalPairOfCStringPtrbool; +static_assert_64bit(offsetof(SignalPairOfCStringPtrbool, first) == 0); +static_assert_64bit(offsetof(SignalPairOfCStringPtrbool, second) == 8); +static_assert_64bit(sizeof(SignalPairOfCStringPtrbool) == 16); +static_assert_64bit(alignof(SignalPairOfCStringPtrbool) == 8); +typedef SignalPairOfCStringPtrbool* SignalType_MutPointer_SignalPairOfCStringPtrbool; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalPairOfCStringPtrbool) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalPairOfCStringPtrbool) == 8); +typedef struct { + const int8_t* first; + uint32_t second; +} SignalPairOfCStringPtru32; +static_assert_64bit(offsetof(SignalPairOfCStringPtru32, first) == 0); +static_assert_64bit(offsetof(SignalPairOfCStringPtru32, second) == 8); +static_assert_64bit(sizeof(SignalPairOfCStringPtru32) == 16); +static_assert_64bit(alignof(SignalPairOfCStringPtru32) == 8); +typedef SignalPairOfCStringPtru32* SignalType_MutPointer_SignalPairOfCStringPtru32; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalPairOfCStringPtru32) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalPairOfCStringPtru32) == 8); +typedef struct { + SignalMutPointerPublicKey first; + SignalMutPointerPrivateKey second; +} SignalPairOfMutPointerPublicKeyMutPointerPrivateKey; +static_assert_64bit(offsetof(SignalPairOfMutPointerPublicKeyMutPointerPrivateKey, first) == 0); +static_assert_64bit(offsetof(SignalPairOfMutPointerPublicKeyMutPointerPrivateKey, second) == 8); +static_assert_64bit(sizeof(SignalPairOfMutPointerPublicKeyMutPointerPrivateKey) == 16); +static_assert_64bit(alignof(SignalPairOfMutPointerPublicKeyMutPointerPrivateKey) == 8); +typedef SignalPairOfMutPointerPublicKeyMutPointerPrivateKey* SignalType_MutPointer_SignalPairOfMutPointerPublicKeyMutPointerPrivateKey; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalPairOfMutPointerPublicKeyMutPointerPrivateKey) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalPairOfMutPointerPublicKeyMutPointerPrivateKey) == 8); +typedef struct { + const int8_t* first; + SignalOwnedBuffer second; +} SignalPairOfCStringPtrOwnedBuffer; +static_assert_64bit(offsetof(SignalPairOfCStringPtrOwnedBuffer, first) == 0); +static_assert_64bit(offsetof(SignalPairOfCStringPtrOwnedBuffer, second) == 8); +static_assert_64bit(sizeof(SignalPairOfCStringPtrOwnedBuffer) == 24); +static_assert_64bit(alignof(SignalPairOfCStringPtrOwnedBuffer) == 8); +typedef struct { + SignalPairOfCStringPtrOwnedBuffer first; + int64_t second; +} SignalPairOfPairOfCStringPtrOwnedBufferi64; +static_assert_64bit(offsetof(SignalPairOfPairOfCStringPtrOwnedBufferi64, first) == 0); +static_assert_64bit(offsetof(SignalPairOfPairOfCStringPtrOwnedBufferi64, second) == 24); +static_assert_64bit(sizeof(SignalPairOfPairOfCStringPtrOwnedBufferi64) == 32); +static_assert_64bit(alignof(SignalPairOfPairOfCStringPtrOwnedBufferi64) == 8); +typedef SignalPairOfPairOfCStringPtrOwnedBufferi64* SignalType_MutPointer_SignalPairOfPairOfCStringPtrOwnedBufferi64; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalPairOfPairOfCStringPtrOwnedBufferi64) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalPairOfPairOfCStringPtrOwnedBufferi64) == 8); +typedef SignalUuid* SignalType_MutPointer_SignalUuid; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalUuid) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalUuid) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalType_FixedArray32_uint8_t_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalType_FixedArray32_uint8_t, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalType_FixedArray32_uint8_t_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalType_FixedArray32_uint8_t_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalType_FixedArray32_uint8_t_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromisec_uchar32; +static_assert_64bit(offsetof(SignalCPromisec_uchar32, complete) == 0); +static_assert_64bit(offsetof(SignalCPromisec_uchar32, context) == 8); +static_assert_64bit(offsetof(SignalCPromisec_uchar32, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromisec_uchar32) == 24); +static_assert_64bit(alignof(SignalCPromisec_uchar32) == 8); +typedef SignalCPromisec_uchar32* SignalType_MutPointer_SignalCPromisec_uchar32; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromisec_uchar32) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromisec_uchar32) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_bool_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_bool, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_bool_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_bool_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_bool_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromisebool; +static_assert_64bit(offsetof(SignalCPromisebool, complete) == 0); +static_assert_64bit(offsetof(SignalCPromisebool, context) == 8); +static_assert_64bit(offsetof(SignalCPromisebool, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromisebool) == 24); +static_assert_64bit(alignof(SignalCPromisebool) == 8); +typedef SignalCPromisebool* SignalType_MutPointer_SignalCPromisebool; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromisebool) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromisebool) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiCdsiLookupResponse_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalFfiCdsiLookupResponse, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiCdsiLookupResponse_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiCdsiLookupResponse_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiCdsiLookupResponse_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseFfiCdsiLookupResponse; +static_assert_64bit(offsetof(SignalCPromiseFfiCdsiLookupResponse, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseFfiCdsiLookupResponse, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseFfiCdsiLookupResponse, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseFfiCdsiLookupResponse) == 24); +static_assert_64bit(alignof(SignalCPromiseFfiCdsiLookupResponse) == 8); +typedef SignalCPromiseFfiCdsiLookupResponse* SignalType_MutPointer_SignalCPromiseFfiCdsiLookupResponse; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseFfiCdsiLookupResponse) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseFfiCdsiLookupResponse) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiChatResponse_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalFfiChatResponse, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiChatResponse_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiChatResponse_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiChatResponse_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseFfiChatResponse; +static_assert_64bit(offsetof(SignalCPromiseFfiChatResponse, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseFfiChatResponse, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseFfiChatResponse, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseFfiChatResponse) == 24); +static_assert_64bit(alignof(SignalCPromiseFfiChatResponse) == 8); +typedef SignalCPromiseFfiChatResponse* SignalType_MutPointer_SignalCPromiseFfiChatResponse; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseFfiChatResponse) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseFfiChatResponse) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiCheckSvr2CredentialsResponse_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalFfiCheckSvr2CredentialsResponse, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiCheckSvr2CredentialsResponse_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiCheckSvr2CredentialsResponse_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiCheckSvr2CredentialsResponse_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseFfiCheckSvr2CredentialsResponse; +static_assert_64bit(offsetof(SignalCPromiseFfiCheckSvr2CredentialsResponse, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseFfiCheckSvr2CredentialsResponse, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseFfiCheckSvr2CredentialsResponse, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseFfiCheckSvr2CredentialsResponse) == 24); +static_assert_64bit(alignof(SignalCPromiseFfiCheckSvr2CredentialsResponse) == 8); +typedef SignalCPromiseFfiCheckSvr2CredentialsResponse* SignalType_MutPointer_SignalCPromiseFfiCheckSvr2CredentialsResponse; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseFfiCheckSvr2CredentialsResponse) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseFfiCheckSvr2CredentialsResponse) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiPreKeysResponse_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalFfiPreKeysResponse, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiPreKeysResponse_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiPreKeysResponse_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiPreKeysResponse_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseFfiPreKeysResponse; +static_assert_64bit(offsetof(SignalCPromiseFfiPreKeysResponse, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseFfiPreKeysResponse, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseFfiPreKeysResponse, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseFfiPreKeysResponse) == 24); +static_assert_64bit(alignof(SignalCPromiseFfiPreKeysResponse) == 8); +typedef SignalCPromiseFfiPreKeysResponse* SignalType_MutPointer_SignalCPromiseFfiPreKeysResponse; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseFfiPreKeysResponse) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseFfiPreKeysResponse) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiUploadForm_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalFfiUploadForm, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiUploadForm_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiUploadForm_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalFfiUploadForm_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseFfiUploadForm; +static_assert_64bit(offsetof(SignalCPromiseFfiUploadForm, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseFfiUploadForm, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseFfiUploadForm, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseFfiUploadForm) == 24); +static_assert_64bit(alignof(SignalCPromiseFfiUploadForm) == 8); +typedef SignalCPromiseFfiUploadForm* SignalType_MutPointer_SignalCPromiseFfiUploadForm; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseFfiUploadForm) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseFfiUploadForm) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerCdsiLookup_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalMutPointerCdsiLookup, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerCdsiLookup_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerCdsiLookup_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerCdsiLookup_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseMutPointerCdsiLookup; +static_assert_64bit(offsetof(SignalCPromiseMutPointerCdsiLookup, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseMutPointerCdsiLookup, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseMutPointerCdsiLookup, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseMutPointerCdsiLookup) == 24); +static_assert_64bit(alignof(SignalCPromiseMutPointerCdsiLookup) == 8); +typedef SignalCPromiseMutPointerCdsiLookup* SignalType_MutPointer_SignalCPromiseMutPointerCdsiLookup; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseMutPointerCdsiLookup) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseMutPointerCdsiLookup) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerAuthenticatedChatConnection_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalMutPointerAuthenticatedChatConnection, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerAuthenticatedChatConnection_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerAuthenticatedChatConnection_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerAuthenticatedChatConnection_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseMutPointerAuthenticatedChatConnection; +static_assert_64bit(offsetof(SignalCPromiseMutPointerAuthenticatedChatConnection, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseMutPointerAuthenticatedChatConnection, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseMutPointerAuthenticatedChatConnection, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseMutPointerAuthenticatedChatConnection) == 24); +static_assert_64bit(alignof(SignalCPromiseMutPointerAuthenticatedChatConnection) == 8); +typedef SignalCPromiseMutPointerAuthenticatedChatConnection* SignalType_MutPointer_SignalCPromiseMutPointerAuthenticatedChatConnection; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseMutPointerAuthenticatedChatConnection) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseMutPointerAuthenticatedChatConnection) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerProvisioningChatConnection_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalMutPointerProvisioningChatConnection, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerProvisioningChatConnection_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerProvisioningChatConnection_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerProvisioningChatConnection_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseMutPointerProvisioningChatConnection; +static_assert_64bit(offsetof(SignalCPromiseMutPointerProvisioningChatConnection, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseMutPointerProvisioningChatConnection, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseMutPointerProvisioningChatConnection, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseMutPointerProvisioningChatConnection) == 24); +static_assert_64bit(alignof(SignalCPromiseMutPointerProvisioningChatConnection) == 8); +typedef SignalCPromiseMutPointerProvisioningChatConnection* SignalType_MutPointer_SignalCPromiseMutPointerProvisioningChatConnection; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseMutPointerProvisioningChatConnection) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseMutPointerProvisioningChatConnection) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerUnauthenticatedChatConnection_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalMutPointerUnauthenticatedChatConnection, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerUnauthenticatedChatConnection_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerUnauthenticatedChatConnection_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerUnauthenticatedChatConnection_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseMutPointerUnauthenticatedChatConnection; +static_assert_64bit(offsetof(SignalCPromiseMutPointerUnauthenticatedChatConnection, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseMutPointerUnauthenticatedChatConnection, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseMutPointerUnauthenticatedChatConnection, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseMutPointerUnauthenticatedChatConnection) == 24); +static_assert_64bit(alignof(SignalCPromiseMutPointerUnauthenticatedChatConnection) == 8); +typedef SignalCPromiseMutPointerUnauthenticatedChatConnection* SignalType_MutPointer_SignalCPromiseMutPointerUnauthenticatedChatConnection; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseMutPointerUnauthenticatedChatConnection) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseMutPointerUnauthenticatedChatConnection) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerRegistrationService_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalMutPointerRegistrationService, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerRegistrationService_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerRegistrationService_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerRegistrationService_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseMutPointerRegistrationService; +static_assert_64bit(offsetof(SignalCPromiseMutPointerRegistrationService, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseMutPointerRegistrationService, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseMutPointerRegistrationService, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseMutPointerRegistrationService) == 24); +static_assert_64bit(alignof(SignalCPromiseMutPointerRegistrationService) == 8); +typedef SignalCPromiseMutPointerRegistrationService* SignalType_MutPointer_SignalCPromiseMutPointerRegistrationService; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseMutPointerRegistrationService) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseMutPointerRegistrationService) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerBackupRestoreResponse_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalMutPointerBackupRestoreResponse, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerBackupRestoreResponse_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerBackupRestoreResponse_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerBackupRestoreResponse_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseMutPointerBackupRestoreResponse; +static_assert_64bit(offsetof(SignalCPromiseMutPointerBackupRestoreResponse, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseMutPointerBackupRestoreResponse, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseMutPointerBackupRestoreResponse, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseMutPointerBackupRestoreResponse) == 24); +static_assert_64bit(alignof(SignalCPromiseMutPointerBackupRestoreResponse) == 8); +typedef SignalCPromiseMutPointerBackupRestoreResponse* SignalType_MutPointer_SignalCPromiseMutPointerBackupRestoreResponse; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseMutPointerBackupRestoreResponse) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseMutPointerBackupRestoreResponse) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerBackupStoreResponse_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalMutPointerBackupStoreResponse, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerBackupStoreResponse_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerBackupStoreResponse_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerBackupStoreResponse_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseMutPointerBackupStoreResponse; +static_assert_64bit(offsetof(SignalCPromiseMutPointerBackupStoreResponse, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseMutPointerBackupStoreResponse, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseMutPointerBackupStoreResponse, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseMutPointerBackupStoreResponse) == 24); +static_assert_64bit(alignof(SignalCPromiseMutPointerBackupStoreResponse) == 8); +typedef SignalCPromiseMutPointerBackupStoreResponse* SignalType_MutPointer_SignalCPromiseMutPointerBackupStoreResponse; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseMutPointerBackupStoreResponse) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseMutPointerBackupStoreResponse) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerRegisterAccountResponse_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalMutPointerRegisterAccountResponse, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerRegisterAccountResponse_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerRegisterAccountResponse_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalMutPointerRegisterAccountResponse_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseMutPointerRegisterAccountResponse; +static_assert_64bit(offsetof(SignalCPromiseMutPointerRegisterAccountResponse, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseMutPointerRegisterAccountResponse, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseMutPointerRegisterAccountResponse, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseMutPointerRegisterAccountResponse) == 24); +static_assert_64bit(alignof(SignalCPromiseMutPointerRegisterAccountResponse) == 8); +typedef SignalCPromiseMutPointerRegisterAccountResponse* SignalType_MutPointer_SignalCPromiseMutPointerRegisterAccountResponse; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseMutPointerRegisterAccountResponse) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseMutPointerRegisterAccountResponse) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOptionalPairOfCStringPtrc_uchar32_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalOptionalPairOfCStringPtrc_uchar32, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOptionalPairOfCStringPtrc_uchar32_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOptionalPairOfCStringPtrc_uchar32_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOptionalPairOfCStringPtrc_uchar32_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseOptionalPairOfCStringPtrc_uchar32; +static_assert_64bit(offsetof(SignalCPromiseOptionalPairOfCStringPtrc_uchar32, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseOptionalPairOfCStringPtrc_uchar32, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseOptionalPairOfCStringPtrc_uchar32, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseOptionalPairOfCStringPtrc_uchar32) == 24); +static_assert_64bit(alignof(SignalCPromiseOptionalPairOfCStringPtrc_uchar32) == 8); +typedef SignalCPromiseOptionalPairOfCStringPtrc_uchar32* SignalType_MutPointer_SignalCPromiseOptionalPairOfCStringPtrc_uchar32; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseOptionalPairOfCStringPtrc_uchar32) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseOptionalPairOfCStringPtrc_uchar32) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOptionalUuid_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalOptionalUuid, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOptionalUuid_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOptionalUuid_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOptionalUuid_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseOptionalUuid; +static_assert_64bit(offsetof(SignalCPromiseOptionalUuid, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseOptionalUuid, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseOptionalUuid, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseOptionalUuid) == 24); +static_assert_64bit(alignof(SignalCPromiseOptionalUuid) == 8); +typedef SignalCPromiseOptionalUuid* SignalType_MutPointer_SignalCPromiseOptionalUuid; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseOptionalUuid) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseOptionalUuid) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOwnedBufferOfc_uchar17_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalOwnedBufferOfc_uchar17, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOwnedBufferOfc_uchar17_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOwnedBufferOfc_uchar17_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOwnedBufferOfc_uchar17_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseOwnedBufferOfc_uchar17; +static_assert_64bit(offsetof(SignalCPromiseOwnedBufferOfc_uchar17, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseOwnedBufferOfc_uchar17, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseOwnedBufferOfc_uchar17, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseOwnedBufferOfc_uchar17) == 24); +static_assert_64bit(alignof(SignalCPromiseOwnedBufferOfc_uchar17) == 8); +typedef SignalCPromiseOwnedBufferOfc_uchar17* SignalType_MutPointer_SignalCPromiseOwnedBufferOfc_uchar17; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseOwnedBufferOfc_uchar17) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseOwnedBufferOfc_uchar17) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOwnedBuffer_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalOwnedBuffer, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOwnedBuffer_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOwnedBuffer_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOwnedBuffer_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseOwnedBuffer; +static_assert_64bit(offsetof(SignalCPromiseOwnedBuffer, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseOwnedBuffer, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseOwnedBuffer, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseOwnedBuffer) == 24); +static_assert_64bit(alignof(SignalCPromiseOwnedBuffer) == 8); +typedef SignalCPromiseOwnedBuffer* SignalType_MutPointer_SignalCPromiseOwnedBuffer; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseOwnedBuffer) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseOwnedBuffer) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult; +static_assert_64bit(offsetof(SignalCPromiseOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult) == 24); +static_assert_64bit(alignof(SignalCPromiseOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult) == 8); +typedef SignalCPromiseOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult* SignalType_MutPointer_SignalCPromiseOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalPairOfCStringPtrCStringPtr_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalPairOfCStringPtrCStringPtr, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalPairOfCStringPtrCStringPtr_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalPairOfCStringPtrCStringPtr_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalPairOfCStringPtrCStringPtr_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromisePairOfCStringPtrCStringPtr; +static_assert_64bit(offsetof(SignalCPromisePairOfCStringPtrCStringPtr, complete) == 0); +static_assert_64bit(offsetof(SignalCPromisePairOfCStringPtrCStringPtr, context) == 8); +static_assert_64bit(offsetof(SignalCPromisePairOfCStringPtrCStringPtr, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromisePairOfCStringPtrCStringPtr) == 24); +static_assert_64bit(alignof(SignalCPromisePairOfCStringPtrCStringPtr) == 8); +typedef SignalCPromisePairOfCStringPtrCStringPtr* SignalType_MutPointer_SignalCPromisePairOfCStringPtrCStringPtr; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromisePairOfCStringPtrCStringPtr) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromisePairOfCStringPtrCStringPtr) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromisePairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr; +static_assert_64bit(offsetof(SignalCPromisePairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr, complete) == 0); +static_assert_64bit(offsetof(SignalCPromisePairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr, context) == 8); +static_assert_64bit(offsetof(SignalCPromisePairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromisePairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr) == 24); +static_assert_64bit(alignof(SignalCPromisePairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr) == 8); +typedef SignalCPromisePairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr* SignalType_MutPointer_SignalCPromisePairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromisePairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromisePairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalPairOfOwnedBufferOwnedBuffer_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalPairOfOwnedBufferOwnedBuffer, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalPairOfOwnedBufferOwnedBuffer_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalPairOfOwnedBufferOwnedBuffer_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalPairOfOwnedBufferOwnedBuffer_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromisePairOfOwnedBufferOwnedBuffer; +static_assert_64bit(offsetof(SignalCPromisePairOfOwnedBufferOwnedBuffer, complete) == 0); +static_assert_64bit(offsetof(SignalCPromisePairOfOwnedBufferOwnedBuffer, context) == 8); +static_assert_64bit(offsetof(SignalCPromisePairOfOwnedBufferOwnedBuffer, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromisePairOfOwnedBufferOwnedBuffer) == 24); +static_assert_64bit(alignof(SignalCPromisePairOfOwnedBufferOwnedBuffer) == 8); +typedef SignalCPromisePairOfOwnedBufferOwnedBuffer* SignalType_MutPointer_SignalCPromisePairOfOwnedBufferOwnedBuffer; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromisePairOfOwnedBufferOwnedBuffer) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromisePairOfOwnedBufferOwnedBuffer) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalUuid_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalUuid, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalUuid_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalUuid_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalUuid_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseUuid; +static_assert_64bit(offsetof(SignalCPromiseUuid, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseUuid, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseUuid, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseUuid) == 24); +static_assert_64bit(alignof(SignalCPromiseUuid) == 8); +typedef SignalCPromiseUuid* SignalType_MutPointer_SignalCPromiseUuid; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseUuid) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseUuid) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalBridgeMediaBackupInfoFfiResult_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalBridgeMediaBackupInfoFfiResult, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalBridgeMediaBackupInfoFfiResult_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalBridgeMediaBackupInfoFfiResult_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalBridgeMediaBackupInfoFfiResult_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseBridgeMediaBackupInfoFfiResult; +static_assert_64bit(offsetof(SignalCPromiseBridgeMediaBackupInfoFfiResult, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseBridgeMediaBackupInfoFfiResult, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseBridgeMediaBackupInfoFfiResult, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseBridgeMediaBackupInfoFfiResult) == 24); +static_assert_64bit(alignof(SignalCPromiseBridgeMediaBackupInfoFfiResult) == 8); +typedef SignalCPromiseBridgeMediaBackupInfoFfiResult* SignalType_MutPointer_SignalCPromiseBridgeMediaBackupInfoFfiResult; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseBridgeMediaBackupInfoFfiResult) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseBridgeMediaBackupInfoFfiResult) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalBridgeMessageBackupInfoFfiResult_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalBridgeMessageBackupInfoFfiResult, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalBridgeMessageBackupInfoFfiResult_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalBridgeMessageBackupInfoFfiResult_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalBridgeMessageBackupInfoFfiResult_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseBridgeMessageBackupInfoFfiResult; +static_assert_64bit(offsetof(SignalCPromiseBridgeMessageBackupInfoFfiResult, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseBridgeMessageBackupInfoFfiResult, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseBridgeMessageBackupInfoFfiResult, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseBridgeMessageBackupInfoFfiResult) == 24); +static_assert_64bit(alignof(SignalCPromiseBridgeMessageBackupInfoFfiResult) == 8); +typedef SignalCPromiseBridgeMessageBackupInfoFfiResult* SignalType_MutPointer_SignalCPromiseBridgeMessageBackupInfoFfiResult; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseBridgeMessageBackupInfoFfiResult) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseBridgeMessageBackupInfoFfiResult) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalCopyBackupMediaNextChunkFfiResult_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalCopyBackupMediaNextChunkFfiResult, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalCopyBackupMediaNextChunkFfiResult_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalCopyBackupMediaNextChunkFfiResult_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalCopyBackupMediaNextChunkFfiResult_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseCopyBackupMediaNextChunkFfiResult; +static_assert_64bit(offsetof(SignalCPromiseCopyBackupMediaNextChunkFfiResult, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseCopyBackupMediaNextChunkFfiResult, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseCopyBackupMediaNextChunkFfiResult, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseCopyBackupMediaNextChunkFfiResult) == 24); +static_assert_64bit(alignof(SignalCPromiseCopyBackupMediaNextChunkFfiResult) == 8); +typedef SignalCPromiseCopyBackupMediaNextChunkFfiResult* SignalType_MutPointer_SignalCPromiseCopyBackupMediaNextChunkFfiResult; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseCopyBackupMediaNextChunkFfiResult) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseCopyBackupMediaNextChunkFfiResult) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalDeleteBackupMediaNextChunkFfiResult_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalDeleteBackupMediaNextChunkFfiResult, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalDeleteBackupMediaNextChunkFfiResult_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalDeleteBackupMediaNextChunkFfiResult_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalDeleteBackupMediaNextChunkFfiResult_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseDeleteBackupMediaNextChunkFfiResult; +static_assert_64bit(offsetof(SignalCPromiseDeleteBackupMediaNextChunkFfiResult, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseDeleteBackupMediaNextChunkFfiResult, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseDeleteBackupMediaNextChunkFfiResult, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseDeleteBackupMediaNextChunkFfiResult) == 24); +static_assert_64bit(alignof(SignalCPromiseDeleteBackupMediaNextChunkFfiResult) == 8); +typedef SignalCPromiseDeleteBackupMediaNextChunkFfiResult* SignalType_MutPointer_SignalCPromiseDeleteBackupMediaNextChunkFfiResult; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseDeleteBackupMediaNextChunkFfiResult) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseDeleteBackupMediaNextChunkFfiResult) == 8); +typedef void (*SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalListMediaResponseFfiResult_SignalType_ConstPointer_void)(SignalType_MutPointer_SignalFfiError, SignalType_ConstPointer_SignalListMediaResponseFfiResult, SignalType_ConstPointer_void); +static_assert_64bit(sizeof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalListMediaResponseFfiResult_SignalType_ConstPointer_void) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalListMediaResponseFfiResult_SignalType_ConstPointer_void) == 8); +typedef struct { + SignalType_FunctionPointer_void_SignalType_MutPointer_SignalFfiError_SignalType_ConstPointer_SignalListMediaResponseFfiResult_SignalType_ConstPointer_void complete; + const void* context; + uint64_t cancellation_id; +} SignalCPromiseListMediaResponseFfiResult; +static_assert_64bit(offsetof(SignalCPromiseListMediaResponseFfiResult, complete) == 0); +static_assert_64bit(offsetof(SignalCPromiseListMediaResponseFfiResult, context) == 8); +static_assert_64bit(offsetof(SignalCPromiseListMediaResponseFfiResult, cancellation_id) == 16); +static_assert_64bit(sizeof(SignalCPromiseListMediaResponseFfiResult) == 24); +static_assert_64bit(alignof(SignalCPromiseListMediaResponseFfiResult) == 8); +typedef SignalCPromiseListMediaResponseFfiResult* SignalType_MutPointer_SignalCPromiseListMediaResponseFfiResult; +static_assert_64bit(sizeof(SignalType_MutPointer_SignalCPromiseListMediaResponseFfiResult) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_SignalCPromiseListMediaResponseFfiResult) == 8); +typedef uint16_t* SignalType_MutPointer_uint16_t; +static_assert_64bit(sizeof(SignalType_MutPointer_uint16_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_uint16_t) == 8); +typedef uint64_t* SignalType_MutPointer_uint64_t; +static_assert_64bit(sizeof(SignalType_MutPointer_uint64_t) == 8); +static_assert_64bit(alignof(SignalType_MutPointer_uint64_t) == 8); typedef enum { SignalLogLevelError = 1, - SignalLogLevelWarn, - SignalLogLevelInfo, - SignalLogLevelDebug, - SignalLogLevelTrace, + SignalLogLevelWarn = 2, + SignalLogLevelInfo = 3, + SignalLogLevelDebug = 4, + SignalLogLevelTrace = 5, } SignalLogLevel; - +static_assert_64bit(sizeof(SignalLogLevel) == 4); +static_assert_64bit(alignof(SignalLogLevel) == 4); +typedef int32_t (*SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalLogLevel_SignalCStringPtr_uint32_t_SignalCStringPtr)(SignalType_MutPointer_void, SignalLogLevel, SignalCStringPtr, uint32_t, SignalCStringPtr); +static_assert_64bit(sizeof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalLogLevel_SignalCStringPtr_uint32_t_SignalCStringPtr) == 8); +static_assert_64bit(alignof(SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalLogLevel_SignalCStringPtr_uint32_t_SignalCStringPtr) == 8); +typedef struct { + const size_t* base; + size_t length; +} SignalBorrowedSliceOfusize; +static_assert_64bit(offsetof(SignalBorrowedSliceOfusize, base) == 0); +static_assert_64bit(offsetof(SignalBorrowedSliceOfusize, length) == 8); +static_assert_64bit(sizeof(SignalBorrowedSliceOfusize) == 16); +static_assert_64bit(alignof(SignalBorrowedSliceOfusize) == 8); +typedef struct { + SignalBorrowedBuffer bytes; + SignalBorrowedSliceOfusize lengths; +} SignalBorrowedBytestringArray; +static_assert_64bit(offsetof(SignalBorrowedBytestringArray, bytes) == 0); +static_assert_64bit(offsetof(SignalBorrowedBytestringArray, lengths) == 16); +static_assert_64bit(sizeof(SignalBorrowedBytestringArray) == 32); +static_assert_64bit(alignof(SignalBorrowedBytestringArray) == 8); +typedef struct { + const SignalType_ConstPointer_SignalType_FixedArray32_uint8_t* base; + size_t length; +} SignalBorrowedSliceOfc_uchar32; +static_assert_64bit(offsetof(SignalBorrowedSliceOfc_uchar32, base) == 0); +static_assert_64bit(offsetof(SignalBorrowedSliceOfc_uchar32, length) == 8); +static_assert_64bit(sizeof(SignalBorrowedSliceOfc_uchar32) == 16); +static_assert_64bit(alignof(SignalBorrowedSliceOfc_uchar32) == 8); +typedef struct { + const SignalBorrowedBuffer* base; + size_t length; +} SignalBorrowedSliceOfBuffers; +static_assert_64bit(offsetof(SignalBorrowedSliceOfBuffers, base) == 0); +static_assert_64bit(offsetof(SignalBorrowedSliceOfBuffers, length) == 8); +static_assert_64bit(sizeof(SignalBorrowedSliceOfBuffers) == 16); +static_assert_64bit(alignof(SignalBorrowedSliceOfBuffers) == 8); +typedef struct { + const SignalConstPointerProtocolAddress* base; + size_t length; +} SignalBorrowedSliceOfConstPointerProtocolAddress; +static_assert_64bit(offsetof(SignalBorrowedSliceOfConstPointerProtocolAddress, base) == 0); +static_assert_64bit(offsetof(SignalBorrowedSliceOfConstPointerProtocolAddress, length) == 8); +static_assert_64bit(sizeof(SignalBorrowedSliceOfConstPointerProtocolAddress) == 16); +static_assert_64bit(alignof(SignalBorrowedSliceOfConstPointerProtocolAddress) == 8); +typedef struct { + const SignalConstPointerPublicKey* base; + size_t length; +} SignalBorrowedSliceOfConstPointerPublicKey; +static_assert_64bit(offsetof(SignalBorrowedSliceOfConstPointerPublicKey, base) == 0); +static_assert_64bit(offsetof(SignalBorrowedSliceOfConstPointerPublicKey, length) == 8); +static_assert_64bit(sizeof(SignalBorrowedSliceOfConstPointerPublicKey) == 16); +static_assert_64bit(alignof(SignalBorrowedSliceOfConstPointerPublicKey) == 8); +typedef struct { + const SignalConstPointerCiphertextMessage* base; + size_t length; +} SignalBorrowedSliceOfConstPointerCiphertextMessage; +static_assert_64bit(offsetof(SignalBorrowedSliceOfConstPointerCiphertextMessage, base) == 0); +static_assert_64bit(offsetof(SignalBorrowedSliceOfConstPointerCiphertextMessage, length) == 8); +static_assert_64bit(sizeof(SignalBorrowedSliceOfConstPointerCiphertextMessage) == 16); +static_assert_64bit(alignof(SignalBorrowedSliceOfConstPointerCiphertextMessage) == 8); +typedef struct { + const SignalConstPointerSessionRecord* base; + size_t length; +} SignalBorrowedSliceOfConstPointerSessionRecord; +static_assert_64bit(offsetof(SignalBorrowedSliceOfConstPointerSessionRecord, base) == 0); +static_assert_64bit(offsetof(SignalBorrowedSliceOfConstPointerSessionRecord, length) == 8); +static_assert_64bit(sizeof(SignalBorrowedSliceOfConstPointerSessionRecord) == 16); +static_assert_64bit(alignof(SignalBorrowedSliceOfConstPointerSessionRecord) == 8); +typedef struct { + const SignalBridgeCopyBackupMediaItemFfiArg* base; + size_t length; +} SignalBorrowedSliceOfBridgeCopyBackupMediaItemFfiArg; +static_assert_64bit(offsetof(SignalBorrowedSliceOfBridgeCopyBackupMediaItemFfiArg, base) == 0); +static_assert_64bit(offsetof(SignalBorrowedSliceOfBridgeCopyBackupMediaItemFfiArg, length) == 8); +static_assert_64bit(sizeof(SignalBorrowedSliceOfBridgeCopyBackupMediaItemFfiArg) == 16); +static_assert_64bit(alignof(SignalBorrowedSliceOfBridgeCopyBackupMediaItemFfiArg) == 8); +typedef struct { + const SignalBridgeDeleteBackupMediaItemFfiArg* base; + size_t length; +} SignalBorrowedSliceOfBridgeDeleteBackupMediaItemFfiArg; +static_assert_64bit(offsetof(SignalBorrowedSliceOfBridgeDeleteBackupMediaItemFfiArg, base) == 0); +static_assert_64bit(offsetof(SignalBorrowedSliceOfBridgeDeleteBackupMediaItemFfiArg, length) == 8); +static_assert_64bit(sizeof(SignalBorrowedSliceOfBridgeDeleteBackupMediaItemFfiArg) == 16); +static_assert_64bit(alignof(SignalBorrowedSliceOfBridgeDeleteBackupMediaItemFfiArg) == 8); +typedef struct { + const uint32_t* base; + size_t length; +} SignalBorrowedSliceOfu32; +static_assert_64bit(offsetof(SignalBorrowedSliceOfu32, base) == 0); +static_assert_64bit(offsetof(SignalBorrowedSliceOfu32, length) == 8); +static_assert_64bit(sizeof(SignalBorrowedSliceOfu32) == 16); +static_assert_64bit(alignof(SignalBorrowedSliceOfu32) == 8); +typedef struct { + const SignalPinHash* raw; +} SignalConstPointerPinHash; +static_assert_64bit(offsetof(SignalConstPointerPinHash, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerPinHash) == 8); +static_assert_64bit(alignof(SignalConstPointerPinHash) == 8); +typedef struct { + const SignalAes256GcmSiv* raw; +} SignalConstPointerAes256GcmSiv; +static_assert_64bit(offsetof(SignalConstPointerAes256GcmSiv, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerAes256GcmSiv) == 8); +static_assert_64bit(alignof(SignalConstPointerAes256GcmSiv) == 8); +typedef struct { + const SignalFfiConnectChatBridgeStruct* raw; +} SignalConstPointerFfiConnectChatBridgeStruct; +static_assert_64bit(offsetof(SignalConstPointerFfiConnectChatBridgeStruct, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerFfiConnectChatBridgeStruct) == 8); +static_assert_64bit(alignof(SignalConstPointerFfiConnectChatBridgeStruct) == 8); +typedef struct { + const SignalHsmEnclaveClient* raw; +} SignalConstPointerHsmEnclaveClient; +static_assert_64bit(offsetof(SignalConstPointerHsmEnclaveClient, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerHsmEnclaveClient) == 8); +static_assert_64bit(alignof(SignalConstPointerHsmEnclaveClient) == 8); +typedef struct { + const SignalFfiSyncInputStreamStruct* raw; +} SignalConstPointerFfiSyncInputStreamStruct; +static_assert_64bit(offsetof(SignalConstPointerFfiSyncInputStreamStruct, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerFfiSyncInputStreamStruct) == 8); +static_assert_64bit(alignof(SignalConstPointerFfiSyncInputStreamStruct) == 8); +typedef struct { + const SignalMessageBackupKey* raw; +} SignalConstPointerMessageBackupKey; +static_assert_64bit(offsetof(SignalConstPointerMessageBackupKey, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerMessageBackupKey) == 8); +static_assert_64bit(alignof(SignalConstPointerMessageBackupKey) == 8); +typedef struct { + const SignalMessageBackupValidationOutcome* raw; +} SignalConstPointerMessageBackupValidationOutcome; +static_assert_64bit(offsetof(SignalConstPointerMessageBackupValidationOutcome, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerMessageBackupValidationOutcome) == 8); +static_assert_64bit(alignof(SignalConstPointerMessageBackupValidationOutcome) == 8); +typedef struct { + const SignalConnectionManager* raw; +} SignalConstPointerConnectionManager; +static_assert_64bit(offsetof(SignalConstPointerConnectionManager, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerConnectionManager) == 8); +static_assert_64bit(alignof(SignalConstPointerConnectionManager) == 8); +typedef struct { + const SignalCdsiLookup* raw; +} SignalConstPointerCdsiLookup; +static_assert_64bit(offsetof(SignalConstPointerCdsiLookup, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerCdsiLookup) == 8); +static_assert_64bit(alignof(SignalConstPointerCdsiLookup) == 8); +typedef struct { + const SignalLookupRequest* raw; +} SignalConstPointerLookupRequest; +static_assert_64bit(offsetof(SignalConstPointerLookupRequest, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerLookupRequest) == 8); +static_assert_64bit(alignof(SignalConstPointerLookupRequest) == 8); +typedef struct { + const SignalAuthenticatedChatConnection* raw; +} SignalConstPointerAuthenticatedChatConnection; +static_assert_64bit(offsetof(SignalConstPointerAuthenticatedChatConnection, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerAuthenticatedChatConnection) == 8); +static_assert_64bit(alignof(SignalConstPointerAuthenticatedChatConnection) == 8); +typedef struct { + const SignalCopyBackupMediaStream* raw; +} SignalConstPointerCopyBackupMediaStream; +static_assert_64bit(offsetof(SignalConstPointerCopyBackupMediaStream, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerCopyBackupMediaStream) == 8); +static_assert_64bit(alignof(SignalConstPointerCopyBackupMediaStream) == 8); +typedef struct { + const SignalDeleteBackupMediaStream* raw; +} SignalConstPointerDeleteBackupMediaStream; +static_assert_64bit(offsetof(SignalConstPointerDeleteBackupMediaStream, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerDeleteBackupMediaStream) == 8); +static_assert_64bit(alignof(SignalConstPointerDeleteBackupMediaStream) == 8); +typedef struct { + const SignalFfiChatListenerStruct* raw; +} SignalConstPointerFfiChatListenerStruct; +static_assert_64bit(offsetof(SignalConstPointerFfiChatListenerStruct, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerFfiChatListenerStruct) == 8); +static_assert_64bit(alignof(SignalConstPointerFfiChatListenerStruct) == 8); +typedef struct { + const SignalFfiProvisioningListenerStruct* raw; +} SignalConstPointerFfiProvisioningListenerStruct; +static_assert_64bit(offsetof(SignalConstPointerFfiProvisioningListenerStruct, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerFfiProvisioningListenerStruct) == 8); +static_assert_64bit(alignof(SignalConstPointerFfiProvisioningListenerStruct) == 8); +typedef struct { + const SignalHttpRequest* raw; +} SignalConstPointerHttpRequest; +static_assert_64bit(offsetof(SignalConstPointerHttpRequest, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerHttpRequest) == 8); +static_assert_64bit(alignof(SignalConstPointerHttpRequest) == 8); +typedef struct { + const SignalProvisioningChatConnection* raw; +} SignalConstPointerProvisioningChatConnection; +static_assert_64bit(offsetof(SignalConstPointerProvisioningChatConnection, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerProvisioningChatConnection) == 8); +static_assert_64bit(alignof(SignalConstPointerProvisioningChatConnection) == 8); +typedef struct { + const SignalServerMessageAck* raw; +} SignalConstPointerServerMessageAck; +static_assert_64bit(offsetof(SignalConstPointerServerMessageAck, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerServerMessageAck) == 8); +static_assert_64bit(alignof(SignalConstPointerServerMessageAck) == 8); +typedef struct { + const SignalUnauthenticatedChatConnection* raw; +} SignalConstPointerUnauthenticatedChatConnection; +static_assert_64bit(offsetof(SignalConstPointerUnauthenticatedChatConnection, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerUnauthenticatedChatConnection) == 8); +static_assert_64bit(alignof(SignalConstPointerUnauthenticatedChatConnection) == 8); +typedef struct { + const SignalRegistrationAccountAttributes* raw; +} SignalConstPointerRegistrationAccountAttributes; +static_assert_64bit(offsetof(SignalConstPointerRegistrationAccountAttributes, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerRegistrationAccountAttributes) == 8); +static_assert_64bit(alignof(SignalConstPointerRegistrationAccountAttributes) == 8); +typedef struct { + const SignalRegisterAccountRequest* raw; +} SignalConstPointerRegisterAccountRequest; +static_assert_64bit(offsetof(SignalConstPointerRegisterAccountRequest, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerRegisterAccountRequest) == 8); +static_assert_64bit(alignof(SignalConstPointerRegisterAccountRequest) == 8); +typedef struct { + const SignalRegistrationService* raw; +} SignalConstPointerRegistrationService; +static_assert_64bit(offsetof(SignalConstPointerRegistrationService, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerRegistrationService) == 8); +static_assert_64bit(alignof(SignalConstPointerRegistrationService) == 8); +typedef struct { + const SignalTokioAsyncContext* raw; +} SignalConstPointerTokioAsyncContext; +static_assert_64bit(offsetof(SignalConstPointerTokioAsyncContext, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerTokioAsyncContext) == 8); +static_assert_64bit(alignof(SignalConstPointerTokioAsyncContext) == 8); +typedef struct { + const SignalFfiIdentityKeyStoreStruct* raw; +} SignalConstPointerFfiIdentityKeyStoreStruct; +static_assert_64bit(offsetof(SignalConstPointerFfiIdentityKeyStoreStruct, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerFfiIdentityKeyStoreStruct) == 8); +static_assert_64bit(alignof(SignalConstPointerFfiIdentityKeyStoreStruct) == 8); +typedef struct { + const SignalFfiKyberPreKeyStoreStruct* raw; +} SignalConstPointerFfiKyberPreKeyStoreStruct; +static_assert_64bit(offsetof(SignalConstPointerFfiKyberPreKeyStoreStruct, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerFfiKyberPreKeyStoreStruct) == 8); +static_assert_64bit(alignof(SignalConstPointerFfiKyberPreKeyStoreStruct) == 8); +typedef struct { + const SignalFfiPreKeyStoreStruct* raw; +} SignalConstPointerFfiPreKeyStoreStruct; +static_assert_64bit(offsetof(SignalConstPointerFfiPreKeyStoreStruct, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerFfiPreKeyStoreStruct) == 8); +static_assert_64bit(alignof(SignalConstPointerFfiPreKeyStoreStruct) == 8); +typedef struct { + const SignalFfiSenderKeyStoreStruct* raw; +} SignalConstPointerFfiSenderKeyStoreStruct; +static_assert_64bit(offsetof(SignalConstPointerFfiSenderKeyStoreStruct, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerFfiSenderKeyStoreStruct) == 8); +static_assert_64bit(alignof(SignalConstPointerFfiSenderKeyStoreStruct) == 8); +typedef struct { + const SignalFfiSessionStoreStruct* raw; +} SignalConstPointerFfiSessionStoreStruct; +static_assert_64bit(offsetof(SignalConstPointerFfiSessionStoreStruct, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerFfiSessionStoreStruct) == 8); +static_assert_64bit(alignof(SignalConstPointerFfiSessionStoreStruct) == 8); +typedef struct { + const SignalFfiSignedPreKeyStoreStruct* raw; +} SignalConstPointerFfiSignedPreKeyStoreStruct; +static_assert_64bit(offsetof(SignalConstPointerFfiSignedPreKeyStoreStruct, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerFfiSignedPreKeyStoreStruct) == 8); +static_assert_64bit(alignof(SignalConstPointerFfiSignedPreKeyStoreStruct) == 8); +typedef struct { + const SignalSgxClientState* raw; +} SignalConstPointerSgxClientState; +static_assert_64bit(offsetof(SignalConstPointerSgxClientState, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerSgxClientState) == 8); +static_assert_64bit(alignof(SignalConstPointerSgxClientState) == 8); +typedef struct { + const SignalBridgedStringMap* raw; +} SignalConstPointerBridgedStringMap; +static_assert_64bit(offsetof(SignalConstPointerBridgedStringMap, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerBridgedStringMap) == 8); +static_assert_64bit(alignof(SignalConstPointerBridgedStringMap) == 8); +typedef struct { + const SignalPrivateKey* raw; +} SignalConstPointerPrivateKey; +static_assert_64bit(offsetof(SignalConstPointerPrivateKey, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerPrivateKey) == 8); +static_assert_64bit(alignof(SignalConstPointerPrivateKey) == 8); +typedef struct { + const SignalChatConnectionInfo* raw; +} SignalConstPointerChatConnectionInfo; +static_assert_64bit(offsetof(SignalConstPointerChatConnectionInfo, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerChatConnectionInfo) == 8); +static_assert_64bit(alignof(SignalConstPointerChatConnectionInfo) == 8); +typedef struct { + const SignalBackupRestoreResponse* raw; +} SignalConstPointerBackupRestoreResponse; +static_assert_64bit(offsetof(SignalConstPointerBackupRestoreResponse, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerBackupRestoreResponse) == 8); +static_assert_64bit(alignof(SignalConstPointerBackupRestoreResponse) == 8); +typedef struct { + const SignalBackupStoreResponse* raw; +} SignalConstPointerBackupStoreResponse; +static_assert_64bit(offsetof(SignalConstPointerBackupStoreResponse, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerBackupStoreResponse) == 8); +static_assert_64bit(alignof(SignalConstPointerBackupStoreResponse) == 8); +typedef struct { + const SignalRegisterAccountResponse* raw; +} SignalConstPointerRegisterAccountResponse; +static_assert_64bit(offsetof(SignalConstPointerRegisterAccountResponse, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerRegisterAccountResponse) == 8); +static_assert_64bit(alignof(SignalConstPointerRegisterAccountResponse) == 8); +typedef struct { + const SignalRegistrationSession* raw; +} SignalConstPointerRegistrationSession; +static_assert_64bit(offsetof(SignalConstPointerRegistrationSession, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerRegistrationSession) == 8); +static_assert_64bit(alignof(SignalConstPointerRegistrationSession) == 8); +typedef struct { + const SignalConnectionProxyConfig* raw; +} SignalConstPointerConnectionProxyConfig; +static_assert_64bit(offsetof(SignalConstPointerConnectionProxyConfig, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerConnectionProxyConfig) == 8); +static_assert_64bit(alignof(SignalConstPointerConnectionProxyConfig) == 8); +typedef struct { + const SignalFingerprint* raw; +} SignalConstPointerFingerprint; +static_assert_64bit(offsetof(SignalConstPointerFingerprint, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerFingerprint) == 8); +static_assert_64bit(alignof(SignalConstPointerFingerprint) == 8); +typedef struct { + const SignalKyberPublicKey* raw; +} SignalConstPointerKyberPublicKey; +static_assert_64bit(offsetof(SignalConstPointerKyberPublicKey, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerKyberPublicKey) == 8); +static_assert_64bit(alignof(SignalConstPointerKyberPublicKey) == 8); +typedef struct { + const SignalKyberSecretKey* raw; +} SignalConstPointerKyberSecretKey; +static_assert_64bit(offsetof(SignalConstPointerKyberSecretKey, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerKyberSecretKey) == 8); +static_assert_64bit(alignof(SignalConstPointerKyberSecretKey) == 8); +typedef struct { + const SignalKyberKeyPair* raw; +} SignalConstPointerKyberKeyPair; +static_assert_64bit(offsetof(SignalConstPointerKyberKeyPair, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerKyberKeyPair) == 8); +static_assert_64bit(alignof(SignalConstPointerKyberKeyPair) == 8); +typedef struct { + const SignalDecryptionErrorMessage* raw; +} SignalConstPointerDecryptionErrorMessage; +static_assert_64bit(offsetof(SignalConstPointerDecryptionErrorMessage, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerDecryptionErrorMessage) == 8); +static_assert_64bit(alignof(SignalConstPointerDecryptionErrorMessage) == 8); +typedef struct { + const SignalPlaintextContent* raw; +} SignalConstPointerPlaintextContent; +static_assert_64bit(offsetof(SignalConstPointerPlaintextContent, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerPlaintextContent) == 8); +static_assert_64bit(alignof(SignalConstPointerPlaintextContent) == 8); +typedef struct { + const SignalPreKeySignalMessage* raw; +} SignalConstPointerPreKeySignalMessage; +static_assert_64bit(offsetof(SignalConstPointerPreKeySignalMessage, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerPreKeySignalMessage) == 8); +static_assert_64bit(alignof(SignalConstPointerPreKeySignalMessage) == 8); +typedef struct { + const SignalSenderKeyDistributionMessage* raw; +} SignalConstPointerSenderKeyDistributionMessage; +static_assert_64bit(offsetof(SignalConstPointerSenderKeyDistributionMessage, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerSenderKeyDistributionMessage) == 8); +static_assert_64bit(alignof(SignalConstPointerSenderKeyDistributionMessage) == 8); +typedef struct { + const SignalSenderKeyMessage* raw; +} SignalConstPointerSenderKeyMessage; +static_assert_64bit(offsetof(SignalConstPointerSenderKeyMessage, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerSenderKeyMessage) == 8); +static_assert_64bit(alignof(SignalConstPointerSenderKeyMessage) == 8); +typedef struct { + const SignalSignalMessage* raw; +} SignalConstPointerSignalMessage; +static_assert_64bit(offsetof(SignalConstPointerSignalMessage, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerSignalMessage) == 8); +static_assert_64bit(alignof(SignalConstPointerSignalMessage) == 8); +typedef struct { + const SignalSenderCertificate* raw; +} SignalConstPointerSenderCertificate; +static_assert_64bit(offsetof(SignalConstPointerSenderCertificate, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerSenderCertificate) == 8); +static_assert_64bit(alignof(SignalConstPointerSenderCertificate) == 8); +typedef struct { + const SignalServerCertificate* raw; +} SignalConstPointerServerCertificate; +static_assert_64bit(offsetof(SignalConstPointerServerCertificate, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerServerCertificate) == 8); +static_assert_64bit(alignof(SignalConstPointerServerCertificate) == 8); +typedef struct { + const SignalUnidentifiedSenderMessageContent* raw; +} SignalConstPointerUnidentifiedSenderMessageContent; +static_assert_64bit(offsetof(SignalConstPointerUnidentifiedSenderMessageContent, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerUnidentifiedSenderMessageContent) == 8); +static_assert_64bit(alignof(SignalConstPointerUnidentifiedSenderMessageContent) == 8); +typedef struct { + const SignalSenderKeyRecord* raw; +} SignalConstPointerSenderKeyRecord; +static_assert_64bit(offsetof(SignalConstPointerSenderKeyRecord, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerSenderKeyRecord) == 8); +static_assert_64bit(alignof(SignalConstPointerSenderKeyRecord) == 8); +typedef struct { + const SignalPreKeyBundle* raw; +} SignalConstPointerPreKeyBundle; +static_assert_64bit(offsetof(SignalConstPointerPreKeyBundle, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerPreKeyBundle) == 8); +static_assert_64bit(alignof(SignalConstPointerPreKeyBundle) == 8); +typedef struct { + const SignalKyberPreKeyRecord* raw; +} SignalConstPointerKyberPreKeyRecord; +static_assert_64bit(offsetof(SignalConstPointerKyberPreKeyRecord, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerKyberPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalConstPointerKyberPreKeyRecord) == 8); +typedef struct { + const SignalPreKeyRecord* raw; +} SignalConstPointerPreKeyRecord; +static_assert_64bit(offsetof(SignalConstPointerPreKeyRecord, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalConstPointerPreKeyRecord) == 8); +typedef struct { + const SignalSignedPreKeyRecord* raw; +} SignalConstPointerSignedPreKeyRecord; +static_assert_64bit(offsetof(SignalConstPointerSignedPreKeyRecord, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerSignedPreKeyRecord) == 8); +static_assert_64bit(alignof(SignalConstPointerSignedPreKeyRecord) == 8); +typedef struct { + const SignalServerPublicParams* raw; +} SignalConstPointerServerPublicParams; +static_assert_64bit(offsetof(SignalConstPointerServerPublicParams, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerServerPublicParams) == 8); +static_assert_64bit(alignof(SignalConstPointerServerPublicParams) == 8); +typedef struct { + const SignalServerSecretParams* raw; +} SignalConstPointerServerSecretParams; +static_assert_64bit(offsetof(SignalConstPointerServerSecretParams, raw) == 0); +static_assert_64bit(sizeof(SignalConstPointerServerSecretParams) == 8); +static_assert_64bit(alignof(SignalConstPointerServerSecretParams) == 8); enum SignalFfiPublicKeyType { SignalFfiPublicKeyTypeECC, SignalFfiPublicKeyTypeKyber, }; typedef uint8_t SignalFfiPublicKeyType; - -enum SignalChallengeOption { - SignalChallengeOptionPushChallenge, - SignalChallengeOptionCaptcha, -}; -typedef uint8_t SignalChallengeOption; - -typedef enum { - SignalDirectionSending = 0, - SignalDirectionReceiving = 1, -} SignalDirection; - -typedef enum { - SignalCiphertextMessageTypeWhisper = 2, - SignalCiphertextMessageTypePreKey = 3, - SignalCiphertextMessageTypeSenderKey = 7, - SignalCiphertextMessageTypePlaintext = 8, -} SignalCiphertextMessageType; - -typedef enum { - SignalContentHintDefault = 0, - SignalContentHintResendable = 1, - SignalContentHintImplicit = 2, -} SignalContentHint; - -/** - * The result of saving a new identity key for a protocol address. - */ -typedef enum { - /** - * The protocol address didn't have an identity key or had the same key. - */ - SignalIdentityChangeNewOrUnchanged, - /** - * The new identity key replaced a different key for the protocol address. - */ - SignalIdentityChangeReplacedExisting, -} SignalIdentityChange; - +static_assert_64bit(sizeof(SignalFfiPublicKeyType) == 1); +static_assert_64bit(alignof(SignalFfiPublicKeyType) == 1); +typedef struct { + const int8_t* number; + const int8_t* push_token; + const int8_t* mcc; + const int8_t* mnc; +} SignalFfiRegistrationCreateSessionRequest; +static_assert_64bit(offsetof(SignalFfiRegistrationCreateSessionRequest, number) == 0); +static_assert_64bit(offsetof(SignalFfiRegistrationCreateSessionRequest, push_token) == 8); +static_assert_64bit(offsetof(SignalFfiRegistrationCreateSessionRequest, mcc) == 16); +static_assert_64bit(offsetof(SignalFfiRegistrationCreateSessionRequest, mnc) == 24); +static_assert_64bit(sizeof(SignalFfiRegistrationCreateSessionRequest) == 32); +static_assert_64bit(alignof(SignalFfiRegistrationCreateSessionRequest) == 8); +typedef struct { + uint32_t key_id; + SignalFfiPublicKeyType public_key_type; + const void* public_key; + SignalBorrowedBuffer signature; +} SignalFfiSignedPublicPreKey; +static_assert_64bit(offsetof(SignalFfiSignedPublicPreKey, key_id) == 0); +static_assert_64bit(offsetof(SignalFfiSignedPublicPreKey, public_key_type) == 4); +static_assert_64bit(offsetof(SignalFfiSignedPublicPreKey, public_key) == 8); +static_assert_64bit(offsetof(SignalFfiSignedPublicPreKey, signature) == 16); +static_assert_64bit(sizeof(SignalFfiSignedPublicPreKey) == 32); +static_assert_64bit(alignof(SignalFfiSignedPublicPreKey) == 8); +typedef struct { + bool present; + SignalBorrowedBuffer value; +} SignalOptionalBorrowedSliceOfc_uchar; +static_assert_64bit(offsetof(SignalOptionalBorrowedSliceOfc_uchar, present) == 0); +static_assert_64bit(offsetof(SignalOptionalBorrowedSliceOfc_uchar, value) == 8); +static_assert_64bit(sizeof(SignalOptionalBorrowedSliceOfc_uchar) == 24); +static_assert_64bit(alignof(SignalOptionalBorrowedSliceOfc_uchar) == 8); +typedef struct { + void* base; + size_t length; + size_t size_bytes; +} SignalOwnedBufferOfMaxAlignedc_void; +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedc_void, base) == 0); +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedc_void, length) == 8); +static_assert_64bit(offsetof(SignalOwnedBufferOfMaxAlignedc_void, size_bytes) == 16); +static_assert_64bit(sizeof(SignalOwnedBufferOfMaxAlignedc_void) == 24); +static_assert_64bit(alignof(SignalOwnedBufferOfMaxAlignedc_void) == 8); typedef enum { SignalErrorCodeUnknownError = 1, SignalErrorCodeInvalidState = 2, @@ -286,2962 +3025,3175 @@ typedef enum { SignalErrorCodeUsernameNotAvailable = 225, SignalErrorCodeUsernameNotSet = 226, } SignalErrorCode; - +static_assert_64bit(sizeof(SignalErrorCode) == 4); +static_assert_64bit(alignof(SignalErrorCode) == 4); +typedef enum { + SignalChallengeOptionPushChallenge, + SignalChallengeOptionCaptcha, +} SignalChallengeOption; +static_assert_64bit(sizeof(SignalChallengeOption) == 4); +static_assert_64bit(alignof(SignalChallengeOption) == 4); +typedef enum { + SignalIdentityChangeNewOrUnchanged, + SignalIdentityChangeReplacedExisting, +} SignalIdentityChange; +static_assert_64bit(sizeof(SignalIdentityChange) == 4); +static_assert_64bit(alignof(SignalIdentityChange) == 4); enum SignalSvr2CredentialsResult { SignalSvr2CredentialsResultMatch, SignalSvr2CredentialsResultNoMatch, SignalSvr2CredentialsResultInvalid, }; typedef uint8_t SignalSvr2CredentialsResult; - -typedef struct SignalAccountAttributes SignalAccountAttributes; - -/** - * A wrapper around [`ctr::Ctr32BE`] that uses a smaller nonce and supports an initial counter. - */ -typedef struct SignalAes256Ctr32 SignalAes256Ctr32; - -typedef struct SignalAes256GcmDecryption SignalAes256GcmDecryption; - -typedef struct SignalAes256GcmEncryption SignalAes256GcmEncryption; - -typedef struct SignalAes256GcmSiv SignalAes256GcmSiv; - -typedef struct SignalAuthenticatedChatConnection SignalAuthenticatedChatConnection; - -typedef struct SignalBackupRestoreResponse SignalBackupRestoreResponse; - -typedef struct SignalBackupStoreResponse SignalBackupStoreResponse; - -typedef struct SignalBridgedStringMap SignalBridgedStringMap; - -typedef struct SignalCdsiLookup SignalCdsiLookup; - -typedef struct SignalCiphertextMessage SignalCiphertextMessage; - -/** - * Information about an established connection. - */ -typedef struct SignalConnectionInfo SignalConnectionInfo; - -typedef struct SignalConnectionManager SignalConnectionManager; - -typedef struct SignalConnectionProxyConfig SignalConnectionProxyConfig; - -typedef struct SignalCopyBackupMediaStream SignalCopyBackupMediaStream; - -typedef struct SignalDecryptionErrorMessage SignalDecryptionErrorMessage; - -typedef struct SignalFingerprint SignalFingerprint; - -typedef struct SignalHsmEnclaveClient SignalHsmEnclaveClient; - -typedef struct SignalHttpRequest SignalHttpRequest; - -typedef struct SignalIncrementalMac SignalIncrementalMac; - -typedef struct SignalKeyPair SignalKeyPair; - -typedef struct SignalKeySecret SignalKeySecret; - -typedef struct SignalKyberPreKeyRecord SignalKyberPreKeyRecord; - -typedef struct SignalLookupRequest SignalLookupRequest; - -typedef struct SignalMessageBackupKey SignalMessageBackupKey; - -typedef struct SignalMessageBackupValidationOutcome SignalMessageBackupValidationOutcome; - -typedef struct SignalOnlineBackupValidator SignalOnlineBackupValidator; - -typedef struct SignalPinHash SignalPinHash; - -typedef struct SignalPlaintextContent SignalPlaintextContent; - -typedef struct SignalPreKeyBundle SignalPreKeyBundle; - -typedef struct SignalPreKeyRecord SignalPreKeyRecord; - -typedef struct SignalPreKeySignalMessage SignalPreKeySignalMessage; - -typedef struct SignalPrivateKey SignalPrivateKey; - -/** - * Represents a unique Signal client instance as `(, )` pair. - */ -typedef struct SignalProtocolAddress SignalProtocolAddress; - -typedef struct SignalProvisioningChatConnection SignalProvisioningChatConnection; - -typedef struct SignalPublicKey SignalPublicKey; - -typedef struct SignalRegisterAccountRequest SignalRegisterAccountRequest; - -typedef struct SignalRegisterAccountResponse SignalRegisterAccountResponse; - -typedef struct SignalRegistrationService SignalRegistrationService; - -typedef struct SignalRegistrationSession SignalRegistrationSession; - -typedef struct SignalSanitizedMetadata SignalSanitizedMetadata; - -typedef struct SignalSenderCertificate SignalSenderCertificate; - -typedef struct SignalSenderKeyDistributionMessage SignalSenderKeyDistributionMessage; - -typedef struct SignalSenderKeyMessage SignalSenderKeyMessage; - -typedef struct SignalSenderKeyRecord SignalSenderKeyRecord; - -typedef struct SignalServerCertificate SignalServerCertificate; - -/** - * Wraps a named type and a single-use guard around [`chat::server_requests::ResponseEnvelopeSender`]. - */ -typedef struct SignalServerMessageAck SignalServerMessageAck; - -typedef struct SignalServerPublicParams SignalServerPublicParams; - -typedef struct SignalServerSecretParams SignalServerSecretParams; - -typedef struct SignalSessionRecord SignalSessionRecord; - -typedef struct SignalSgxClientState SignalSgxClientState; - -/** - * The top-level error type (opaquely) returned to C clients when something goes wrong. - * - * Ideally this would use [ThinBox][], and then we wouldn't need an extra level of indirection when - * returning it to C, but unfortunately that isn't stable yet. - * - * [ThinBox]: https://doc.rust-lang.org/std/boxed/struct.ThinBox.html - */ -typedef struct SignalFfiError SignalFfiError; - -typedef struct SignalMessage SignalMessage; - -typedef struct SignalSignedPreKeyRecord SignalSignedPreKeyRecord; - -typedef struct SignalTokioAsyncContext SignalTokioAsyncContext; - -typedef struct SignalUnauthenticatedChatConnection SignalUnauthenticatedChatConnection; - -typedef struct SignalUnidentifiedSenderMessageContent SignalUnidentifiedSenderMessageContent; - -typedef struct SignalValidatingMac SignalValidatingMac; - -/** - * A type alias to be used with [`OwnedBufferOf`], so that `OwnedBufferOf` and - * `OwnedBufferOf<*const c_char>` get distinct names. - */ -typedef const char *SignalCStringPtr; - -typedef struct { - SignalProtocolAddress *raw; -} SignalMutPointerProtocolAddress; - -typedef struct { - const SignalProtocolAddress *raw; -} SignalConstPointerProtocolAddress; - -typedef struct { - SignalAes256Ctr32 *raw; -} SignalMutPointerAes256Ctr32; - -typedef struct { - const unsigned char *base; - size_t length; -} SignalBorrowedBuffer; - -typedef struct { - unsigned char *base; - size_t length; -} SignalBorrowedMutableBuffer; - -typedef struct { - SignalAes256GcmDecryption *raw; -} SignalMutPointerAes256GcmDecryption; - -/** - * A representation of a array allocated on the Rust heap for use in C code. - */ -typedef struct { - unsigned char *base; - /** - * The number of elements in the buffer (not necessarily the number of bytes). - */ - size_t length; -} SignalOwnedBuffer; - -typedef struct { - SignalAes256GcmEncryption *raw; -} SignalMutPointerAes256GcmEncryption; - -typedef struct { - const SignalAes256GcmSiv *raw; -} SignalConstPointerAes256GcmSiv; - -typedef struct { - SignalAes256GcmSiv *raw; -} SignalMutPointerAes256GcmSiv; - -typedef uint64_t SignalCancellationId; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const bool *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromisebool; - -typedef struct { - const SignalTokioAsyncContext *raw; -} SignalConstPointerTokioAsyncContext; - -typedef struct { - const SignalAuthenticatedChatConnection *raw; -} SignalConstPointerAuthenticatedChatConnection; - -typedef struct { - SignalAuthenticatedChatConnection *raw; -} SignalMutPointerAuthenticatedChatConnection; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalMutPointerAuthenticatedChatConnection *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseMutPointerAuthenticatedChatConnection; - -typedef struct { - const SignalConnectionManager *raw; -} SignalConstPointerConnectionManager; - -typedef struct { - const size_t *base; - size_t length; -} SignalBorrowedSliceOfusize; - -typedef struct { - SignalBorrowedBuffer bytes; - SignalBorrowedSliceOfusize lengths; -} SignalBorrowedBytestringArray; - -typedef struct { - uint8_t id; - SignalOwnedBuffer encrypted_name; - uint64_t last_seen; - uint16_t registration_id; - SignalOwnedBuffer created_at_ciphertext; -} SignalLinkedDeviceInternalFfiResult; - -/** - * A buffer of `length` elements of type `T`, allocated with the alignment of - * [`libc::max_align_t`]. - * - * The number of bytes allocated is stored in `size_bytes`. - * - * `base` should be allocated via Rust's global alloc (i.e. via [`std::alloc::alloc`]) - * - * # Motivation - * Rust's global allocator takes a size and alignment for _both_ allocation and deallocation. As a - * result, if we want to have a general "free this buffer" function, that function needs to be - * able to know the total size of the allocation and its alignment. Having a fixed (constant) - * alignment means we don't need to store the alignment in this struct (or have a separate free - * function for each type). - */ -typedef struct { - SignalLinkedDeviceInternalFfiResult *base; - size_t length; - size_t size_bytes; -} SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult; - -/** - * A representation of a array allocated on the Rust heap for use in C code. - */ -typedef struct { - SignalCStringPtr *base; - /** - * The number of elements in the buffer (not necessarily the number of bytes). - */ - size_t length; -} SignalOwnedBufferOfCStringPtr; - -typedef struct { - uint32_t cdn; - SignalCStringPtr key; - SignalOwnedBufferOfCStringPtr header_keys; - SignalOwnedBufferOfCStringPtr header_values; - SignalCStringPtr signed_upload_url; -} SignalFfiUploadForm; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalFfiUploadForm *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseFfiUploadForm; - -typedef SignalConnectionInfo SignalChatConnectionInfo; - -typedef struct { - SignalChatConnectionInfo *raw; -} SignalMutPointerChatConnectionInfo; - -typedef struct { - SignalServerMessageAck *raw; -} SignalMutPointerServerMessageAck; - -typedef int (*SignalFfiChatListenerReceivedIncomingMessage)(void *ctx, SignalOwnedBuffer envelope, uint64_t timestamp, SignalMutPointerServerMessageAck ack); - -typedef int (*SignalFfiChatListenerReceivedQueueEmpty)(void *ctx); - -/** - * A representation of a array allocated on the Rust heap for use in C code. - */ -typedef struct { - size_t *base; - /** - * The number of elements in the buffer (not necessarily the number of bytes). - */ - size_t length; -} SignalOwnedBufferOfusize; - -typedef struct { - SignalOwnedBuffer bytes; - SignalOwnedBufferOfusize lengths; -} SignalBytestringArray; - -typedef SignalBytestringArray SignalStringArray; - -typedef int (*SignalFfiChatListenerReceivedAlerts)(void *ctx, SignalStringArray alerts); - -typedef int (*SignalFfiChatListenerConnectionInterrupted)(void *ctx, SignalFfiError *disconnect_cause); - -typedef void (*SignalFfiChatListenerDestroy)(void *ctx); - -typedef struct { - void *ctx; - SignalFfiChatListenerReceivedIncomingMessage received_incoming_message; - SignalFfiChatListenerReceivedQueueEmpty received_queue_empty; - SignalFfiChatListenerReceivedAlerts received_alerts; - SignalFfiChatListenerConnectionInterrupted connection_interrupted; - SignalFfiChatListenerDestroy destroy; -} SignalFfiChatListenerStruct; - -typedef struct { - const SignalFfiChatListenerStruct *raw; -} SignalConstPointerFfiChatListenerStruct; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const uint8_t (*result)[32], const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseu832; - -typedef struct { - const uint8_t (*const *base)[32]; - size_t length; -} SignalBorrowedSliceOfu832; - -typedef struct { - uint16_t status; - const char *message; - SignalOwnedBufferOfCStringPtr headers; - SignalOwnedBuffer body; -} SignalFfiChatResponse; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalFfiChatResponse *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseFfiChatResponse; - -typedef struct { - const SignalHttpRequest *raw; -} SignalConstPointerHttpRequest; - -/** - * The fixed-width binary representation of a ServiceId. - * - * Rarely used. The variable-width format that privileges ACIs is preferred. - */ -typedef uint8_t SignalServiceIdFixedWidthBinaryBytes[17]; - -typedef struct { - const uint32_t *base; - size_t length; -} SignalBorrowedSliceOfu32; - -typedef struct { - const SignalCiphertextMessage *raw; -} SignalConstPointerCiphertextMessage; - -typedef struct { - const SignalConstPointerCiphertextMessage *base; - size_t length; -} SignalBorrowedSliceOfConstPointerCiphertextMessage; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalOwnedBuffer *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseOwnedBufferOfc_uchar; - -/** - * A wrapper type for raw UUIDs, because C treats arrays specially in argument position. - */ -typedef struct { - uint8_t bytes[16]; -} SignalUuid; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalUuid *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseUuid; - -typedef struct { - SignalPrivateKey *raw; -} SignalMutPointerPrivateKey; - -typedef struct { - SignalBackupRestoreResponse *raw; -} SignalMutPointerBackupRestoreResponse; - -typedef struct { - const SignalBackupRestoreResponse *raw; -} SignalConstPointerBackupRestoreResponse; - -typedef struct { - SignalBackupStoreResponse *raw; -} SignalMutPointerBackupStoreResponse; - -typedef struct { - const SignalBackupStoreResponse *raw; -} SignalConstPointerBackupStoreResponse; - -typedef struct { - SignalBridgedStringMap *raw; -} SignalMutPointerBridgedStringMap; - -typedef struct { - const SignalBridgedStringMap *raw; -} SignalConstPointerBridgedStringMap; - -typedef struct { - SignalSgxClientState *raw; -} SignalMutPointerSgxClientState; - -typedef struct { - /** - * Telephone number, as an unformatted e164. - */ - uint64_t e164; - uint8_t rawAciUuid[16]; - uint8_t rawPniUuid[16]; -} SignalFfiCdsiLookupResponseEntry; - -/** - * A representation of a array allocated on the Rust heap for use in C code. - */ -typedef struct { - SignalFfiCdsiLookupResponseEntry *base; - /** - * The number of elements in the buffer (not necessarily the number of bytes). - */ - size_t length; -} SignalOwnedBufferOfFfiCdsiLookupResponseEntry; - -typedef struct { - SignalOwnedBufferOfFfiCdsiLookupResponseEntry entries; - int32_t debug_permits_used; -} SignalFfiCdsiLookupResponse; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalFfiCdsiLookupResponse *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseFfiCdsiLookupResponse; - -typedef struct { - const SignalCdsiLookup *raw; -} SignalConstPointerCdsiLookup; - -typedef struct { - SignalCdsiLookup *raw; -} SignalMutPointerCdsiLookup; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalMutPointerCdsiLookup *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseMutPointerCdsiLookup; - -typedef struct { - const SignalLookupRequest *raw; -} SignalConstPointerLookupRequest; - -typedef struct { - const SignalChatConnectionInfo *raw; -} SignalConstPointerChatConnectionInfo; - -typedef struct { - SignalCiphertextMessage *raw; -} SignalMutPointerCiphertextMessage; - -typedef struct { - const SignalPlaintextContent *raw; -} SignalConstPointerPlaintextContent; - -typedef struct { - SignalConnectionInfo *raw; -} SignalMutPointerConnectionInfo; - -typedef struct { - SignalConnectionManager *raw; -} SignalMutPointerConnectionManager; - -typedef struct { - const SignalConnectionProxyConfig *raw; -} SignalConstPointerConnectionProxyConfig; - -typedef struct { - SignalConnectionProxyConfig *raw; -} SignalMutPointerConnectionProxyConfig; - -typedef struct { - const SignalCopyBackupMediaStream *raw; -} SignalConstPointerCopyBackupMediaStream; - -typedef struct { - SignalCopyBackupMediaStream *raw; -} SignalMutPointerCopyBackupMediaStream; - -typedef struct { - int32_t source_attachment_cdn; - SignalCStringPtr source_key; - int64_t object_length; - uint8_t media_id[SignalMEDIA_ID_LEN]; - uint8_t encryption_key[SignalMEDIA_ENCRYPTION_KEY_LEN]; -} SignalBridgeCopyBackupMediaItemFfiResult; - -/** - * A buffer of `length` elements of type `T`, allocated with the alignment of - * [`libc::max_align_t`]. - * - * The number of bytes allocated is stored in `size_bytes`. - * - * `base` should be allocated via Rust's global alloc (i.e. via [`std::alloc::alloc`]) - * - * # Motivation - * Rust's global allocator takes a size and alignment for _both_ allocation and deallocation. As a - * result, if we want to have a general "free this buffer" function, that function needs to be - * able to know the total size of the allocation and its alignment. Having a fixed (constant) - * alignment means we don't need to store the alignment in this struct (or have a separate free - * function for each type). - */ -typedef struct { - SignalBridgeCopyBackupMediaItemFfiResult *base; - size_t length; - size_t size_bytes; -} SignalOwnedBufferOfMaxAlignedBridgeCopyBackupMediaItemFfiResult; - +static_assert_64bit(sizeof(SignalSvr2CredentialsResult) == 1); +static_assert_64bit(alignof(SignalSvr2CredentialsResult) == 1); typedef enum { - SignalBridgeCopyBackupMediaResultFfiResultSuccess, - SignalBridgeCopyBackupMediaResultFfiResultSourceNotFound, - SignalBridgeCopyBackupMediaResultFfiResultWrongSourceLength, - SignalBridgeCopyBackupMediaResultFfiResultOutOfSpace, -} SignalBridgeCopyBackupMediaResultFfiResult_Tag; - + SignalCiphertextMessageTypeWhisper = 2, + SignalCiphertextMessageTypePreKey = 3, + SignalCiphertextMessageTypeSenderKey = 7, + SignalCiphertextMessageTypePlaintext = 8, +} SignalCiphertextMessageType; +static_assert_64bit(sizeof(SignalCiphertextMessageType) == 4); +static_assert_64bit(alignof(SignalCiphertextMessageType) == 4); +typedef enum { + SignalContentHintDefault, + SignalContentHintResendable, + SignalContentHintImplicit, +} SignalContentHint; +static_assert_64bit(sizeof(SignalContentHint) == 4); +static_assert_64bit(alignof(SignalContentHint) == 4); +typedef enum { + SignalDirectionSending, + SignalDirectionReceiving, +} SignalDirection; +static_assert_64bit(sizeof(SignalDirection) == 4); +static_assert_64bit(alignof(SignalDirection) == 4); typedef struct { - int32_t cdn; -} SignalBridgeCopyBackupMediaResultFfiResultSignalSuccess_Body; - -typedef struct { - SignalBridgeCopyBackupMediaResultFfiResult_Tag tag; - union { - SignalBridgeCopyBackupMediaResultFfiResultSignalSuccess_Body success; - }; -} SignalBridgeCopyBackupMediaResultFfiResult; - -typedef struct { - uint8_t media_id[SignalMEDIA_ID_LEN]; - SignalBridgeCopyBackupMediaResultFfiResult result; -} SignalBridgeCopyBackupMediaOutcomeFfiResult; - -/** - * A buffer of `length` elements of type `T`, allocated with the alignment of - * [`libc::max_align_t`]. - * - * The number of bytes allocated is stored in `size_bytes`. - * - * `base` should be allocated via Rust's global alloc (i.e. via [`std::alloc::alloc`]) - * - * # Motivation - * Rust's global allocator takes a size and alignment for _both_ allocation and deallocation. As a - * result, if we want to have a general "free this buffer" function, that function needs to be - * able to know the total size of the allocation and its alignment. Having a fixed (constant) - * alignment means we don't need to store the alignment in this struct (or have a separate free - * function for each type). - */ -typedef struct { - SignalBridgeCopyBackupMediaOutcomeFfiResult *base; - size_t length; - size_t size_bytes; -} SignalOwnedBufferOfMaxAlignedBridgeCopyBackupMediaOutcomeFfiResult; - -/** - * A low-level three-state enum: 0 (still going), `MAP_FAILED` (finished), or a valid pointer - * (error). - * - * `MAP_FAILED` was chosen because it's an existing C pointer sentinel value, even though it won't - * be aligned to match `SignalFfiError`. This is fine as long as we don't try to load from it - * (which wouldn't work anyway) or convert it to a reference. - */ -typedef struct { - SignalFfiError *raw; -} SignalFfiBulkPolledStreamTerminationReason; - -typedef struct { - SignalOwnedBufferOfMaxAlignedBridgeCopyBackupMediaOutcomeFfiResult chunk; - SignalFfiBulkPolledStreamTerminationReason termination; -} SignalCopyBackupMediaNextChunkFfiResult; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalCopyBackupMediaNextChunkFfiResult *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseCopyBackupMediaNextChunkFfiResult; - -typedef struct { - const SignalMessage *raw; -} SignalConstPointerSignalMessage; - -typedef struct { - SignalSessionRecord *raw; -} SignalMutPointerSessionRecord; - -typedef int (*SignalFfiSessionStoreLoadSession)(void *ctx, SignalMutPointerSessionRecord *out, SignalMutPointerProtocolAddress address); - -typedef int (*SignalFfiSessionStoreStoreSession)(void *ctx, SignalMutPointerProtocolAddress address, SignalMutPointerSessionRecord record); - -typedef void (*SignalFfiSessionStoreDestroy)(void *ctx); - -typedef struct { - void *ctx; - SignalFfiSessionStoreLoadSession load_session; - SignalFfiSessionStoreStoreSession store_session; - SignalFfiSessionStoreDestroy destroy; -} SignalSessionStore; - -typedef struct { - const SignalSessionStore *raw; -} SignalConstPointerFfiSessionStoreStruct; - -typedef struct { - SignalPublicKey *raw; -} SignalMutPointerPublicKey; - -typedef struct { - SignalMutPointerPrivateKey first; - SignalMutPointerPublicKey second; -} SignalPairOfMutPointerPrivateKeyMutPointerPublicKey; - -typedef int (*SignalFfiIdentityKeyStoreGetLocalIdentityKeyPair)(void *ctx, SignalPairOfMutPointerPrivateKeyMutPointerPublicKey *out); - -typedef int (*SignalFfiIdentityKeyStoreGetLocalRegistrationId)(void *ctx, uint32_t *out); - -typedef int (*SignalFfiIdentityKeyStoreGetIdentityKey)(void *ctx, SignalMutPointerPublicKey *out, SignalMutPointerProtocolAddress address); - -typedef int (*SignalFfiIdentityKeyStoreSaveIdentityKey)(void *ctx, uint8_t *out, SignalMutPointerProtocolAddress address, SignalMutPointerPublicKey public_key); - -typedef int (*SignalFfiIdentityKeyStoreIsTrustedIdentity)(void *ctx, bool *out, SignalMutPointerProtocolAddress address, SignalMutPointerPublicKey public_key, uint32_t direction); - -typedef void (*SignalFfiIdentityKeyStoreDestroy)(void *ctx); - -typedef struct { - void *ctx; - SignalFfiIdentityKeyStoreGetLocalIdentityKeyPair get_local_identity_key_pair; - SignalFfiIdentityKeyStoreGetLocalRegistrationId get_local_registration_id; - SignalFfiIdentityKeyStoreGetIdentityKey get_identity_key; - SignalFfiIdentityKeyStoreSaveIdentityKey save_identity_key; - SignalFfiIdentityKeyStoreIsTrustedIdentity is_trusted_identity; - SignalFfiIdentityKeyStoreDestroy destroy; -} SignalIdentityKeyStore; - -typedef struct { - const SignalIdentityKeyStore *raw; -} SignalConstPointerFfiIdentityKeyStoreStruct; - -typedef struct { - const SignalPreKeySignalMessage *raw; -} SignalConstPointerPreKeySignalMessage; - -typedef struct { - SignalPreKeyRecord *raw; -} SignalMutPointerPreKeyRecord; - -typedef int (*SignalFfiPreKeyStoreLoadPreKey)(void *ctx, SignalMutPointerPreKeyRecord *out, uint32_t id); - -typedef int (*SignalFfiPreKeyStoreStorePreKey)(void *ctx, uint32_t id, SignalMutPointerPreKeyRecord record); - -typedef int (*SignalFfiPreKeyStoreRemovePreKey)(void *ctx, uint32_t id); - -typedef void (*SignalFfiPreKeyStoreDestroy)(void *ctx); - -typedef struct { - void *ctx; - SignalFfiPreKeyStoreLoadPreKey load_pre_key; - SignalFfiPreKeyStoreStorePreKey store_pre_key; - SignalFfiPreKeyStoreRemovePreKey remove_pre_key; - SignalFfiPreKeyStoreDestroy destroy; -} SignalPreKeyStore; - -typedef struct { - const SignalPreKeyStore *raw; -} SignalConstPointerFfiPreKeyStoreStruct; - -typedef struct { - SignalSignedPreKeyRecord *raw; -} SignalMutPointerSignedPreKeyRecord; - -typedef int (*SignalFfiSignedPreKeyStoreLoadSignedPreKey)(void *ctx, SignalMutPointerSignedPreKeyRecord *out, uint32_t id); - -typedef int (*SignalFfiSignedPreKeyStoreStoreSignedPreKey)(void *ctx, uint32_t id, SignalMutPointerSignedPreKeyRecord record); - -typedef void (*SignalFfiSignedPreKeyStoreDestroy)(void *ctx); - -typedef struct { - void *ctx; - SignalFfiSignedPreKeyStoreLoadSignedPreKey load_signed_pre_key; - SignalFfiSignedPreKeyStoreStoreSignedPreKey store_signed_pre_key; - SignalFfiSignedPreKeyStoreDestroy destroy; -} SignalSignedPreKeyStore; - -typedef struct { - const SignalSignedPreKeyStore *raw; -} SignalConstPointerFfiSignedPreKeyStoreStruct; - -typedef struct { - SignalKyberPreKeyRecord *raw; -} SignalMutPointerKyberPreKeyRecord; - -typedef int (*SignalFfiKyberPreKeyStoreLoadKyberPreKey)(void *ctx, SignalMutPointerKyberPreKeyRecord *out, uint32_t id); - -typedef int (*SignalFfiKyberPreKeyStoreStoreKyberPreKey)(void *ctx, uint32_t id, SignalMutPointerKyberPreKeyRecord record); - -typedef int (*SignalFfiKyberPreKeyStoreMarkKyberPreKeyUsed)(void *ctx, uint32_t id, uint32_t ec_prekey_id, SignalMutPointerPublicKey base_key); - -typedef void (*SignalFfiKyberPreKeyStoreDestroy)(void *ctx); - -typedef struct { - void *ctx; - SignalFfiKyberPreKeyStoreLoadKyberPreKey load_kyber_pre_key; - SignalFfiKyberPreKeyStoreStoreKyberPreKey store_kyber_pre_key; - SignalFfiKyberPreKeyStoreMarkKyberPreKeyUsed mark_kyber_pre_key_used; - SignalFfiKyberPreKeyStoreDestroy destroy; -} SignalKyberPreKeyStore; - -typedef struct { - const SignalKyberPreKeyStore *raw; -} SignalConstPointerFfiKyberPreKeyStoreStruct; - -typedef struct { - SignalDecryptionErrorMessage *raw; -} SignalMutPointerDecryptionErrorMessage; - -typedef struct { - const SignalDecryptionErrorMessage *raw; -} SignalConstPointerDecryptionErrorMessage; - -typedef struct { - const SignalServerSecretParams *raw; -} SignalConstPointerServerSecretParams; - -typedef struct { - const SignalServerPublicParams *raw; -} SignalConstPointerServerPublicParams; - -typedef struct { - SignalCStringPtr first; - uint32_t second; -} SignalPairOfCStringPtru32; - -/** - * A representation of a array allocated on the Rust heap for use in C code. - */ -typedef struct { - uint32_t *base; - /** - * The number of elements in the buffer (not necessarily the number of bytes). - */ - size_t length; -} SignalOwnedBufferOfu32; - -typedef struct { - SignalServiceIdFixedWidthBinaryBytes account; - SignalOwnedBufferOfu32 missing_devices; - SignalOwnedBufferOfu32 extra_devices; - SignalOwnedBufferOfu32 stale_devices; -} SignalFfiMismatchedDevicesError; - -/** - * A representation of a array allocated on the Rust heap for use in C code. - */ -typedef struct { - SignalFfiMismatchedDevicesError *base; - /** - * The number of elements in the buffer (not necessarily the number of bytes). - */ - size_t length; -} SignalOwnedBufferOfFfiMismatchedDevicesError; - -typedef struct { - SignalCStringPtr first; - SignalOwnedBuffer second; -} SignalPairOfCStringPtrOwnedBufferOfc_uchar; - -typedef struct { - SignalPairOfCStringPtrOwnedBufferOfc_uchar first; - int64_t second; -} SignalPairOfPairOfCStringPtrOwnedBufferOfc_uchari64; - -typedef struct { - SignalCStringPtr first; - bool second; -} SignalPairOfCStringPtrbool; - -typedef struct { - SignalFingerprint *raw; -} SignalMutPointerFingerprint; - -typedef struct { - const SignalFingerprint *raw; -} SignalConstPointerFingerprint; - -typedef struct { - const SignalPublicKey *raw; -} SignalConstPointerPublicKey; - -typedef struct { - /** - * The badge ID. - */ - const char *id; - /** - * Whether the badge is currently configured to be visible. - */ - bool visible; - /** - * When the badge expires. - */ - double expiration_secs; -} SignalFfiRegisterResponseBadge; - -/** - * A representation of a array allocated on the Rust heap for use in C code. - */ -typedef struct { - SignalFfiRegisterResponseBadge *base; - /** - * The number of elements in the buffer (not necessarily the number of bytes). - */ - size_t length; -} SignalOwnedBufferOfFfiRegisterResponseBadge; - -/** - * A representation of a array allocated on the Rust heap for use in C code. - */ -typedef struct { - SignalServiceIdFixedWidthBinaryBytes *base; - /** - * The number of elements in the buffer (not necessarily the number of bytes). - */ - size_t length; -} SignalOwnedBufferOfServiceIdFixedWidthBinaryBytes; - -typedef struct { - SignalPreKeyBundle *raw; -} SignalMutPointerPreKeyBundle; - -/** - * A representation of a array allocated on the Rust heap for use in C code. - */ -typedef struct { - SignalMutPointerPreKeyBundle *base; - /** - * The number of elements in the buffer (not necessarily the number of bytes). - */ - size_t length; -} SignalOwnedBufferOfMutPointerPreKeyBundle; - -/** - * A buffer of `length` elements of type `T`, allocated with the alignment of - * [`libc::max_align_t`]. - * - * The number of bytes allocated is stored in `size_bytes`. - * - * `base` should be allocated via Rust's global alloc (i.e. via [`std::alloc::alloc`]) - * - * # Motivation - * Rust's global allocator takes a size and alignment for _both_ allocation and deallocation. As a - * result, if we want to have a general "free this buffer" function, that function needs to be - * able to know the total size of the allocation and its alignment. Having a fixed (constant) - * alignment means we don't need to store the alignment in this struct (or have a separate free - * function for each type). - */ -typedef struct { - void *base; - size_t length; - size_t size_bytes; -} SignalOwnedBufferOfMaxAlignedc_void; - -typedef struct { - SignalSenderKeyRecord *raw; -} SignalMutPointerSenderKeyRecord; - -typedef int (*SignalFfiSenderKeyStoreLoadSenderKey)(void *ctx, SignalMutPointerSenderKeyRecord *out, SignalMutPointerProtocolAddress sender, SignalUuid distribution_id); - -typedef int (*SignalFfiSenderKeyStoreStoreSenderKey)(void *ctx, SignalMutPointerProtocolAddress sender, SignalUuid distribution_id, SignalMutPointerSenderKeyRecord record); - -typedef void (*SignalFfiSenderKeyStoreDestroy)(void *ctx); - -typedef struct { - void *ctx; - SignalFfiSenderKeyStoreLoadSenderKey load_sender_key; - SignalFfiSenderKeyStoreStoreSenderKey store_sender_key; - SignalFfiSenderKeyStoreDestroy destroy; -} SignalSenderKeyStore; - -typedef struct { - const SignalSenderKeyStore *raw; -} SignalConstPointerFfiSenderKeyStoreStruct; - -typedef struct { - const SignalBorrowedBuffer *base; - size_t length; -} SignalBorrowedSliceOfBuffers; - -typedef struct { - SignalHsmEnclaveClient *raw; -} SignalMutPointerHsmEnclaveClient; - -typedef struct { - const SignalHsmEnclaveClient *raw; -} SignalConstPointerHsmEnclaveClient; - -typedef struct { - SignalHttpRequest *raw; -} SignalMutPointerHttpRequest; - -typedef struct { - SignalMutPointerPublicKey first; - SignalMutPointerPrivateKey second; -} SignalPairOfMutPointerPublicKeyMutPointerPrivateKey; - -typedef struct { - const SignalPrivateKey *raw; -} SignalConstPointerPrivateKey; - -typedef struct { - SignalIncrementalMac *raw; -} SignalMutPointerIncrementalMac; - -typedef int (*SignalFfiLoggerLog)(void *ctx, SignalLogLevel level, SignalCStringPtr file, uint32_t line, SignalCStringPtr message); - -typedef int (*SignalFfiLoggerFlush)(void *ctx); - -typedef void (*SignalFfiLoggerDestroy)(void *ctx); - -typedef struct { - void *ctx; - SignalFfiLoggerLog log; - SignalFfiLoggerFlush flush; - SignalFfiLoggerDestroy destroy; + void* ctx; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalLogLevel_SignalCStringPtr_uint32_t_SignalCStringPtr log; + SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void flush; + SignalType_FunctionPointer_void_SignalType_MutPointer_void destroy; } SignalFfiLoggerStruct; - -typedef struct { - SignalOwnedBuffer first; - SignalOwnedBuffer second; -} SignalPairOfOwnedBufferOfc_ucharOwnedBufferOfc_uchar; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalPairOfOwnedBufferOfc_ucharOwnedBufferOfc_uchar *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromisePairOfOwnedBufferOfc_ucharOwnedBufferOfc_uchar; - -typedef struct { - const SignalUnauthenticatedChatConnection *raw; -} SignalConstPointerUnauthenticatedChatConnection; - -typedef struct { - bool present; - SignalBorrowedBuffer value; -} SignalOptionalBorrowedSliceOfc_uchar; - -typedef SignalKeyPair SignalKyberKeyPair; - -typedef struct { - SignalKyberKeyPair *raw; -} SignalMutPointerKyberKeyPair; - -typedef struct { - const SignalKyberKeyPair *raw; -} SignalConstPointerKyberKeyPair; - -typedef SignalPublicKey SignalKyberPublicKey; - -typedef struct { - SignalKyberPublicKey *raw; -} SignalMutPointerKyberPublicKey; - -/** - * A KEM secret key with the ability to decapsulate a shared secret. - */ -typedef SignalKeySecret SignalSecretKey; - -typedef SignalSecretKey SignalKyberSecretKey; - -typedef struct { - SignalKyberSecretKey *raw; -} SignalMutPointerKyberSecretKey; - -typedef struct { - const SignalKyberPreKeyRecord *raw; -} SignalConstPointerKyberPreKeyRecord; - -typedef struct { - const SignalKyberPublicKey *raw; -} SignalConstPointerKyberPublicKey; - -typedef struct { - const SignalKyberSecretKey *raw; -} SignalConstPointerKyberSecretKey; - -typedef struct { - SignalLookupRequest *raw; -} SignalMutPointerLookupRequest; - -typedef struct { - SignalMessageBackupKey *raw; -} SignalMutPointerMessageBackupKey; - -typedef struct { - const SignalMessageBackupKey *raw; -} SignalConstPointerMessageBackupKey; - -typedef struct { - SignalMessageBackupValidationOutcome *raw; -} SignalMutPointerMessageBackupValidationOutcome; - -typedef struct { - const SignalMessageBackupValidationOutcome *raw; -} SignalConstPointerMessageBackupValidationOutcome; - -typedef int (*SignalFfiSyncInputStreamRead)(void *ctx, size_t *out, SignalBorrowedMutableBuffer buf); - -typedef int (*SignalFfiSyncInputStreamSkip)(void *ctx, uint64_t amount); - -typedef void (*SignalFfiSyncInputStreamDestroy)(void *ctx); - -typedef struct { - void *ctx; - SignalFfiSyncInputStreamRead read; - SignalFfiSyncInputStreamSkip skip; - SignalFfiSyncInputStreamDestroy destroy; -} SignalSyncInputStream; - -typedef SignalSyncInputStream SignalInputStream; - -typedef struct { - const SignalInputStream *raw; -} SignalConstPointerFfiInputStreamStruct; - -typedef struct { - SignalMessage *raw; -} SignalMutPointerSignalMessage; - -typedef struct { - SignalSanitizedMetadata *raw; -} SignalMutPointerSanitizedMetadata; - -typedef struct { - SignalOnlineBackupValidator *raw; -} SignalMutPointerOnlineBackupValidator; - -typedef struct { - const SignalPinHash *raw; -} SignalConstPointerPinHash; - -typedef struct { - SignalPinHash *raw; -} SignalMutPointerPinHash; - -typedef struct { - SignalPlaintextContent *raw; -} SignalMutPointerPlaintextContent; - -typedef struct { - const SignalPreKeyBundle *raw; -} SignalConstPointerPreKeyBundle; - -typedef struct { - const SignalPreKeyRecord *raw; -} SignalConstPointerPreKeyRecord; - -typedef struct { - SignalPreKeySignalMessage *raw; -} SignalMutPointerPreKeySignalMessage; - -typedef struct { - const SignalSenderKeyDistributionMessage *raw; -} SignalConstPointerSenderKeyDistributionMessage; - -typedef struct { - SignalProvisioningChatConnection *raw; -} SignalMutPointerProvisioningChatConnection; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalMutPointerProvisioningChatConnection *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseMutPointerProvisioningChatConnection; - -typedef struct { - const SignalProvisioningChatConnection *raw; -} SignalConstPointerProvisioningChatConnection; - -typedef int (*SignalFfiProvisioningListenerReceivedAddress)(void *ctx, SignalCStringPtr address, SignalMutPointerServerMessageAck send_ack); - -typedef int (*SignalFfiProvisioningListenerReceivedEnvelope)(void *ctx, SignalOwnedBuffer envelope, SignalMutPointerServerMessageAck send_ack); - -typedef int (*SignalFfiProvisioningListenerConnectionInterrupted)(void *ctx, SignalFfiError *disconnect_cause); - -typedef void (*SignalFfiProvisioningListenerDestroy)(void *ctx); - -typedef struct { - void *ctx; - SignalFfiProvisioningListenerReceivedAddress received_address; - SignalFfiProvisioningListenerReceivedEnvelope received_envelope; - SignalFfiProvisioningListenerConnectionInterrupted connection_interrupted; - SignalFfiProvisioningListenerDestroy destroy; -} SignalFfiProvisioningListenerStruct; - -typedef struct { - const SignalFfiProvisioningListenerStruct *raw; -} SignalConstPointerFfiProvisioningListenerStruct; - -typedef struct { - SignalRegisterAccountRequest *raw; -} SignalMutPointerRegisterAccountRequest; - -typedef struct { - const SignalRegisterAccountRequest *raw; -} SignalConstPointerRegisterAccountRequest; - -typedef struct { - uint32_t key_id; - SignalFfiPublicKeyType public_key_type; - const void *public_key; - SignalBorrowedBuffer signature; -} SignalFfiSignedPublicPreKey; - -typedef struct { - SignalRegisterAccountResponse *raw; -} SignalMutPointerRegisterAccountResponse; - -typedef struct { - const SignalRegisterAccountResponse *raw; -} SignalConstPointerRegisterAccountResponse; - -typedef struct { - bool present; - uint8_t bytes[16]; -} SignalOptionalUuid; - -typedef SignalAccountAttributes SignalRegistrationAccountAttributes; - -typedef struct { - SignalRegistrationAccountAttributes *raw; -} SignalMutPointerRegistrationAccountAttributes; - -typedef struct { - /** - * Bridged as a string of bytes, but each entry is a UTF-8 `String` key - * concatenated with a byte for the value. - */ - SignalBytestringArray entries; -} SignalFfiCheckSvr2CredentialsResponse; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalFfiCheckSvr2CredentialsResponse *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseFfiCheckSvr2CredentialsResponse; - -typedef struct { - const SignalRegistrationService *raw; -} SignalConstPointerRegistrationService; - -typedef struct { - SignalRegistrationService *raw; -} SignalMutPointerRegistrationService; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalMutPointerRegistrationService *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseMutPointerRegistrationService; - -typedef struct { - const char *number; - const char *push_token; - const char *mcc; - const char *mnc; -} SignalFfiRegistrationCreateSessionRequest; - -typedef const SignalConnectionManager *(*SignalGetConnectChatConnectionManager)(void *ctx); - -typedef void (*SignalDestroyConnectChatBridge)(void *ctx); - -/** - * A ref-counting pointer to a [`ConnectionManager`] and a callback to - * decrement the count. - */ -typedef struct { - void *ctx; - SignalGetConnectChatConnectionManager get_connection_manager; - SignalDestroyConnectChatBridge destroy; -} SignalFfiConnectChatBridgeStruct; - -typedef struct { - const SignalFfiConnectChatBridgeStruct *raw; -} SignalConstPointerFfiConnectChatBridgeStruct; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalMutPointerRegisterAccountResponse *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseMutPointerRegisterAccountResponse; - -typedef struct { - const SignalRegistrationAccountAttributes *raw; -} SignalConstPointerRegistrationAccountAttributes; - -typedef struct { - SignalRegistrationSession *raw; -} SignalMutPointerRegistrationSession; - -typedef struct { - const SignalRegistrationSession *raw; -} SignalConstPointerRegistrationSession; - -typedef struct { - const SignalSanitizedMetadata *raw; -} SignalConstPointerSanitizedMetadata; - -typedef struct { - const SignalConstPointerProtocolAddress *base; - size_t length; -} SignalBorrowedSliceOfConstPointerProtocolAddress; - -typedef struct { - const SignalSessionRecord *raw; -} SignalConstPointerSessionRecord; - -typedef struct { - const SignalConstPointerSessionRecord *base; - size_t length; -} SignalBorrowedSliceOfConstPointerSessionRecord; - -typedef struct { - const SignalUnidentifiedSenderMessageContent *raw; -} SignalConstPointerUnidentifiedSenderMessageContent; - -typedef struct { - SignalUnidentifiedSenderMessageContent *raw; -} SignalMutPointerUnidentifiedSenderMessageContent; - -typedef uint8_t SignalBackupKeyBytes[SignalBACKUP_KEY_LEN]; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalMutPointerBackupRestoreResponse *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseMutPointerBackupRestoreResponse; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalMutPointerBackupStoreResponse *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseMutPointerBackupStoreResponse; - -typedef struct { - SignalSenderCertificate *raw; -} SignalMutPointerSenderCertificate; - -typedef struct { - const SignalSenderCertificate *raw; -} SignalConstPointerSenderCertificate; - -typedef struct { - SignalServerCertificate *raw; -} SignalMutPointerServerCertificate; - -typedef struct { - const SignalServerCertificate *raw; -} SignalConstPointerServerCertificate; - -typedef struct { - const SignalConstPointerPublicKey *base; - size_t length; -} SignalBorrowedSliceOfConstPointerPublicKey; - -typedef struct { - SignalSenderKeyDistributionMessage *raw; -} SignalMutPointerSenderKeyDistributionMessage; - -typedef struct { - SignalSenderKeyMessage *raw; -} SignalMutPointerSenderKeyMessage; - -typedef struct { - const SignalSenderKeyMessage *raw; -} SignalConstPointerSenderKeyMessage; - -typedef struct { - const SignalSenderKeyRecord *raw; -} SignalConstPointerSenderKeyRecord; - -typedef struct { - const SignalServerMessageAck *raw; -} SignalConstPointerServerMessageAck; - -typedef struct { - SignalServerPublicParams *raw; -} SignalMutPointerServerPublicParams; - -typedef struct { - SignalServerSecretParams *raw; -} SignalMutPointerServerSecretParams; - -typedef struct { - const SignalSgxClientState *raw; -} SignalConstPointerSgxClientState; - -typedef struct { - const SignalSignedPreKeyRecord *raw; -} SignalConstPointerSignedPreKeyRecord; - -typedef struct { - SignalTokioAsyncContext *raw; -} SignalMutPointerTokioAsyncContext; - -typedef struct { - int32_t source_attachment_cdn; - SignalCStringPtr source_key; - int64_t object_length; - const uint8_t (*media_id)[SignalMEDIA_ID_LEN]; - const uint8_t (*encryption_key)[SignalMEDIA_ENCRYPTION_KEY_LEN]; -} SignalBridgeCopyBackupMediaItemFfiArg; - -typedef struct { - const SignalBridgeCopyBackupMediaItemFfiArg *base; - size_t length; -} SignalBorrowedSliceOfBridgeCopyBackupMediaItemFfiArg; - -typedef struct { - SignalOwnedBufferOfCStringPtr first; - SignalOwnedBufferOfCStringPtr second; -} SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalPairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromisePairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr; - -typedef struct { - SignalCStringPtr first; - SignalCStringPtr second; -} SignalPairOfCStringPtrCStringPtr; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalPairOfCStringPtrCStringPtr *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromisePairOfCStringPtrCStringPtr; - -typedef struct { - SignalUnauthenticatedChatConnection *raw; -} SignalMutPointerUnauthenticatedChatConnection; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalMutPointerUnauthenticatedChatConnection *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseMutPointerUnauthenticatedChatConnection; - -typedef struct { - SignalMutPointerPublicKey identity_key; - SignalOwnedBufferOfMutPointerPreKeyBundle pre_key_bundles; -} SignalFfiPreKeysResponse; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalFfiPreKeysResponse *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseFfiPreKeysResponse; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalOptionalUuid *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseOptionalUuid; - -typedef struct { - bool present; - SignalCStringPtr first; - uint8_t second[32]; -} SignalOptionalPairOfCStringPtru832; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalOptionalPairOfCStringPtru832 *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseOptionalPairOfCStringPtru832; - -/** - * A C callback used to report the results of Rust futures. - * - * cbindgen will produce independent C types like `SignalCPromisei32` and - * `SignalCPromiseProtocolAddress`. - * - * This derives Copy because it behaves like a C type; nevertheless, a promise should still only be - * completed once. - */ -typedef struct { - void (*complete)(SignalFfiError *error, const SignalOwnedBufferOfServiceIdFixedWidthBinaryBytes *result, const void *context); - const void *context; - SignalCancellationId cancellation_id; -} SignalCPromiseOwnedBufferOfServiceIdFixedWidthBinaryBytes; - -typedef struct { - SignalValidatingMac *raw; -} SignalMutPointerValidatingMac; - -typedef struct { - const SignalSyncInputStream *raw; -} SignalConstPointerFfiSyncInputStreamStruct; - -typedef uint8_t SignalRandomnessBytes[SignalRANDOMNESS_LEN]; - -typedef uint8_t SignalUnidentifiedAccessKey[SignalACCESS_KEY_LEN]; - - - -SignalFfiError *signal_account_entropy_pool_derive_backup_key(uint8_t (*out)[SignalBACKUP_KEY_LEN], const char *account_entropy); - -SignalFfiError *signal_account_entropy_pool_derive_svr_key(uint8_t (*out)[SignalSVR_KEY_LEN], const char *account_entropy); - -SignalFfiError *signal_account_entropy_pool_generate(SignalCStringPtr *out); - -SignalFfiError *signal_account_entropy_pool_is_valid(bool *out, SignalCStringPtr account_entropy); - -SignalFfiError *signal_address_clone(SignalMutPointerProtocolAddress *new_obj, SignalConstPointerProtocolAddress obj); - -SignalFfiError *signal_address_destroy(SignalMutPointerProtocolAddress p); - -SignalFfiError *signal_address_get_device_id(uint32_t *out, SignalConstPointerProtocolAddress obj); - -SignalFfiError *signal_address_get_name(SignalCStringPtr *out, SignalConstPointerProtocolAddress obj); - -SignalFfiError *signal_address_new(SignalMutPointerProtocolAddress *out, SignalCStringPtr name, uint32_t device_id); - -SignalFfiError *signal_aes256_ctr32_destroy(SignalMutPointerAes256Ctr32 p); - -SignalFfiError *signal_aes256_ctr32_new(SignalMutPointerAes256Ctr32 *out, SignalBorrowedBuffer key, SignalBorrowedBuffer nonce, uint32_t initial_ctr); - -SignalFfiError *signal_aes256_ctr32_process(SignalMutPointerAes256Ctr32 ctr, SignalBorrowedMutableBuffer data, uint32_t offset, uint32_t length); - -SignalFfiError *signal_aes256_gcm_decryption_destroy(SignalMutPointerAes256GcmDecryption p); - -SignalFfiError *signal_aes256_gcm_decryption_new(SignalMutPointerAes256GcmDecryption *out, SignalBorrowedBuffer key, SignalBorrowedBuffer nonce, SignalBorrowedBuffer associated_data); - -SignalFfiError *signal_aes256_gcm_decryption_update(SignalMutPointerAes256GcmDecryption gcm, SignalBorrowedMutableBuffer data, uint32_t offset, uint32_t length); - -SignalFfiError *signal_aes256_gcm_decryption_verify_tag(bool *out, SignalMutPointerAes256GcmDecryption gcm, SignalBorrowedBuffer tag); - -SignalFfiError *signal_aes256_gcm_encryption_compute_tag(SignalOwnedBuffer *out, SignalMutPointerAes256GcmEncryption gcm); - -SignalFfiError *signal_aes256_gcm_encryption_destroy(SignalMutPointerAes256GcmEncryption p); - -SignalFfiError *signal_aes256_gcm_encryption_new(SignalMutPointerAes256GcmEncryption *out, SignalBorrowedBuffer key, SignalBorrowedBuffer nonce, SignalBorrowedBuffer associated_data); - -SignalFfiError *signal_aes256_gcm_encryption_update(SignalMutPointerAes256GcmEncryption gcm, SignalBorrowedMutableBuffer data, uint32_t offset, uint32_t length); - -SignalFfiError *signal_aes256_gcm_siv_decrypt(SignalOwnedBuffer *out, SignalConstPointerAes256GcmSiv aes_gcm_siv, SignalBorrowedBuffer ctext, SignalBorrowedBuffer nonce, SignalBorrowedBuffer associated_data); - -SignalFfiError *signal_aes256_gcm_siv_destroy(SignalMutPointerAes256GcmSiv p); - -SignalFfiError *signal_aes256_gcm_siv_encrypt(SignalOwnedBuffer *out, SignalConstPointerAes256GcmSiv aes_gcm_siv_obj, SignalBorrowedBuffer ptext, SignalBorrowedBuffer nonce, SignalBorrowedBuffer associated_data); - -SignalFfiError *signal_aes256_gcm_siv_new(SignalMutPointerAes256GcmSiv *out, SignalBorrowedBuffer key); - -SignalFfiError *signal_auth_credential_presentation_check_valid_contents(SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_auth_credential_presentation_get_pni_ciphertext(unsigned char (*out)[SignalUUID_CIPHERTEXT_LEN], SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_auth_credential_presentation_get_redemption_time(uint64_t *out, SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_auth_credential_presentation_get_uuid_ciphertext(unsigned char (*out)[SignalUUID_CIPHERTEXT_LEN], SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_auth_credential_with_pni_check_valid_contents(SignalBorrowedBuffer bytes); - -SignalFfiError *signal_auth_credential_with_pni_response_check_valid_contents(SignalBorrowedBuffer bytes); - -SignalFfiError *signal_authenticated_chat_connection_clear_push_token(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerAuthenticatedChatConnection chat); - -SignalFfiError *signal_authenticated_chat_connection_connect(SignalCPromiseMutPointerAuthenticatedChatConnection *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerConnectionManager connection_manager, SignalCStringPtr username, SignalCStringPtr password, bool receive_stories, SignalBorrowedBytestringArray languages); - -SignalFfiError *signal_authenticated_chat_connection_destroy(SignalMutPointerAuthenticatedChatConnection p); - -SignalFfiError *signal_authenticated_chat_connection_disconnect(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerAuthenticatedChatConnection chat); - -SignalFfiError *signal_authenticated_chat_connection_get_devices(SignalCPromiseOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerAuthenticatedChatConnection chat); - -SignalFfiError *signal_authenticated_chat_connection_get_upload_form(SignalCPromiseFfiUploadForm *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerAuthenticatedChatConnection chat, uint64_t upload_length); - -SignalFfiError *signal_authenticated_chat_connection_info(SignalMutPointerChatConnectionInfo *out, SignalConstPointerAuthenticatedChatConnection chat); - -SignalFfiError *signal_authenticated_chat_connection_init_listener(SignalConstPointerAuthenticatedChatConnection chat, SignalConstPointerFfiChatListenerStruct listener); - -SignalFfiError *signal_authenticated_chat_connection_preconnect(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerConnectionManager connection_manager); - -SignalFfiError *signal_authenticated_chat_connection_remove_device(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerAuthenticatedChatConnection chat, uint8_t device_id); - -SignalFfiError *signal_authenticated_chat_connection_reserve_username_hash(SignalCPromiseu832 *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerAuthenticatedChatConnection chat, SignalBorrowedSliceOfu832 username_hashes); - -SignalFfiError *signal_authenticated_chat_connection_send(SignalCPromiseFfiChatResponse *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerAuthenticatedChatConnection chat, SignalConstPointerHttpRequest http_request, uint32_t timeout_millis); - -SignalFfiError *signal_authenticated_chat_connection_send_message(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerAuthenticatedChatConnection chat, const SignalServiceIdFixedWidthBinaryBytes *destination, uint64_t timestamp, SignalBorrowedSliceOfu32 device_ids, SignalBorrowedSliceOfu32 registration_ids, SignalBorrowedSliceOfConstPointerCiphertextMessage contents, bool online_only, bool is_urgent); - -SignalFfiError *signal_authenticated_chat_connection_send_raw_grpc(SignalCPromiseOwnedBufferOfc_uchar *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerAuthenticatedChatConnection chat, SignalCStringPtr service, SignalCStringPtr method, SignalBorrowedBuffer payload); - -SignalFfiError *signal_authenticated_chat_connection_send_sync_message(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerAuthenticatedChatConnection chat, uint64_t timestamp, SignalBorrowedSliceOfu32 device_ids, SignalBorrowedSliceOfu32 registration_ids, SignalBorrowedSliceOfConstPointerCiphertextMessage contents, bool is_urgent); - -SignalFfiError *signal_authenticated_chat_connection_set_device_name(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerAuthenticatedChatConnection chat, uint8_t device_id, SignalBorrowedBuffer encrypted_name); - -SignalFfiError *signal_authenticated_chat_connection_set_push_token_apns(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerAuthenticatedChatConnection chat, SignalCStringPtr apns_token); - -SignalFfiError *signal_authenticated_chat_connection_set_username_link(SignalCPromiseUuid *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerAuthenticatedChatConnection chat, SignalBorrowedBuffer username_ciphertext, bool keep_link_handle); - -SignalFfiError *signal_avatar_upload_credential_check_valid_contents(SignalBorrowedBuffer credential_bytes); - -SignalFfiError *signal_avatar_upload_credential_get_cm(uint8_t (*out)[32], SignalBorrowedBuffer credential_bytes); - -SignalFfiError *signal_avatar_upload_credential_get_redemption_time(uint64_t *out, SignalBorrowedBuffer credential_bytes); - -SignalFfiError *signal_avatar_upload_credential_present_deterministic(SignalOwnedBuffer *out, SignalBorrowedBuffer credential_bytes, SignalBorrowedBuffer server_params_bytes, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_avatar_upload_credential_presentation_check_valid_contents(SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_avatar_upload_credential_presentation_get_cm(uint8_t (*out)[32], SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_avatar_upload_credential_presentation_get_redemption_time(uint64_t *out, SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_avatar_upload_credential_presentation_verify(SignalBorrowedBuffer presentation_bytes, uint64_t current_time, SignalBorrowedBuffer server_params_bytes); - -SignalFfiError *signal_avatar_upload_credential_request_check_valid_contents(SignalBorrowedBuffer request_bytes); - -SignalFfiError *signal_avatar_upload_credential_request_context_check_valid_contents(SignalBorrowedBuffer context_bytes); - -SignalFfiError *signal_avatar_upload_credential_request_context_get_request(SignalOwnedBuffer *out, SignalBorrowedBuffer context_bytes); - -SignalFfiError *signal_avatar_upload_credential_request_context_new(SignalOwnedBuffer *out, const SignalServiceIdFixedWidthBinaryBytes *aci, SignalBorrowedBuffer zk_credential_key_pair_bytes, uint64_t rotation_id, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_avatar_upload_credential_request_context_receive_response(SignalOwnedBuffer *out, SignalBorrowedBuffer context_bytes, SignalBorrowedBuffer response_bytes, uint64_t current_time, SignalBorrowedBuffer params_bytes); - -SignalFfiError *signal_avatar_upload_credential_request_issue_deterministic(SignalOwnedBuffer *out, SignalBorrowedBuffer request_bytes, const SignalServiceIdFixedWidthBinaryBytes *aci, SignalBorrowedBuffer zk_credential_key_pub_bytes, uint64_t rotation_id, uint64_t redemption_time, SignalBorrowedBuffer params_bytes, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_avatar_upload_credential_response_check_valid_contents(SignalBorrowedBuffer response_bytes); - -SignalFfiError *signal_backup_auth_credential_check_valid_contents(SignalBorrowedBuffer params_bytes); - -SignalFfiError *signal_backup_auth_credential_get_backup_id(uint8_t (*out)[16], SignalBorrowedBuffer credential_bytes); - -SignalFfiError *signal_backup_auth_credential_get_backup_level(uint8_t *out, SignalBorrowedBuffer credential_bytes); - -SignalFfiError *signal_backup_auth_credential_get_type(uint8_t *out, SignalBorrowedBuffer credential_bytes); - -SignalFfiError *signal_backup_auth_credential_present_deterministic(SignalOwnedBuffer *out, SignalBorrowedBuffer credential_bytes, SignalBorrowedBuffer server_params_bytes, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_backup_auth_credential_presentation_check_valid_contents(SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_backup_auth_credential_presentation_verify(SignalBorrowedBuffer presentation_bytes, uint64_t now, SignalBorrowedBuffer server_params_bytes); - -SignalFfiError *signal_backup_auth_credential_request_check_valid_contents(SignalBorrowedBuffer request_bytes); - -SignalFfiError *signal_backup_auth_credential_request_context_check_valid_contents(SignalBorrowedBuffer context_bytes); - -SignalFfiError *signal_backup_auth_credential_request_context_get_request(SignalOwnedBuffer *out, SignalBorrowedBuffer context_bytes); - -SignalFfiError *signal_backup_auth_credential_request_context_new(SignalOwnedBuffer *out, const uint8_t (*backup_key)[32], SignalUuid uuid); - -SignalFfiError *signal_backup_auth_credential_request_context_receive_response(SignalOwnedBuffer *out, SignalBorrowedBuffer context_bytes, SignalBorrowedBuffer response_bytes, uint64_t expected_redemption_time, SignalBorrowedBuffer params_bytes); - -SignalFfiError *signal_backup_auth_credential_request_issue_deterministic(SignalOwnedBuffer *out, SignalBorrowedBuffer request_bytes, uint64_t redemption_time, uint8_t backup_level, uint8_t credential_type, SignalBorrowedBuffer params_bytes, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_backup_auth_credential_response_check_valid_contents(SignalBorrowedBuffer response_bytes); - -SignalFfiError *signal_backup_key_derive_backup_id(uint8_t (*out)[16], const uint8_t (*backup_key)[SignalBACKUP_KEY_LEN], const SignalServiceIdFixedWidthBinaryBytes *aci); - -SignalFfiError *signal_backup_key_derive_ec_key(SignalMutPointerPrivateKey *out, const uint8_t (*backup_key)[SignalBACKUP_KEY_LEN], const SignalServiceIdFixedWidthBinaryBytes *aci); - -SignalFfiError *signal_backup_key_derive_local_backup_metadata_key(uint8_t (*out)[SignalLOCAL_BACKUP_METADATA_KEY_LEN], const uint8_t (*backup_key)[SignalBACKUP_KEY_LEN]); - -SignalFfiError *signal_backup_key_derive_media_encryption_key(uint8_t (*out)[SignalMEDIA_ENCRYPTION_KEY_LEN], const uint8_t (*backup_key)[SignalBACKUP_KEY_LEN], const uint8_t (*media_id)[SignalMEDIA_ID_LEN]); - -SignalFfiError *signal_backup_key_derive_media_id(uint8_t (*out)[SignalMEDIA_ID_LEN], const uint8_t (*backup_key)[SignalBACKUP_KEY_LEN], SignalCStringPtr media_name); - -SignalFfiError *signal_backup_key_derive_thumbnail_transit_encryption_key(uint8_t (*out)[SignalMEDIA_ENCRYPTION_KEY_LEN], const uint8_t (*backup_key)[SignalBACKUP_KEY_LEN], const uint8_t (*media_id)[SignalMEDIA_ID_LEN]); - -SignalFfiError *signal_backup_restore_response_destroy(SignalMutPointerBackupRestoreResponse p); - -SignalFfiError *signal_backup_restore_response_get_forward_secrecy_token(uint8_t (*out)[SignalBACKUP_FORWARD_SECRECY_TOKEN_LEN], SignalConstPointerBackupRestoreResponse response); - -SignalFfiError *signal_backup_restore_response_get_next_backup_secret_data(SignalOwnedBuffer *out, SignalConstPointerBackupRestoreResponse response); - -SignalFfiError *signal_backup_store_response_destroy(SignalMutPointerBackupStoreResponse p); - -SignalFfiError *signal_backup_store_response_get_forward_secrecy_token(uint8_t (*out)[SignalBACKUP_FORWARD_SECRECY_TOKEN_LEN], SignalConstPointerBackupStoreResponse response); - -SignalFfiError *signal_backup_store_response_get_next_backup_secret_data(SignalOwnedBuffer *out, SignalConstPointerBackupStoreResponse response); - -SignalFfiError *signal_backup_store_response_get_opaque_metadata(SignalOwnedBuffer *out, SignalConstPointerBackupStoreResponse response); - -SignalFfiError *signal_bridged_string_map_clone(SignalMutPointerBridgedStringMap *new_obj, SignalConstPointerBridgedStringMap obj); - -SignalFfiError *signal_bridged_string_map_destroy(SignalMutPointerBridgedStringMap p); - -SignalFfiError *signal_bridged_string_map_insert(SignalMutPointerBridgedStringMap map, SignalCStringPtr key, SignalCStringPtr value); - -SignalFfiError *signal_bridged_string_map_new(SignalMutPointerBridgedStringMap *out, uint32_t initial_capacity); - -SignalFfiError *signal_call_link_auth_credential_check_valid_contents(SignalBorrowedBuffer credential_bytes); - -SignalFfiError *signal_call_link_auth_credential_present_deterministic(SignalOwnedBuffer *out, SignalBorrowedBuffer credential_bytes, const SignalServiceIdFixedWidthBinaryBytes *user_id, uint64_t redemption_time, SignalBorrowedBuffer server_params_bytes, SignalBorrowedBuffer call_link_params_bytes, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_call_link_auth_credential_presentation_check_valid_contents(SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_call_link_auth_credential_presentation_get_user_id(unsigned char (*out)[SignalUUID_CIPHERTEXT_LEN], SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_call_link_auth_credential_presentation_verify(SignalBorrowedBuffer presentation_bytes, uint64_t now, SignalBorrowedBuffer server_params_bytes, SignalBorrowedBuffer call_link_params_bytes); - -SignalFfiError *signal_call_link_auth_credential_response_check_valid_contents(SignalBorrowedBuffer response_bytes); - -SignalFfiError *signal_call_link_auth_credential_response_issue_deterministic(SignalOwnedBuffer *out, const SignalServiceIdFixedWidthBinaryBytes *user_id, uint64_t redemption_time, SignalBorrowedBuffer params_bytes, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_call_link_auth_credential_response_receive(SignalOwnedBuffer *out, SignalBorrowedBuffer response_bytes, const SignalServiceIdFixedWidthBinaryBytes *user_id, uint64_t redemption_time, SignalBorrowedBuffer params_bytes); - -SignalFfiError *signal_call_link_public_params_check_valid_contents(SignalBorrowedBuffer params_bytes); - -SignalFfiError *signal_call_link_secret_params_check_valid_contents(SignalBorrowedBuffer params_bytes); - -SignalFfiError *signal_call_link_secret_params_decrypt_user_id(SignalServiceIdFixedWidthBinaryBytes *out, SignalBorrowedBuffer params_bytes, const unsigned char (*user_id)[SignalUUID_CIPHERTEXT_LEN]); - -SignalFfiError *signal_call_link_secret_params_derive_from_root_key(SignalOwnedBuffer *out, SignalBorrowedBuffer root_key); - -SignalFfiError *signal_call_link_secret_params_encrypt_user_id(unsigned char (*out)[SignalUUID_CIPHERTEXT_LEN], SignalBorrowedBuffer params_bytes, const SignalServiceIdFixedWidthBinaryBytes *user_id); - -SignalFfiError *signal_call_link_secret_params_get_public_params(SignalOwnedBuffer *out, SignalBorrowedBuffer params_bytes); - -SignalFfiError *signal_cds2_client_state_new(SignalMutPointerSgxClientState *out, SignalBorrowedBuffer mrenclave, SignalBorrowedBuffer attestation_msg, uint64_t current_timestamp); - -SignalFfiError *signal_cdsi_lookup_complete(SignalCPromiseFfiCdsiLookupResponse *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerCdsiLookup lookup); - -SignalFfiError *signal_cdsi_lookup_destroy(SignalMutPointerCdsiLookup p); - -SignalFfiError *signal_cdsi_lookup_new(SignalCPromiseMutPointerCdsiLookup *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerConnectionManager connection_manager, SignalCStringPtr username, SignalCStringPtr password, SignalConstPointerLookupRequest request); - -SignalFfiError *signal_cdsi_lookup_token(SignalOwnedBuffer *out, SignalConstPointerCdsiLookup lookup); - -SignalFfiError *signal_chat_connection_info_description(SignalCStringPtr *out, SignalConstPointerChatConnectionInfo connection_info); - -SignalFfiError *signal_chat_connection_info_ip_version(uint8_t *out, SignalConstPointerChatConnectionInfo connection_info); - -SignalFfiError *signal_chat_connection_info_local_port(uint16_t *out, SignalConstPointerChatConnectionInfo connection_info); - -SignalFfiError *signal_ciphertext_message_destroy(SignalMutPointerCiphertextMessage p); - -SignalFfiError *signal_ciphertext_message_from_plaintext_content(SignalMutPointerCiphertextMessage *out, SignalConstPointerPlaintextContent m); - -SignalFfiError *signal_ciphertext_message_serialize(SignalOwnedBuffer *out, SignalConstPointerCiphertextMessage obj); - -SignalFfiError *signal_ciphertext_message_type(uint8_t *out, SignalConstPointerCiphertextMessage msg); - -SignalFfiError *signal_connection_info_destroy(SignalMutPointerConnectionInfo p); - -SignalFfiError *signal_connection_manager_clear_proxy(SignalConstPointerConnectionManager connection_manager); - -SignalFfiError *signal_connection_manager_destroy(SignalMutPointerConnectionManager p); - -SignalFfiError *signal_connection_manager_new(SignalMutPointerConnectionManager *out, uint8_t environment, SignalCStringPtr user_agent, SignalMutPointerBridgedStringMap remote_config, uint8_t build_variant); - -SignalFfiError *signal_connection_manager_on_network_change(SignalConstPointerConnectionManager connection_manager); - -SignalFfiError *signal_connection_manager_set_censorship_circumvention_enabled(SignalConstPointerConnectionManager connection_manager, bool enabled); - -SignalFfiError *signal_connection_manager_set_invalid_proxy(SignalConstPointerConnectionManager connection_manager); - -SignalFfiError *signal_connection_manager_set_proxy(SignalConstPointerConnectionManager connection_manager, SignalConstPointerConnectionProxyConfig proxy); - -SignalFfiError *signal_connection_manager_set_remote_config(SignalConstPointerConnectionManager connection_manager, SignalMutPointerBridgedStringMap remote_config, uint8_t build_variant); - -SignalFfiError *signal_connection_proxy_config_clone(SignalMutPointerConnectionProxyConfig *new_obj, SignalConstPointerConnectionProxyConfig obj); - -SignalFfiError *signal_connection_proxy_config_destroy(SignalMutPointerConnectionProxyConfig p); - -SignalFfiError *signal_connection_proxy_config_new(SignalMutPointerConnectionProxyConfig *out, SignalCStringPtr scheme, SignalCStringPtr host, int32_t port, SignalCStringPtr username, SignalCStringPtr password); - -SignalFfiError *signal_copy_backup_media_stream_cancel(SignalConstPointerCopyBackupMediaStream stream); - -SignalFfiError *signal_copy_backup_media_stream_destroy(SignalMutPointerCopyBackupMediaStream p); - -SignalFfiError *signal_copy_backup_media_stream_force_emit_vec_of_bridge_copy_backup_media_item(SignalOwnedBufferOfMaxAlignedBridgeCopyBackupMediaItemFfiResult *out); - -SignalFfiError *signal_copy_backup_media_stream_next(SignalCPromiseCopyBackupMediaNextChunkFfiResult *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerCopyBackupMediaStream stream); - -SignalFfiError *signal_create_call_link_credential_check_valid_contents(SignalBorrowedBuffer params_bytes); - -SignalFfiError *signal_create_call_link_credential_present_deterministic(SignalOwnedBuffer *out, SignalBorrowedBuffer credential_bytes, SignalBorrowedBuffer room_id, const SignalServiceIdFixedWidthBinaryBytes *user_id, SignalBorrowedBuffer server_params_bytes, SignalBorrowedBuffer call_link_params_bytes, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_create_call_link_credential_presentation_check_valid_contents(SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_create_call_link_credential_presentation_verify(SignalBorrowedBuffer presentation_bytes, SignalBorrowedBuffer room_id, uint64_t now, SignalBorrowedBuffer server_params_bytes, SignalBorrowedBuffer call_link_params_bytes); - -SignalFfiError *signal_create_call_link_credential_request_check_valid_contents(SignalBorrowedBuffer request_bytes); - -SignalFfiError *signal_create_call_link_credential_request_context_check_valid_contents(SignalBorrowedBuffer context_bytes); - -SignalFfiError *signal_create_call_link_credential_request_context_get_request(SignalOwnedBuffer *out, SignalBorrowedBuffer context_bytes); - -SignalFfiError *signal_create_call_link_credential_request_context_new_deterministic(SignalOwnedBuffer *out, SignalBorrowedBuffer room_id, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_create_call_link_credential_request_context_receive_response(SignalOwnedBuffer *out, SignalBorrowedBuffer context_bytes, SignalBorrowedBuffer response_bytes, const SignalServiceIdFixedWidthBinaryBytes *user_id, SignalBorrowedBuffer params_bytes); - -SignalFfiError *signal_create_call_link_credential_request_issue_deterministic(SignalOwnedBuffer *out, SignalBorrowedBuffer request_bytes, const SignalServiceIdFixedWidthBinaryBytes *user_id, uint64_t timestamp, SignalBorrowedBuffer params_bytes, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_create_call_link_credential_response_check_valid_contents(SignalBorrowedBuffer response_bytes); - -SignalFfiError *signal_decrypt_message(SignalOwnedBuffer *out, SignalConstPointerSignalMessage message, SignalConstPointerProtocolAddress protocol_address, SignalConstPointerProtocolAddress local_address, SignalConstPointerFfiSessionStoreStruct session_store, SignalConstPointerFfiIdentityKeyStoreStruct identity_key_store); - -SignalFfiError *signal_decrypt_pre_key_message(SignalOwnedBuffer *out, SignalConstPointerPreKeySignalMessage message, SignalConstPointerProtocolAddress protocol_address, SignalConstPointerProtocolAddress local_address, SignalConstPointerFfiSessionStoreStruct session_store, SignalConstPointerFfiIdentityKeyStoreStruct identity_key_store, SignalConstPointerFfiPreKeyStoreStruct prekey_store, SignalConstPointerFfiSignedPreKeyStoreStruct signed_prekey_store, SignalConstPointerFfiKyberPreKeyStoreStruct kyber_prekey_store); - -SignalFfiError *signal_decryption_error_message_clone(SignalMutPointerDecryptionErrorMessage *new_obj, SignalConstPointerDecryptionErrorMessage obj); - -SignalFfiError *signal_decryption_error_message_deserialize(SignalMutPointerDecryptionErrorMessage *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_decryption_error_message_destroy(SignalMutPointerDecryptionErrorMessage p); - -SignalFfiError *signal_decryption_error_message_extract_from_serialized_content(SignalMutPointerDecryptionErrorMessage *out, SignalBorrowedBuffer bytes); - -SignalFfiError *signal_decryption_error_message_for_original_message(SignalMutPointerDecryptionErrorMessage *out, SignalBorrowedBuffer original_bytes, uint8_t original_type, uint64_t original_timestamp, uint32_t original_sender_device_id); - -SignalFfiError *signal_decryption_error_message_get_device_id(uint32_t *out, SignalConstPointerDecryptionErrorMessage obj); - -SignalFfiError *signal_decryption_error_message_get_ratchet_key(SignalMutPointerPublicKey *out, SignalConstPointerDecryptionErrorMessage m); - -SignalFfiError *signal_decryption_error_message_get_timestamp(uint64_t *out, SignalConstPointerDecryptionErrorMessage obj); - -SignalFfiError *signal_decryption_error_message_serialize(SignalOwnedBuffer *out, SignalConstPointerDecryptionErrorMessage obj); - -SignalFfiError *signal_device_transfer_generate_certificate(SignalOwnedBuffer *out, SignalBorrowedBuffer private_key, SignalCStringPtr name, uint32_t days_to_expire); - -SignalFfiError *signal_device_transfer_generate_private_key(SignalOwnedBuffer *out); - -SignalFfiError *signal_device_transfer_generate_private_key_with_format(SignalOwnedBuffer *out, uint8_t key_format); - -SignalFfiError *signal_donation_permit_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_donation_permit_derived_key_pair_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_donation_permit_derived_key_pair_for_expiration(SignalOwnedBuffer *out, uint64_t timestamp, SignalConstPointerServerSecretParams root); - -SignalFfiError *signal_donation_permit_expiration(uint64_t *out, SignalBorrowedBuffer donation_permit); - -SignalFfiError *signal_donation_permit_request_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_donation_permit_request_context_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_donation_permit_request_context_new_deterministic(SignalOwnedBuffer *out, int32_t count, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_donation_permit_request_context_receive(SignalBytestringArray *out, SignalBorrowedBuffer context, SignalBorrowedBuffer response, SignalConstPointerServerPublicParams public_params, uint64_t now); - -SignalFfiError *signal_donation_permit_request_context_request(SignalOwnedBuffer *out, SignalBorrowedBuffer ctx); - -SignalFfiError *signal_donation_permit_request_len(int32_t *out, SignalBorrowedBuffer donation_permit_request); - -SignalFfiError *signal_donation_permit_response_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_donation_permit_response_default_expiration(uint64_t *out, uint64_t current_time); - -SignalFfiError *signal_donation_permit_response_get_expiration(uint64_t *out, SignalBorrowedBuffer response); - -SignalFfiError *signal_donation_permit_response_issue_deterministic(SignalOwnedBuffer *out, SignalBorrowedBuffer request, SignalBorrowedBuffer key_pair, const uint8_t (*seed)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_donation_permit_spend_id(SignalOwnedBuffer *out, SignalBorrowedBuffer donation_permit); - -SignalFfiError *signal_donation_permit_verify(SignalBorrowedBuffer permit, uint64_t now, SignalBorrowedBuffer key_pair); - -SignalFfiError *signal_encrypt_message(SignalMutPointerCiphertextMessage *out, SignalBorrowedBuffer ptext, SignalConstPointerProtocolAddress protocol_address, SignalConstPointerProtocolAddress local_address, SignalConstPointerFfiSessionStoreStruct session_store, SignalConstPointerFfiIdentityKeyStoreStruct identity_key_store, uint64_t now); - -void signal_error_free(SignalFfiError *err); - -SignalFfiError *signal_error_get_address(SignalMutPointerProtocolAddress *out, const SignalFfiError *err); - -SignalFfiError *signal_error_get_invalid_protocol_address(SignalPairOfCStringPtru32 *out, const SignalFfiError *err); - -SignalFfiError *signal_error_get_message(SignalCStringPtr *out, const SignalFfiError *err); - -SignalFfiError *signal_error_get_mismatched_device_errors(SignalOwnedBufferOfFfiMismatchedDevicesError *out, const SignalFfiError *err); - -SignalFfiError *signal_error_get_our_fingerprint_version(uint32_t *out, const SignalFfiError *err); - -SignalFfiError *signal_error_get_rate_limit_challenge(SignalPairOfPairOfCStringPtrOwnedBufferOfc_uchari64 *out, const SignalFfiError *err); - -SignalFfiError *signal_error_get_registration_error_not_deliverable(SignalPairOfCStringPtrbool *out, const SignalFfiError *err); - -SignalFfiError *signal_error_get_registration_lock(uint64_t *out_time_remaining_seconds, const char **out_svr2_username, const char **out_svr2_password, const SignalFfiError *err); - -SignalFfiError *signal_error_get_retry_after_seconds(uint32_t *out, const SignalFfiError *err); - -SignalFfiError *signal_error_get_their_fingerprint_version(uint32_t *out, const SignalFfiError *err); - -SignalFfiError *signal_error_get_tries_remaining(uint32_t *out, const SignalFfiError *err); - -uint32_t signal_error_get_type(const SignalFfiError *err); - -SignalFfiError *signal_error_get_unknown_fields(SignalStringArray *out, const SignalFfiError *err); - -SignalFfiError *signal_error_get_uuid(SignalUuid *out, const SignalFfiError *err); - -SignalFfiError *signal_expiring_profile_key_credential_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_expiring_profile_key_credential_get_expiration_time(uint64_t *out, const unsigned char (*credential)[SignalEXPIRING_PROFILE_KEY_CREDENTIAL_LEN]); - -SignalFfiError *signal_expiring_profile_key_credential_response_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_fingerprint_clone(SignalMutPointerFingerprint *new_obj, SignalConstPointerFingerprint obj); - -SignalFfiError *signal_fingerprint_compare(bool *out, SignalBorrowedBuffer fprint1, SignalBorrowedBuffer fprint2); - -SignalFfiError *signal_fingerprint_destroy(SignalMutPointerFingerprint p); - -SignalFfiError *signal_fingerprint_display_string(SignalCStringPtr *out, SignalConstPointerFingerprint obj); - -SignalFfiError *signal_fingerprint_new(SignalMutPointerFingerprint *out, uint32_t iterations, uint32_t version, SignalBorrowedBuffer local_identifier, SignalConstPointerPublicKey local_key, SignalBorrowedBuffer remote_identifier, SignalConstPointerPublicKey remote_key); - -SignalFfiError *signal_fingerprint_scannable_encoding(SignalOwnedBuffer *out, SignalConstPointerFingerprint obj); - -void signal_free_buffer(const unsigned char *buf, size_t buf_len); - -void signal_free_bytestring_array(SignalBytestringArray array); - -void signal_free_list_of_mismatched_device_errors(SignalOwnedBufferOfFfiMismatchedDevicesError buffer); - -void signal_free_list_of_register_response_badges(SignalOwnedBufferOfFfiRegisterResponseBadge buffer); - -void signal_free_list_of_service_ids(SignalOwnedBufferOfServiceIdFixedWidthBinaryBytes buffer); - -void signal_free_list_of_strings(SignalOwnedBufferOfCStringPtr buffer); - -void signal_free_lookup_response_entry_list(SignalOwnedBufferOfFfiCdsiLookupResponseEntry buffer); - -/** - * This frees a buffer of PreKeyBundle pointers, and _does not_ free the - * pointers within the buffer. This _only_ frees the buffer containing - * the pointers. - */ -void signal_free_outer_buffer_list_of_prekey_bundles(SignalOwnedBufferOfMutPointerPreKeyBundle buffer); - -void signal_free_owned_buffer_of_max_aligned(SignalOwnedBufferOfMaxAlignedc_void buffer); - -void signal_free_string(const char *buf); - -SignalFfiError *signal_generic_server_public_params_check_valid_contents(SignalBorrowedBuffer params_bytes); - -SignalFfiError *signal_generic_server_secret_params_check_valid_contents(SignalBorrowedBuffer params_bytes); - -SignalFfiError *signal_generic_server_secret_params_generate_deterministic(SignalOwnedBuffer *out, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_generic_server_secret_params_get_public_params(SignalOwnedBuffer *out, SignalBorrowedBuffer params_bytes); - -SignalFfiError *signal_group_decrypt_message(SignalOwnedBuffer *out, SignalConstPointerProtocolAddress sender, SignalBorrowedBuffer message, SignalConstPointerFfiSenderKeyStoreStruct store); - -SignalFfiError *signal_group_encrypt_message(SignalMutPointerCiphertextMessage *out, SignalConstPointerProtocolAddress sender, SignalUuid distribution_id, SignalBorrowedBuffer message, SignalConstPointerFfiSenderKeyStoreStruct store); - -SignalFfiError *signal_group_master_key_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_group_public_params_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_group_public_params_get_group_identifier(uint8_t (*out)[SignalGROUP_IDENTIFIER_LEN], const unsigned char (*group_public_params)[SignalGROUP_PUBLIC_PARAMS_LEN]); - -SignalFfiError *signal_group_secret_params_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_group_secret_params_decrypt_blob_with_padding(SignalOwnedBuffer *out, const unsigned char (*params)[SignalGROUP_SECRET_PARAMS_LEN], SignalBorrowedBuffer ciphertext); - -SignalFfiError *signal_group_secret_params_decrypt_profile_key(unsigned char (*out)[SignalPROFILE_KEY_LEN], const unsigned char (*params)[SignalGROUP_SECRET_PARAMS_LEN], const unsigned char (*profile_key)[SignalPROFILE_KEY_CIPHERTEXT_LEN], const SignalServiceIdFixedWidthBinaryBytes *user_id); - -SignalFfiError *signal_group_secret_params_decrypt_service_id(SignalServiceIdFixedWidthBinaryBytes *out, const unsigned char (*params)[SignalGROUP_SECRET_PARAMS_LEN], const unsigned char (*ciphertext)[SignalUUID_CIPHERTEXT_LEN]); - -SignalFfiError *signal_group_secret_params_derive_from_master_key(unsigned char (*out)[SignalGROUP_SECRET_PARAMS_LEN], const unsigned char (*master_key)[SignalGROUP_MASTER_KEY_LEN]); - -SignalFfiError *signal_group_secret_params_encrypt_blob_with_padding_deterministic(SignalOwnedBuffer *out, const unsigned char (*params)[SignalGROUP_SECRET_PARAMS_LEN], const uint8_t (*randomness)[SignalRANDOMNESS_LEN], SignalBorrowedBuffer plaintext, uint32_t padding_len); - -SignalFfiError *signal_group_secret_params_encrypt_profile_key(unsigned char (*out)[SignalPROFILE_KEY_CIPHERTEXT_LEN], const unsigned char (*params)[SignalGROUP_SECRET_PARAMS_LEN], const unsigned char (*profile_key)[SignalPROFILE_KEY_LEN], const SignalServiceIdFixedWidthBinaryBytes *user_id); - -SignalFfiError *signal_group_secret_params_encrypt_service_id(unsigned char (*out)[SignalUUID_CIPHERTEXT_LEN], const unsigned char (*params)[SignalGROUP_SECRET_PARAMS_LEN], const SignalServiceIdFixedWidthBinaryBytes *service_id); - -SignalFfiError *signal_group_secret_params_generate_deterministic(unsigned char (*out)[SignalGROUP_SECRET_PARAMS_LEN], const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_group_secret_params_get_master_key(unsigned char (*out)[SignalGROUP_MASTER_KEY_LEN], const unsigned char (*params)[SignalGROUP_SECRET_PARAMS_LEN]); - -SignalFfiError *signal_group_secret_params_get_public_params(unsigned char (*out)[SignalGROUP_PUBLIC_PARAMS_LEN], const unsigned char (*params)[SignalGROUP_SECRET_PARAMS_LEN]); - -SignalFfiError *signal_group_send_derived_key_pair_check_valid_contents(SignalBorrowedBuffer bytes); - -SignalFfiError *signal_group_send_derived_key_pair_for_expiration(SignalOwnedBuffer *out, uint64_t expiration, SignalConstPointerServerSecretParams server_params); - -SignalFfiError *signal_group_send_endorsement_call_link_params_to_token(SignalOwnedBuffer *out, SignalBorrowedBuffer endorsement, SignalBorrowedBuffer call_link_secret_params_serialized); - -SignalFfiError *signal_group_send_endorsement_check_valid_contents(SignalBorrowedBuffer bytes); - -SignalFfiError *signal_group_send_endorsement_combine(SignalOwnedBuffer *out, SignalBorrowedSliceOfBuffers endorsements); - -SignalFfiError *signal_group_send_endorsement_remove(SignalOwnedBuffer *out, SignalBorrowedBuffer endorsement, SignalBorrowedBuffer to_remove); - -SignalFfiError *signal_group_send_endorsement_to_token(SignalOwnedBuffer *out, SignalBorrowedBuffer endorsement, const unsigned char (*group_params)[SignalGROUP_SECRET_PARAMS_LEN]); - -SignalFfiError *signal_group_send_endorsements_response_check_valid_contents(SignalBorrowedBuffer bytes); - -SignalFfiError *signal_group_send_endorsements_response_get_expiration(uint64_t *out, SignalBorrowedBuffer response_bytes); - -SignalFfiError *signal_group_send_endorsements_response_issue_deterministic(SignalOwnedBuffer *out, SignalBorrowedBuffer concatenated_group_member_ciphertexts, SignalBorrowedBuffer key_pair, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_group_send_endorsements_response_receive_and_combine_with_ciphertexts(SignalBytestringArray *out, SignalBorrowedBuffer response_bytes, SignalBorrowedBuffer concatenated_group_member_ciphertexts, SignalBorrowedBuffer local_user_ciphertext, uint64_t now, SignalConstPointerServerPublicParams server_params); - -SignalFfiError *signal_group_send_endorsements_response_receive_and_combine_with_service_ids(SignalBytestringArray *out, SignalBorrowedBuffer response_bytes, SignalBorrowedBuffer group_members, const SignalServiceIdFixedWidthBinaryBytes *local_user, uint64_t now, const unsigned char (*group_params)[SignalGROUP_SECRET_PARAMS_LEN], SignalConstPointerServerPublicParams server_params); - -SignalFfiError *signal_group_send_full_token_check_valid_contents(SignalBorrowedBuffer bytes); - -SignalFfiError *signal_group_send_full_token_get_expiration(uint64_t *out, SignalBorrowedBuffer token); - -SignalFfiError *signal_group_send_full_token_verify(SignalBorrowedBuffer token, SignalBorrowedBuffer user_ids, uint64_t now, SignalBorrowedBuffer key_pair); - -SignalFfiError *signal_group_send_token_check_valid_contents(SignalBorrowedBuffer bytes); - -SignalFfiError *signal_group_send_token_to_full_token(SignalOwnedBuffer *out, SignalBorrowedBuffer token, uint64_t expiration); - -SignalFfiError *signal_hex_encode(SignalBorrowedMutableBuffer output, SignalBorrowedBuffer input); - -SignalFfiError *signal_hkdf_derive(SignalBorrowedMutableBuffer output, SignalBorrowedBuffer ikm, SignalBorrowedBuffer label, SignalBorrowedBuffer salt); - -SignalFfiError *signal_hsm_enclave_client_complete_handshake(SignalMutPointerHsmEnclaveClient cli, SignalBorrowedBuffer handshake_received); - -SignalFfiError *signal_hsm_enclave_client_destroy(SignalMutPointerHsmEnclaveClient p); - -SignalFfiError *signal_hsm_enclave_client_established_recv(SignalOwnedBuffer *out, SignalMutPointerHsmEnclaveClient cli, SignalBorrowedBuffer received_ciphertext); - -SignalFfiError *signal_hsm_enclave_client_established_send(SignalOwnedBuffer *out, SignalMutPointerHsmEnclaveClient cli, SignalBorrowedBuffer plaintext_to_send); - -SignalFfiError *signal_hsm_enclave_client_initial_request(SignalOwnedBuffer *out, SignalConstPointerHsmEnclaveClient obj); - -SignalFfiError *signal_hsm_enclave_client_new(SignalMutPointerHsmEnclaveClient *out, SignalBorrowedBuffer trusted_public_key, SignalBorrowedBuffer trusted_code_hashes); - -SignalFfiError *signal_http_request_add_header(SignalConstPointerHttpRequest request, SignalCStringPtr name, SignalCStringPtr value); - -SignalFfiError *signal_http_request_destroy(SignalMutPointerHttpRequest p); - -SignalFfiError *signal_http_request_new_with_body(SignalMutPointerHttpRequest *out, SignalCStringPtr method, SignalCStringPtr path, SignalBorrowedBuffer body_as_slice); - -SignalFfiError *signal_http_request_new_without_body(SignalMutPointerHttpRequest *out, SignalCStringPtr method, SignalCStringPtr path); - -SignalFfiError *signal_identitykey_verify_alternate_identity(bool *out, SignalConstPointerPublicKey public_key, SignalConstPointerPublicKey other_identity, SignalBorrowedBuffer signature); - -SignalFfiError *signal_identitykeypair_deserialize(SignalPairOfMutPointerPublicKeyMutPointerPrivateKey *out, SignalBorrowedBuffer input); - -SignalFfiError *signal_identitykeypair_serialize(SignalOwnedBuffer *out, SignalConstPointerPublicKey public_key, SignalConstPointerPrivateKey private_key); - -SignalFfiError *signal_identitykeypair_sign_alternate_identity(SignalOwnedBuffer *out, SignalConstPointerPublicKey public_key, SignalConstPointerPrivateKey private_key, SignalConstPointerPublicKey other_identity); - -SignalFfiError *signal_incremental_mac_calculate_chunk_size(uint32_t *out, uint32_t data_size); - -SignalFfiError *signal_incremental_mac_destroy(SignalMutPointerIncrementalMac p); - -SignalFfiError *signal_incremental_mac_finalize(SignalOwnedBuffer *out, SignalMutPointerIncrementalMac mac); - -SignalFfiError *signal_incremental_mac_initialize(SignalMutPointerIncrementalMac *out, SignalBorrowedBuffer key, uint32_t chunk_size); - -SignalFfiError *signal_incremental_mac_update(SignalOwnedBuffer *out, SignalMutPointerIncrementalMac mac, SignalBorrowedBuffer bytes, uint32_t offset, uint32_t length); - -bool signal_init_logger(SignalLogLevel max_level, SignalFfiLoggerStruct logger); - -SignalFfiError *signal_key_transparency_aci_search_key(SignalOwnedBuffer *out, const SignalServiceIdFixedWidthBinaryBytes *aci); - -SignalFfiError *signal_key_transparency_check(SignalCPromisePairOfOwnedBufferOfc_ucharOwnedBufferOfc_uchar *promise, SignalConstPointerTokioAsyncContext async_runtime, uint8_t environment, SignalConstPointerUnauthenticatedChatConnection chat_connection, const SignalServiceIdFixedWidthBinaryBytes *aci, SignalConstPointerPublicKey aci_identity_key, const char *e164, SignalOptionalBorrowedSliceOfc_uchar unidentified_access_key, SignalOptionalBorrowedSliceOfc_uchar username_hash, SignalOptionalBorrowedSliceOfc_uchar account_data, SignalOptionalBorrowedSliceOfc_uchar last_distinguished_tree_head, bool is_self_check, bool is_e164_discoverable); - -SignalFfiError *signal_key_transparency_e164_search_key(SignalOwnedBuffer *out, const char *e164); - -SignalFfiError *signal_key_transparency_reset_data_field(SignalOwnedBuffer *out, SignalBorrowedBuffer account_data, uint8_t field); - -SignalFfiError *signal_key_transparency_username_hash_search_key(SignalOwnedBuffer *out, SignalBorrowedBuffer hash); - -SignalFfiError *signal_kyber_key_pair_clone(SignalMutPointerKyberKeyPair *new_obj, SignalConstPointerKyberKeyPair obj); - -SignalFfiError *signal_kyber_key_pair_destroy(SignalMutPointerKyberKeyPair p); - -SignalFfiError *signal_kyber_key_pair_generate(SignalMutPointerKyberKeyPair *out); - -SignalFfiError *signal_kyber_key_pair_get_public_key(SignalMutPointerKyberPublicKey *out, SignalConstPointerKyberKeyPair key_pair); - -SignalFfiError *signal_kyber_key_pair_get_secret_key(SignalMutPointerKyberSecretKey *out, SignalConstPointerKyberKeyPair key_pair); - -SignalFfiError *signal_kyber_pre_key_record_clone(SignalMutPointerKyberPreKeyRecord *new_obj, SignalConstPointerKyberPreKeyRecord obj); - -SignalFfiError *signal_kyber_pre_key_record_deserialize(SignalMutPointerKyberPreKeyRecord *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_kyber_pre_key_record_destroy(SignalMutPointerKyberPreKeyRecord p); - -SignalFfiError *signal_kyber_pre_key_record_get_id(uint32_t *out, SignalConstPointerKyberPreKeyRecord obj); - -SignalFfiError *signal_kyber_pre_key_record_get_key_pair(SignalMutPointerKyberKeyPair *out, SignalConstPointerKyberPreKeyRecord obj); - -SignalFfiError *signal_kyber_pre_key_record_get_public_key(SignalMutPointerKyberPublicKey *out, SignalConstPointerKyberPreKeyRecord obj); - -SignalFfiError *signal_kyber_pre_key_record_get_secret_key(SignalMutPointerKyberSecretKey *out, SignalConstPointerKyberPreKeyRecord obj); - -SignalFfiError *signal_kyber_pre_key_record_get_signature(SignalOwnedBuffer *out, SignalConstPointerKyberPreKeyRecord obj); - -SignalFfiError *signal_kyber_pre_key_record_get_timestamp(uint64_t *out, SignalConstPointerKyberPreKeyRecord obj); - -SignalFfiError *signal_kyber_pre_key_record_new(SignalMutPointerKyberPreKeyRecord *out, uint32_t id, uint64_t timestamp, SignalConstPointerKyberKeyPair key_pair, SignalBorrowedBuffer signature); - -SignalFfiError *signal_kyber_pre_key_record_serialize(SignalOwnedBuffer *out, SignalConstPointerKyberPreKeyRecord obj); - -SignalFfiError *signal_kyber_public_key_clone(SignalMutPointerKyberPublicKey *new_obj, SignalConstPointerKyberPublicKey obj); - -SignalFfiError *signal_kyber_public_key_deserialize(SignalMutPointerKyberPublicKey *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_kyber_public_key_destroy(SignalMutPointerKyberPublicKey p); - -SignalFfiError *signal_kyber_public_key_equals(bool *out, SignalConstPointerKyberPublicKey lhs, SignalConstPointerKyberPublicKey rhs); - -SignalFfiError *signal_kyber_public_key_serialize(SignalOwnedBuffer *out, SignalConstPointerKyberPublicKey obj); - -SignalFfiError *signal_kyber_secret_key_clone(SignalMutPointerKyberSecretKey *new_obj, SignalConstPointerKyberSecretKey obj); - -SignalFfiError *signal_kyber_secret_key_deserialize(SignalMutPointerKyberSecretKey *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_kyber_secret_key_destroy(SignalMutPointerKyberSecretKey p); - -SignalFfiError *signal_kyber_secret_key_serialize(SignalOwnedBuffer *out, SignalConstPointerKyberSecretKey obj); - -SignalFfiError *signal_lookup_request_add_aci_and_access_key(SignalConstPointerLookupRequest request, const SignalServiceIdFixedWidthBinaryBytes *aci, SignalBorrowedBuffer access_key); - -SignalFfiError *signal_lookup_request_add_e164(SignalConstPointerLookupRequest request, const char *e164); - -SignalFfiError *signal_lookup_request_add_previous_e164(SignalConstPointerLookupRequest request, const char *e164); - -SignalFfiError *signal_lookup_request_destroy(SignalMutPointerLookupRequest p); - -SignalFfiError *signal_lookup_request_new(SignalMutPointerLookupRequest *out); - -SignalFfiError *signal_lookup_request_set_token(SignalConstPointerLookupRequest request, SignalBorrowedBuffer token); - -SignalFfiError *signal_message_backup_key_destroy(SignalMutPointerMessageBackupKey p); - -SignalFfiError *signal_message_backup_key_from_account_entropy_pool(SignalMutPointerMessageBackupKey *out, const char *account_entropy, const SignalServiceIdFixedWidthBinaryBytes *aci, const uint8_t (*forward_secrecy_token)[SignalBACKUP_FORWARD_SECRECY_TOKEN_LEN]); - -SignalFfiError *signal_message_backup_key_from_backup_key_and_backup_id(SignalMutPointerMessageBackupKey *out, const uint8_t (*backup_key)[32], const uint8_t (*backup_id)[16], const uint8_t (*forward_secrecy_token)[SignalBACKUP_FORWARD_SECRECY_TOKEN_LEN]); - -SignalFfiError *signal_message_backup_key_get_aes_key(uint8_t (*out)[32], SignalConstPointerMessageBackupKey key); - -SignalFfiError *signal_message_backup_key_get_hmac_key(uint8_t (*out)[32], SignalConstPointerMessageBackupKey key); - -SignalFfiError *signal_message_backup_validation_outcome_destroy(SignalMutPointerMessageBackupValidationOutcome p); - -SignalFfiError *signal_message_backup_validation_outcome_get_error_message(SignalCStringPtr *out, SignalConstPointerMessageBackupValidationOutcome outcome); - -SignalFfiError *signal_message_backup_validation_outcome_get_unknown_fields(SignalStringArray *out, SignalConstPointerMessageBackupValidationOutcome outcome); - -SignalFfiError *signal_message_backup_validator_validate(SignalMutPointerMessageBackupValidationOutcome *out, SignalConstPointerMessageBackupKey key, SignalConstPointerFfiInputStreamStruct first_stream, SignalConstPointerFfiInputStreamStruct second_stream, uint64_t len, uint8_t purpose); - -SignalFfiError *signal_message_clone(SignalMutPointerSignalMessage *new_obj, SignalConstPointerSignalMessage obj); - -SignalFfiError *signal_message_deserialize(SignalMutPointerSignalMessage *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_message_destroy(SignalMutPointerSignalMessage p); - -SignalFfiError *signal_message_get_body(SignalOwnedBuffer *out, SignalConstPointerSignalMessage obj); - -SignalFfiError *signal_message_get_counter(uint32_t *out, SignalConstPointerSignalMessage obj); - -SignalFfiError *signal_message_get_message_version(uint32_t *out, SignalConstPointerSignalMessage obj); - -SignalFfiError *signal_message_get_pq_ratchet(SignalOwnedBuffer *out, SignalConstPointerSignalMessage msg); - -SignalFfiError *signal_message_get_sender_ratchet_key(SignalMutPointerPublicKey *out, SignalConstPointerSignalMessage m); - -SignalFfiError *signal_message_get_serialized(SignalOwnedBuffer *out, SignalConstPointerSignalMessage obj); - -SignalFfiError *signal_message_new(SignalMutPointerSignalMessage *out, uint8_t message_version, SignalBorrowedBuffer mac_key, SignalConstPointerPublicKey sender_ratchet_key, uint32_t counter, uint32_t previous_counter, SignalBorrowedBuffer ciphertext, SignalConstPointerPublicKey sender_identity_key, SignalConstPointerPublicKey receiver_identity_key, SignalBorrowedBuffer pq_ratchet); - -SignalFfiError *signal_mp4_sanitizer_sanitize(SignalMutPointerSanitizedMetadata *out, SignalConstPointerFfiInputStreamStruct input, uint64_t len); - -SignalFfiError *signal_online_backup_validator_add_frame(SignalMutPointerOnlineBackupValidator backup, SignalBorrowedBuffer frame); - -SignalFfiError *signal_online_backup_validator_destroy(SignalMutPointerOnlineBackupValidator p); - -SignalFfiError *signal_online_backup_validator_finalize(SignalMutPointerOnlineBackupValidator backup); - -SignalFfiError *signal_online_backup_validator_new(SignalMutPointerOnlineBackupValidator *out, SignalBorrowedBuffer backup_info_frame, uint8_t purpose); - -SignalFfiError *signal_pin_hash_access_key(uint8_t (*out)[32], SignalConstPointerPinHash ph); - -SignalFfiError *signal_pin_hash_clone(SignalMutPointerPinHash *new_obj, SignalConstPointerPinHash obj); - -SignalFfiError *signal_pin_hash_destroy(SignalMutPointerPinHash p); - -SignalFfiError *signal_pin_hash_encryption_key(uint8_t (*out)[32], SignalConstPointerPinHash ph); - -SignalFfiError *signal_pin_hash_from_salt(SignalMutPointerPinHash *out, SignalBorrowedBuffer pin, const uint8_t (*salt)[32]); - -SignalFfiError *signal_pin_hash_from_username_mrenclave(SignalMutPointerPinHash *out, SignalBorrowedBuffer pin, SignalCStringPtr username, SignalBorrowedBuffer mrenclave); - -SignalFfiError *signal_pin_local_hash(SignalCStringPtr *out, SignalBorrowedBuffer pin); - -SignalFfiError *signal_pin_verify_local_hash(bool *out, SignalCStringPtr encoded_hash, SignalBorrowedBuffer pin); - -SignalFfiError *signal_plaintext_content_clone(SignalMutPointerPlaintextContent *new_obj, SignalConstPointerPlaintextContent obj); - -SignalFfiError *signal_plaintext_content_deserialize(SignalMutPointerPlaintextContent *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_plaintext_content_destroy(SignalMutPointerPlaintextContent p); - -SignalFfiError *signal_plaintext_content_from_decryption_error_message(SignalMutPointerPlaintextContent *out, SignalConstPointerDecryptionErrorMessage m); - -SignalFfiError *signal_plaintext_content_get_body(SignalOwnedBuffer *out, SignalConstPointerPlaintextContent obj); - -SignalFfiError *signal_plaintext_content_serialize(SignalOwnedBuffer *out, SignalConstPointerPlaintextContent obj); - -SignalFfiError *signal_pre_key_bundle_clone(SignalMutPointerPreKeyBundle *new_obj, SignalConstPointerPreKeyBundle obj); - -SignalFfiError *signal_pre_key_bundle_destroy(SignalMutPointerPreKeyBundle p); - -SignalFfiError *signal_pre_key_bundle_get_device_id(uint32_t *out, SignalConstPointerPreKeyBundle obj); - -SignalFfiError *signal_pre_key_bundle_get_identity_key(SignalMutPointerPublicKey *out, SignalConstPointerPreKeyBundle p); - -SignalFfiError *signal_pre_key_bundle_get_kyber_pre_key_id(uint32_t *out, SignalConstPointerPreKeyBundle obj); - -SignalFfiError *signal_pre_key_bundle_get_kyber_pre_key_public(SignalMutPointerKyberPublicKey *out, SignalConstPointerPreKeyBundle bundle); - -SignalFfiError *signal_pre_key_bundle_get_kyber_pre_key_signature(SignalOwnedBuffer *out, SignalConstPointerPreKeyBundle obj); - -SignalFfiError *signal_pre_key_bundle_get_pre_key_id(uint32_t *out, SignalConstPointerPreKeyBundle obj); - -SignalFfiError *signal_pre_key_bundle_get_pre_key_public(SignalMutPointerPublicKey *out, SignalConstPointerPreKeyBundle obj); - -SignalFfiError *signal_pre_key_bundle_get_registration_id(uint32_t *out, SignalConstPointerPreKeyBundle obj); - -SignalFfiError *signal_pre_key_bundle_get_signed_pre_key_id(uint32_t *out, SignalConstPointerPreKeyBundle obj); - -SignalFfiError *signal_pre_key_bundle_get_signed_pre_key_public(SignalMutPointerPublicKey *out, SignalConstPointerPreKeyBundle obj); - -SignalFfiError *signal_pre_key_bundle_get_signed_pre_key_signature(SignalOwnedBuffer *out, SignalConstPointerPreKeyBundle obj); - -SignalFfiError *signal_pre_key_bundle_new(SignalMutPointerPreKeyBundle *out, uint32_t registration_id, uint32_t device_id, uint32_t prekey_id, SignalConstPointerPublicKey prekey, uint32_t signed_prekey_id, SignalConstPointerPublicKey signed_prekey, SignalBorrowedBuffer signed_prekey_signature, SignalConstPointerPublicKey identity_key, uint32_t kyber_prekey_id, SignalConstPointerKyberPublicKey kyber_prekey, SignalBorrowedBuffer kyber_prekey_signature); - -SignalFfiError *signal_pre_key_record_clone(SignalMutPointerPreKeyRecord *new_obj, SignalConstPointerPreKeyRecord obj); - -SignalFfiError *signal_pre_key_record_deserialize(SignalMutPointerPreKeyRecord *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_pre_key_record_destroy(SignalMutPointerPreKeyRecord p); - -SignalFfiError *signal_pre_key_record_get_id(uint32_t *out, SignalConstPointerPreKeyRecord obj); - -SignalFfiError *signal_pre_key_record_get_private_key(SignalMutPointerPrivateKey *out, SignalConstPointerPreKeyRecord obj); - -SignalFfiError *signal_pre_key_record_get_public_key(SignalMutPointerPublicKey *out, SignalConstPointerPreKeyRecord obj); - -SignalFfiError *signal_pre_key_record_new(SignalMutPointerPreKeyRecord *out, uint32_t id, SignalConstPointerPublicKey pub_key, SignalConstPointerPrivateKey priv_key); - -SignalFfiError *signal_pre_key_record_serialize(SignalOwnedBuffer *out, SignalConstPointerPreKeyRecord obj); - -SignalFfiError *signal_pre_key_signal_message_clone(SignalMutPointerPreKeySignalMessage *new_obj, SignalConstPointerPreKeySignalMessage obj); - -SignalFfiError *signal_pre_key_signal_message_deserialize(SignalMutPointerPreKeySignalMessage *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_pre_key_signal_message_destroy(SignalMutPointerPreKeySignalMessage p); - -SignalFfiError *signal_pre_key_signal_message_get_base_key(SignalMutPointerPublicKey *out, SignalConstPointerPreKeySignalMessage m); - -SignalFfiError *signal_pre_key_signal_message_get_identity_key(SignalMutPointerPublicKey *out, SignalConstPointerPreKeySignalMessage m); - -SignalFfiError *signal_pre_key_signal_message_get_pre_key_id(uint32_t *out, SignalConstPointerPreKeySignalMessage obj); - -SignalFfiError *signal_pre_key_signal_message_get_registration_id(uint32_t *out, SignalConstPointerPreKeySignalMessage obj); - -SignalFfiError *signal_pre_key_signal_message_get_signal_message(SignalMutPointerSignalMessage *out, SignalConstPointerPreKeySignalMessage m); - -SignalFfiError *signal_pre_key_signal_message_get_signed_pre_key_id(uint32_t *out, SignalConstPointerPreKeySignalMessage obj); - -SignalFfiError *signal_pre_key_signal_message_get_version(uint32_t *out, SignalConstPointerPreKeySignalMessage obj); - -SignalFfiError *signal_pre_key_signal_message_new(SignalMutPointerPreKeySignalMessage *out, uint8_t message_version, uint32_t registration_id, uint32_t pre_key_id, uint32_t signed_pre_key_id, SignalConstPointerPublicKey base_key, SignalConstPointerPublicKey identity_key, SignalConstPointerSignalMessage signal_message); - -SignalFfiError *signal_pre_key_signal_message_serialize(SignalOwnedBuffer *out, SignalConstPointerPreKeySignalMessage obj); - -void signal_print_ptr(const void *p); - -SignalFfiError *signal_privatekey_agree(SignalOwnedBuffer *out, SignalConstPointerPrivateKey private_key, SignalConstPointerPublicKey public_key); - -SignalFfiError *signal_privatekey_clone(SignalMutPointerPrivateKey *new_obj, SignalConstPointerPrivateKey obj); - -SignalFfiError *signal_privatekey_deserialize(SignalMutPointerPrivateKey *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_privatekey_destroy(SignalMutPointerPrivateKey p); - -SignalFfiError *signal_privatekey_generate(SignalMutPointerPrivateKey *out); - -SignalFfiError *signal_privatekey_get_public_key(SignalMutPointerPublicKey *out, SignalConstPointerPrivateKey k); - -SignalFfiError *signal_privatekey_hpke_open(SignalOwnedBuffer *out, SignalConstPointerPrivateKey sk, SignalBorrowedBuffer ciphertext, SignalBorrowedBuffer info, SignalBorrowedBuffer associated_data); - -SignalFfiError *signal_privatekey_serialize(SignalOwnedBuffer *out, SignalConstPointerPrivateKey obj); - -SignalFfiError *signal_privatekey_sign(SignalOwnedBuffer *out, SignalConstPointerPrivateKey key, SignalBorrowedBuffer message); - -SignalFfiError *signal_process_prekey_bundle(SignalConstPointerPreKeyBundle bundle, SignalConstPointerProtocolAddress protocol_address, SignalConstPointerProtocolAddress local_address, SignalConstPointerFfiSessionStoreStruct session_store, SignalConstPointerFfiIdentityKeyStoreStruct identity_key_store, uint64_t now); - -SignalFfiError *signal_process_sender_key_distribution_message(SignalConstPointerProtocolAddress sender, SignalConstPointerSenderKeyDistributionMessage sender_key_distribution_message, SignalConstPointerFfiSenderKeyStoreStruct store); - -SignalFfiError *signal_profile_key_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_profile_key_ciphertext_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_profile_key_commitment_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_profile_key_credential_presentation_check_valid_contents(SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_profile_key_credential_presentation_get_profile_key_ciphertext(unsigned char (*out)[SignalPROFILE_KEY_CIPHERTEXT_LEN], SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_profile_key_credential_presentation_get_uuid_ciphertext(unsigned char (*out)[SignalUUID_CIPHERTEXT_LEN], SignalBorrowedBuffer presentation_bytes); - -SignalFfiError *signal_profile_key_credential_request_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_profile_key_credential_request_context_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_profile_key_credential_request_context_get_request(unsigned char (*out)[SignalPROFILE_KEY_CREDENTIAL_REQUEST_LEN], const unsigned char (*context)[SignalPROFILE_KEY_CREDENTIAL_REQUEST_CONTEXT_LEN]); - -SignalFfiError *signal_profile_key_derive_access_key(uint8_t (*out)[SignalACCESS_KEY_LEN], const unsigned char (*profile_key)[SignalPROFILE_KEY_LEN]); - -SignalFfiError *signal_profile_key_get_commitment(unsigned char (*out)[SignalPROFILE_KEY_COMMITMENT_LEN], const unsigned char (*profile_key)[SignalPROFILE_KEY_LEN], const SignalServiceIdFixedWidthBinaryBytes *user_id); - -SignalFfiError *signal_profile_key_get_profile_key_version(uint8_t (*out)[SignalPROFILE_KEY_VERSION_ENCODED_LEN], const unsigned char (*profile_key)[SignalPROFILE_KEY_LEN], const SignalServiceIdFixedWidthBinaryBytes *user_id); - -SignalFfiError *signal_provisioning_chat_connection_connect(SignalCPromiseMutPointerProvisioningChatConnection *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerConnectionManager connection_manager); - -SignalFfiError *signal_provisioning_chat_connection_destroy(SignalMutPointerProvisioningChatConnection p); - -SignalFfiError *signal_provisioning_chat_connection_disconnect(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerProvisioningChatConnection chat); - -SignalFfiError *signal_provisioning_chat_connection_info(SignalMutPointerChatConnectionInfo *out, SignalConstPointerProvisioningChatConnection chat); - -SignalFfiError *signal_provisioning_chat_connection_init_listener(SignalConstPointerProvisioningChatConnection chat, SignalConstPointerFfiProvisioningListenerStruct listener); - -SignalFfiError *signal_publickey_clone(SignalMutPointerPublicKey *new_obj, SignalConstPointerPublicKey obj); - -SignalFfiError *signal_publickey_deserialize(SignalMutPointerPublicKey *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_publickey_destroy(SignalMutPointerPublicKey p); - -SignalFfiError *signal_publickey_equals(bool *out, SignalConstPointerPublicKey lhs, SignalConstPointerPublicKey rhs); - -SignalFfiError *signal_publickey_get_public_key_bytes(SignalOwnedBuffer *out, SignalConstPointerPublicKey obj); - -SignalFfiError *signal_publickey_hpke_seal(SignalOwnedBuffer *out, SignalConstPointerPublicKey pk, SignalBorrowedBuffer plaintext, SignalBorrowedBuffer info, SignalBorrowedBuffer associated_data); - -SignalFfiError *signal_publickey_serialize(SignalOwnedBuffer *out, SignalConstPointerPublicKey obj); - -SignalFfiError *signal_publickey_verify(bool *out, SignalConstPointerPublicKey key, SignalBorrowedBuffer message, SignalBorrowedBuffer signature); - -SignalFfiError *signal_receipt_credential_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_receipt_credential_get_receipt_expiration_time(uint64_t *out, const unsigned char (*receipt_credential)[SignalRECEIPT_CREDENTIAL_LEN]); - -SignalFfiError *signal_receipt_credential_get_receipt_level(uint64_t *out, const unsigned char (*receipt_credential)[SignalRECEIPT_CREDENTIAL_LEN]); - -SignalFfiError *signal_receipt_credential_presentation_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_receipt_credential_presentation_get_receipt_expiration_time(uint64_t *out, const unsigned char (*presentation)[SignalRECEIPT_CREDENTIAL_PRESENTATION_LEN]); - -SignalFfiError *signal_receipt_credential_presentation_get_receipt_level(uint64_t *out, const unsigned char (*presentation)[SignalRECEIPT_CREDENTIAL_PRESENTATION_LEN]); - -SignalFfiError *signal_receipt_credential_presentation_get_receipt_serial(uint8_t (*out)[SignalRECEIPT_SERIAL_LEN], const unsigned char (*presentation)[SignalRECEIPT_CREDENTIAL_PRESENTATION_LEN]); - -SignalFfiError *signal_receipt_credential_request_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_receipt_credential_request_context_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_receipt_credential_request_context_get_request(unsigned char (*out)[SignalRECEIPT_CREDENTIAL_REQUEST_LEN], const unsigned char (*request_context)[SignalRECEIPT_CREDENTIAL_REQUEST_CONTEXT_LEN]); - -SignalFfiError *signal_receipt_credential_response_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_register_account_request_create(SignalMutPointerRegisterAccountRequest *out); - -SignalFfiError *signal_register_account_request_destroy(SignalMutPointerRegisterAccountRequest p); - -SignalFfiError *signal_register_account_request_set_account_password(SignalConstPointerRegisterAccountRequest register_account, SignalCStringPtr account_password); - -SignalFfiError *signal_register_account_request_set_apn_push_token(SignalConstPointerRegisterAccountRequest register_account, SignalCStringPtr apn_push_token); - -SignalFfiError *signal_register_account_request_set_identity_pq_last_resort_pre_key(SignalConstPointerRegisterAccountRequest register_account, uint8_t identity_type, SignalFfiSignedPublicPreKey pq_last_resort_pre_key); - -SignalFfiError *signal_register_account_request_set_identity_public_key(SignalConstPointerRegisterAccountRequest register_account, uint8_t identity_type, SignalConstPointerPublicKey identity_key); - -SignalFfiError *signal_register_account_request_set_identity_signed_pre_key(SignalConstPointerRegisterAccountRequest register_account, uint8_t identity_type, SignalFfiSignedPublicPreKey signed_pre_key); - -SignalFfiError *signal_register_account_request_set_skip_device_transfer(SignalConstPointerRegisterAccountRequest register_account); - -SignalFfiError *signal_register_account_response_destroy(SignalMutPointerRegisterAccountResponse p); - -SignalFfiError *signal_register_account_response_get_entitlement_backup_expiration_seconds(uint64_t *out, SignalConstPointerRegisterAccountResponse response); - -SignalFfiError *signal_register_account_response_get_entitlement_backup_level(uint64_t *out, SignalConstPointerRegisterAccountResponse response); - -SignalFfiError *signal_register_account_response_get_entitlement_badges(SignalOwnedBufferOfFfiRegisterResponseBadge *out, SignalConstPointerRegisterAccountResponse response); - -SignalFfiError *signal_register_account_response_get_identity(SignalServiceIdFixedWidthBinaryBytes *out, SignalConstPointerRegisterAccountResponse response, uint8_t identity_type); - -SignalFfiError *signal_register_account_response_get_number(SignalCStringPtr *out, SignalConstPointerRegisterAccountResponse response); - -SignalFfiError *signal_register_account_response_get_reregistration(bool *out, SignalConstPointerRegisterAccountResponse response); - -SignalFfiError *signal_register_account_response_get_storage_capable(bool *out, SignalConstPointerRegisterAccountResponse response); - -SignalFfiError *signal_register_account_response_get_username_hash(SignalOwnedBuffer *out, SignalConstPointerRegisterAccountResponse response); - -SignalFfiError *signal_register_account_response_get_username_link_handle(SignalOptionalUuid *out, SignalConstPointerRegisterAccountResponse response); - -SignalFfiError *signal_registration_account_attributes_create(SignalMutPointerRegistrationAccountAttributes *out, SignalBorrowedBuffer recovery_password, uint16_t aci_registration_id, uint16_t pni_registration_id, SignalCStringPtr registration_lock, const uint8_t (*unidentified_access_key)[16], bool unrestricted_unidentified_access, SignalBorrowedBytestringArray capabilities, bool discoverable_by_phone_number); - -SignalFfiError *signal_registration_account_attributes_destroy(SignalMutPointerRegistrationAccountAttributes p); - -SignalFfiError *signal_registration_service_check_svr2_credentials(SignalCPromiseFfiCheckSvr2CredentialsResponse *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerRegistrationService service, SignalBorrowedBytestringArray svr_tokens); - -SignalFfiError *signal_registration_service_create_session(SignalCPromiseMutPointerRegistrationService *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalFfiRegistrationCreateSessionRequest create_session, SignalConstPointerFfiConnectChatBridgeStruct connect_chat); - -SignalFfiError *signal_registration_service_destroy(SignalMutPointerRegistrationService p); - -SignalFfiError *signal_registration_service_register_account(SignalCPromiseMutPointerRegisterAccountResponse *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerRegistrationService service, SignalConstPointerRegisterAccountRequest register_account, SignalConstPointerRegistrationAccountAttributes account_attributes); - -SignalFfiError *signal_registration_service_registration_session(SignalMutPointerRegistrationSession *out, SignalConstPointerRegistrationService service); - -SignalFfiError *signal_registration_service_request_push_challenge(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerRegistrationService service, const char *push_token); - -SignalFfiError *signal_registration_service_request_verification_code(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerRegistrationService service, SignalCStringPtr transport, SignalCStringPtr client, SignalBorrowedBytestringArray languages); - -SignalFfiError *signal_registration_service_reregister_account(SignalCPromiseMutPointerRegisterAccountResponse *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerFfiConnectChatBridgeStruct connect_chat, SignalCStringPtr number, SignalConstPointerRegisterAccountRequest register_account, SignalConstPointerRegistrationAccountAttributes account_attributes); - -SignalFfiError *signal_registration_service_resume_session(SignalCPromiseMutPointerRegistrationService *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalCStringPtr session_id, SignalCStringPtr number, SignalConstPointerFfiConnectChatBridgeStruct connect_chat); - -SignalFfiError *signal_registration_service_session_id(SignalCStringPtr *out, SignalConstPointerRegistrationService service); - -SignalFfiError *signal_registration_service_submit_captcha(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerRegistrationService service, SignalCStringPtr captcha_value); - -SignalFfiError *signal_registration_service_submit_push_challenge(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerRegistrationService service, SignalCStringPtr push_challenge); - -SignalFfiError *signal_registration_service_submit_verification_code(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerRegistrationService service, SignalCStringPtr code); - -SignalFfiError *signal_registration_session_destroy(SignalMutPointerRegistrationSession p); - -SignalFfiError *signal_registration_session_get_allowed_to_request_code(bool *out, SignalConstPointerRegistrationSession session); - -SignalFfiError *signal_registration_session_get_next_call_seconds(uint32_t *out, SignalConstPointerRegistrationSession session); - -SignalFfiError *signal_registration_session_get_next_sms_seconds(uint32_t *out, SignalConstPointerRegistrationSession session); - -SignalFfiError *signal_registration_session_get_next_verification_attempt_seconds(uint32_t *out, SignalConstPointerRegistrationSession session); - -SignalFfiError *signal_registration_session_get_requested_information(SignalOwnedBuffer *out, SignalConstPointerRegistrationSession session); - -SignalFfiError *signal_registration_session_get_verified(bool *out, SignalConstPointerRegistrationSession session); - -SignalFfiError *signal_sanitized_metadata_clone(SignalMutPointerSanitizedMetadata *new_obj, SignalConstPointerSanitizedMetadata obj); - -SignalFfiError *signal_sanitized_metadata_destroy(SignalMutPointerSanitizedMetadata p); - -SignalFfiError *signal_sanitized_metadata_get_data_len(uint64_t *out, SignalConstPointerSanitizedMetadata sanitized); - -SignalFfiError *signal_sanitized_metadata_get_data_offset(uint64_t *out, SignalConstPointerSanitizedMetadata sanitized); - -SignalFfiError *signal_sanitized_metadata_get_metadata(SignalOwnedBuffer *out, SignalConstPointerSanitizedMetadata sanitized); - -SignalFfiError *signal_sealed_sender_multi_recipient_encrypt(SignalOwnedBuffer *out, SignalBorrowedSliceOfConstPointerProtocolAddress recipients, SignalBorrowedSliceOfConstPointerSessionRecord recipient_sessions, SignalBorrowedBuffer excluded_recipients, SignalConstPointerUnidentifiedSenderMessageContent content, SignalConstPointerFfiIdentityKeyStoreStruct identity_key_store); - -SignalFfiError *signal_sealed_sender_multi_recipient_message_for_single_recipient(SignalOwnedBuffer *out, SignalBorrowedBuffer encoded_multi_recipient_message); - -SignalFfiError *signal_sealed_session_cipher_decrypt_to_usmc(SignalMutPointerUnidentifiedSenderMessageContent *out, SignalBorrowedBuffer ctext, SignalConstPointerFfiIdentityKeyStoreStruct identity_store); - -SignalFfiError *signal_sealed_session_cipher_encrypt(SignalOwnedBuffer *out, SignalConstPointerProtocolAddress destination, SignalConstPointerUnidentifiedSenderMessageContent content, SignalConstPointerFfiIdentityKeyStoreStruct identity_key_store); - -SignalFfiError *signal_secure_value_recovery_for_backups_create_new_backup_chain(SignalOwnedBuffer *out, uint8_t environment, const SignalBackupKeyBytes *backup_key); - -SignalFfiError *signal_secure_value_recovery_for_backups_remove_backup(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerConnectionManager connection_manager, SignalCStringPtr username, SignalCStringPtr password); - -SignalFfiError *signal_secure_value_recovery_for_backups_restore_backup_from_server(SignalCPromiseMutPointerBackupRestoreResponse *promise, SignalConstPointerTokioAsyncContext async_runtime, const SignalBackupKeyBytes *backup_key, SignalBorrowedBuffer metadata, SignalConstPointerConnectionManager connection_manager, SignalCStringPtr username, SignalCStringPtr password); - -SignalFfiError *signal_secure_value_recovery_for_backups_store_backup(SignalCPromiseMutPointerBackupStoreResponse *promise, SignalConstPointerTokioAsyncContext async_runtime, const SignalBackupKeyBytes *backup_key, SignalBorrowedBuffer previous_secret_data, SignalConstPointerConnectionManager connection_manager, SignalCStringPtr username, SignalCStringPtr password); - -SignalFfiError *signal_sender_certificate_clone(SignalMutPointerSenderCertificate *new_obj, SignalConstPointerSenderCertificate obj); - -SignalFfiError *signal_sender_certificate_deserialize(SignalMutPointerSenderCertificate *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_sender_certificate_destroy(SignalMutPointerSenderCertificate p); - -SignalFfiError *signal_sender_certificate_get_certificate(SignalOwnedBuffer *out, SignalConstPointerSenderCertificate obj); - -SignalFfiError *signal_sender_certificate_get_device_id(uint32_t *out, SignalConstPointerSenderCertificate obj); - -SignalFfiError *signal_sender_certificate_get_expiration(uint64_t *out, SignalConstPointerSenderCertificate obj); - -SignalFfiError *signal_sender_certificate_get_key(SignalMutPointerPublicKey *out, SignalConstPointerSenderCertificate obj); - -SignalFfiError *signal_sender_certificate_get_sender_e164(SignalCStringPtr *out, SignalConstPointerSenderCertificate obj); - -SignalFfiError *signal_sender_certificate_get_sender_uuid(SignalCStringPtr *out, SignalConstPointerSenderCertificate obj); - -SignalFfiError *signal_sender_certificate_get_serialized(SignalOwnedBuffer *out, SignalConstPointerSenderCertificate obj); - -SignalFfiError *signal_sender_certificate_get_server_certificate(SignalMutPointerServerCertificate *out, SignalConstPointerSenderCertificate cert); - -SignalFfiError *signal_sender_certificate_get_signature(SignalOwnedBuffer *out, SignalConstPointerSenderCertificate obj); - -SignalFfiError *signal_sender_certificate_new(SignalMutPointerSenderCertificate *out, SignalCStringPtr sender_uuid, SignalCStringPtr sender_e164, uint32_t sender_device_id, SignalConstPointerPublicKey sender_key, uint64_t expiration, SignalConstPointerServerCertificate signer_cert, SignalConstPointerPrivateKey signer_key); - -SignalFfiError *signal_sender_certificate_validate(bool *out, SignalConstPointerSenderCertificate cert, SignalBorrowedSliceOfConstPointerPublicKey trust_roots, uint64_t time); - -SignalFfiError *signal_sender_key_distribution_message_clone(SignalMutPointerSenderKeyDistributionMessage *new_obj, SignalConstPointerSenderKeyDistributionMessage obj); - -SignalFfiError *signal_sender_key_distribution_message_create(SignalMutPointerSenderKeyDistributionMessage *out, SignalConstPointerProtocolAddress sender, SignalUuid distribution_id, SignalConstPointerFfiSenderKeyStoreStruct store); - -SignalFfiError *signal_sender_key_distribution_message_deserialize(SignalMutPointerSenderKeyDistributionMessage *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_sender_key_distribution_message_destroy(SignalMutPointerSenderKeyDistributionMessage p); - -SignalFfiError *signal_sender_key_distribution_message_get_chain_id(uint32_t *out, SignalConstPointerSenderKeyDistributionMessage obj); - -SignalFfiError *signal_sender_key_distribution_message_get_chain_key(SignalOwnedBuffer *out, SignalConstPointerSenderKeyDistributionMessage obj); - -SignalFfiError *signal_sender_key_distribution_message_get_distribution_id(SignalUuid *out, SignalConstPointerSenderKeyDistributionMessage obj); - -SignalFfiError *signal_sender_key_distribution_message_get_iteration(uint32_t *out, SignalConstPointerSenderKeyDistributionMessage obj); - -SignalFfiError *signal_sender_key_distribution_message_get_signature_key(SignalMutPointerPublicKey *out, SignalConstPointerSenderKeyDistributionMessage m); - -SignalFfiError *signal_sender_key_distribution_message_new(SignalMutPointerSenderKeyDistributionMessage *out, uint8_t message_version, SignalUuid distribution_id, uint32_t chain_id, uint32_t iteration, SignalBorrowedBuffer chainkey, SignalConstPointerPublicKey pk); - -SignalFfiError *signal_sender_key_distribution_message_serialize(SignalOwnedBuffer *out, SignalConstPointerSenderKeyDistributionMessage obj); - -SignalFfiError *signal_sender_key_message_clone(SignalMutPointerSenderKeyMessage *new_obj, SignalConstPointerSenderKeyMessage obj); - -SignalFfiError *signal_sender_key_message_deserialize(SignalMutPointerSenderKeyMessage *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_sender_key_message_destroy(SignalMutPointerSenderKeyMessage p); - -SignalFfiError *signal_sender_key_message_get_chain_id(uint32_t *out, SignalConstPointerSenderKeyMessage obj); - -SignalFfiError *signal_sender_key_message_get_cipher_text(SignalOwnedBuffer *out, SignalConstPointerSenderKeyMessage obj); - -SignalFfiError *signal_sender_key_message_get_distribution_id(SignalUuid *out, SignalConstPointerSenderKeyMessage obj); - -SignalFfiError *signal_sender_key_message_get_iteration(uint32_t *out, SignalConstPointerSenderKeyMessage obj); - -SignalFfiError *signal_sender_key_message_new(SignalMutPointerSenderKeyMessage *out, uint8_t message_version, SignalUuid distribution_id, uint32_t chain_id, uint32_t iteration, SignalBorrowedBuffer ciphertext, SignalConstPointerPrivateKey pk); - -SignalFfiError *signal_sender_key_message_serialize(SignalOwnedBuffer *out, SignalConstPointerSenderKeyMessage obj); - -SignalFfiError *signal_sender_key_message_verify_signature(bool *out, SignalConstPointerSenderKeyMessage skm, SignalConstPointerPublicKey pubkey); - -SignalFfiError *signal_sender_key_record_clone(SignalMutPointerSenderKeyRecord *new_obj, SignalConstPointerSenderKeyRecord obj); - -SignalFfiError *signal_sender_key_record_deserialize(SignalMutPointerSenderKeyRecord *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_sender_key_record_destroy(SignalMutPointerSenderKeyRecord p); - -SignalFfiError *signal_sender_key_record_serialize(SignalOwnedBuffer *out, SignalConstPointerSenderKeyRecord obj); - -SignalFfiError *signal_server_certificate_clone(SignalMutPointerServerCertificate *new_obj, SignalConstPointerServerCertificate obj); - -SignalFfiError *signal_server_certificate_deserialize(SignalMutPointerServerCertificate *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_server_certificate_destroy(SignalMutPointerServerCertificate p); - -SignalFfiError *signal_server_certificate_get_certificate(SignalOwnedBuffer *out, SignalConstPointerServerCertificate obj); - -SignalFfiError *signal_server_certificate_get_key(SignalMutPointerPublicKey *out, SignalConstPointerServerCertificate obj); - -SignalFfiError *signal_server_certificate_get_key_id(uint32_t *out, SignalConstPointerServerCertificate obj); - -SignalFfiError *signal_server_certificate_get_serialized(SignalOwnedBuffer *out, SignalConstPointerServerCertificate obj); - -SignalFfiError *signal_server_certificate_get_signature(SignalOwnedBuffer *out, SignalConstPointerServerCertificate obj); - -SignalFfiError *signal_server_certificate_new(SignalMutPointerServerCertificate *out, uint32_t key_id, SignalConstPointerPublicKey server_key, SignalConstPointerPrivateKey trust_root); - -SignalFfiError *signal_server_message_ack_destroy(SignalMutPointerServerMessageAck p); - -SignalFfiError *signal_server_message_ack_send(SignalConstPointerServerMessageAck ack); - -SignalFfiError *signal_server_public_params_create_auth_credential_with_pni_presentation_deterministic(SignalOwnedBuffer *out, SignalConstPointerServerPublicParams server_public_params, const uint8_t (*randomness)[SignalRANDOMNESS_LEN], const unsigned char (*group_secret_params)[SignalGROUP_SECRET_PARAMS_LEN], SignalBorrowedBuffer auth_credential_with_pni_bytes); - -SignalFfiError *signal_server_public_params_create_expiring_profile_key_credential_presentation_deterministic(SignalOwnedBuffer *out, SignalConstPointerServerPublicParams server_public_params, const uint8_t (*randomness)[SignalRANDOMNESS_LEN], const unsigned char (*group_secret_params)[SignalGROUP_SECRET_PARAMS_LEN], const unsigned char (*profile_key_credential)[SignalEXPIRING_PROFILE_KEY_CREDENTIAL_LEN]); - -SignalFfiError *signal_server_public_params_create_profile_key_credential_request_context_deterministic(unsigned char (*out)[SignalPROFILE_KEY_CREDENTIAL_REQUEST_CONTEXT_LEN], SignalConstPointerServerPublicParams server_public_params, const uint8_t (*randomness)[SignalRANDOMNESS_LEN], const SignalServiceIdFixedWidthBinaryBytes *user_id, const unsigned char (*profile_key)[SignalPROFILE_KEY_LEN]); - -SignalFfiError *signal_server_public_params_create_receipt_credential_presentation_deterministic(unsigned char (*out)[SignalRECEIPT_CREDENTIAL_PRESENTATION_LEN], SignalConstPointerServerPublicParams server_public_params, const uint8_t (*randomness)[SignalRANDOMNESS_LEN], const unsigned char (*receipt_credential)[SignalRECEIPT_CREDENTIAL_LEN]); - -SignalFfiError *signal_server_public_params_create_receipt_credential_request_context_deterministic(unsigned char (*out)[SignalRECEIPT_CREDENTIAL_REQUEST_CONTEXT_LEN], SignalConstPointerServerPublicParams server_public_params, const uint8_t (*randomness)[SignalRANDOMNESS_LEN], const uint8_t (*receipt_serial)[SignalRECEIPT_SERIAL_LEN]); - -SignalFfiError *signal_server_public_params_deserialize(SignalMutPointerServerPublicParams *out, SignalBorrowedBuffer buffer); - -SignalFfiError *signal_server_public_params_destroy(SignalMutPointerServerPublicParams p); - -SignalFfiError *signal_server_public_params_get_endorsement_public_key(SignalOwnedBuffer *out, SignalConstPointerServerPublicParams params); - -SignalFfiError *signal_server_public_params_receive_auth_credential_with_pni_as_service_id(SignalOwnedBuffer *out, SignalConstPointerServerPublicParams params, const SignalServiceIdFixedWidthBinaryBytes *aci, const SignalServiceIdFixedWidthBinaryBytes *pni, uint64_t redemption_time, SignalBorrowedBuffer auth_credential_with_pni_response_bytes); - -SignalFfiError *signal_server_public_params_receive_expiring_profile_key_credential(unsigned char (*out)[SignalEXPIRING_PROFILE_KEY_CREDENTIAL_LEN], SignalConstPointerServerPublicParams server_public_params, const unsigned char (*request_context)[SignalPROFILE_KEY_CREDENTIAL_REQUEST_CONTEXT_LEN], const unsigned char (*response)[SignalEXPIRING_PROFILE_KEY_CREDENTIAL_RESPONSE_LEN], uint64_t current_time_in_seconds); - -SignalFfiError *signal_server_public_params_receive_receipt_credential(unsigned char (*out)[SignalRECEIPT_CREDENTIAL_LEN], SignalConstPointerServerPublicParams server_public_params, const unsigned char (*request_context)[SignalRECEIPT_CREDENTIAL_REQUEST_CONTEXT_LEN], const unsigned char (*response)[SignalRECEIPT_CREDENTIAL_RESPONSE_LEN]); - -SignalFfiError *signal_server_public_params_serialize(SignalOwnedBuffer *out, SignalConstPointerServerPublicParams handle); - -SignalFfiError *signal_server_public_params_verify_signature(SignalConstPointerServerPublicParams server_public_params, SignalBorrowedBuffer message, const uint8_t (*notary_signature)[SignalSIGNATURE_LEN]); - -SignalFfiError *signal_server_secret_params_deserialize(SignalMutPointerServerSecretParams *out, SignalBorrowedBuffer buffer); - -SignalFfiError *signal_server_secret_params_destroy(SignalMutPointerServerSecretParams p); - -SignalFfiError *signal_server_secret_params_generate_deterministic(SignalMutPointerServerSecretParams *out, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_server_secret_params_get_public_params(SignalMutPointerServerPublicParams *out, SignalConstPointerServerSecretParams params); - -SignalFfiError *signal_server_secret_params_issue_auth_credential_with_pni_zkc_deterministic(SignalOwnedBuffer *out, SignalConstPointerServerSecretParams server_secret_params, const uint8_t (*randomness)[SignalRANDOMNESS_LEN], const SignalServiceIdFixedWidthBinaryBytes *aci, const SignalServiceIdFixedWidthBinaryBytes *pni, uint64_t redemption_time); - -SignalFfiError *signal_server_secret_params_issue_expiring_profile_key_credential_deterministic(unsigned char (*out)[SignalEXPIRING_PROFILE_KEY_CREDENTIAL_RESPONSE_LEN], SignalConstPointerServerSecretParams server_secret_params, const uint8_t (*randomness)[SignalRANDOMNESS_LEN], const unsigned char (*request)[SignalPROFILE_KEY_CREDENTIAL_REQUEST_LEN], const SignalServiceIdFixedWidthBinaryBytes *user_id, const unsigned char (*commitment)[SignalPROFILE_KEY_COMMITMENT_LEN], uint64_t expiration_in_seconds); - -SignalFfiError *signal_server_secret_params_issue_receipt_credential_deterministic(unsigned char (*out)[SignalRECEIPT_CREDENTIAL_RESPONSE_LEN], SignalConstPointerServerSecretParams server_secret_params, const uint8_t (*randomness)[SignalRANDOMNESS_LEN], const unsigned char (*request)[SignalRECEIPT_CREDENTIAL_REQUEST_LEN], uint64_t receipt_expiration_time, uint64_t receipt_level); - -SignalFfiError *signal_server_secret_params_serialize(SignalOwnedBuffer *out, SignalConstPointerServerSecretParams handle); - -SignalFfiError *signal_server_secret_params_sign_deterministic(uint8_t (*out)[SignalSIGNATURE_LEN], SignalConstPointerServerSecretParams params, const uint8_t (*randomness)[SignalRANDOMNESS_LEN], SignalBorrowedBuffer message); - -SignalFfiError *signal_server_secret_params_verify_auth_credential_presentation(SignalConstPointerServerSecretParams server_secret_params, const unsigned char (*group_public_params)[SignalGROUP_PUBLIC_PARAMS_LEN], SignalBorrowedBuffer presentation_bytes, uint64_t current_time_in_seconds); - -SignalFfiError *signal_server_secret_params_verify_profile_key_credential_presentation(SignalConstPointerServerSecretParams server_secret_params, const unsigned char (*group_public_params)[SignalGROUP_PUBLIC_PARAMS_LEN], SignalBorrowedBuffer presentation_bytes, uint64_t current_time_in_seconds); - -SignalFfiError *signal_server_secret_params_verify_receipt_credential_presentation(SignalConstPointerServerSecretParams server_secret_params, const unsigned char (*presentation)[SignalRECEIPT_CREDENTIAL_PRESENTATION_LEN]); - -SignalFfiError *signal_service_id_parse_from_service_id_binary(SignalServiceIdFixedWidthBinaryBytes *out, SignalBorrowedBuffer input); - -SignalFfiError *signal_service_id_parse_from_service_id_string(SignalServiceIdFixedWidthBinaryBytes *out, SignalCStringPtr input); - -SignalFfiError *signal_service_id_service_id_binary(SignalOwnedBuffer *out, const SignalServiceIdFixedWidthBinaryBytes *value); - -SignalFfiError *signal_service_id_service_id_log(SignalCStringPtr *out, const SignalServiceIdFixedWidthBinaryBytes *value); - -SignalFfiError *signal_service_id_service_id_string(SignalCStringPtr *out, const SignalServiceIdFixedWidthBinaryBytes *value); - -SignalFfiError *signal_session_record_archive_current_state(SignalMutPointerSessionRecord session_record); - -SignalFfiError *signal_session_record_clone(SignalMutPointerSessionRecord *new_obj, SignalConstPointerSessionRecord obj); - -SignalFfiError *signal_session_record_current_ratchet_key_matches(bool *out, SignalConstPointerSessionRecord s, SignalConstPointerPublicKey key); - -SignalFfiError *signal_session_record_deserialize(SignalMutPointerSessionRecord *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_session_record_destroy(SignalMutPointerSessionRecord p); - -SignalFfiError *signal_session_record_get_local_registration_id(uint32_t *out, SignalConstPointerSessionRecord obj); - -SignalFfiError *signal_session_record_get_remote_registration_id(uint32_t *out, SignalConstPointerSessionRecord obj); - -SignalFfiError *signal_session_record_has_usable_sender_chain(bool *out, SignalConstPointerSessionRecord s, double require_pq_ratio, uint64_t now); - -SignalFfiError *signal_session_record_serialize(SignalOwnedBuffer *out, SignalConstPointerSessionRecord obj); - -SignalFfiError *signal_sgx_client_state_complete_handshake(SignalMutPointerSgxClientState cli, SignalBorrowedBuffer handshake_received); - -SignalFfiError *signal_sgx_client_state_destroy(SignalMutPointerSgxClientState p); - -SignalFfiError *signal_sgx_client_state_established_recv(SignalOwnedBuffer *out, SignalMutPointerSgxClientState cli, SignalBorrowedBuffer received_ciphertext); - -SignalFfiError *signal_sgx_client_state_established_send(SignalOwnedBuffer *out, SignalMutPointerSgxClientState cli, SignalBorrowedBuffer plaintext_to_send); - -SignalFfiError *signal_sgx_client_state_initial_request(SignalOwnedBuffer *out, SignalConstPointerSgxClientState obj); - -SignalFfiError *signal_signal_media_check_available(void); - -SignalFfiError *signal_signed_pre_key_record_clone(SignalMutPointerSignedPreKeyRecord *new_obj, SignalConstPointerSignedPreKeyRecord obj); - -SignalFfiError *signal_signed_pre_key_record_deserialize(SignalMutPointerSignedPreKeyRecord *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_signed_pre_key_record_destroy(SignalMutPointerSignedPreKeyRecord p); - -SignalFfiError *signal_signed_pre_key_record_get_id(uint32_t *out, SignalConstPointerSignedPreKeyRecord obj); - -SignalFfiError *signal_signed_pre_key_record_get_private_key(SignalMutPointerPrivateKey *out, SignalConstPointerSignedPreKeyRecord obj); - -SignalFfiError *signal_signed_pre_key_record_get_public_key(SignalMutPointerPublicKey *out, SignalConstPointerSignedPreKeyRecord obj); - -SignalFfiError *signal_signed_pre_key_record_get_signature(SignalOwnedBuffer *out, SignalConstPointerSignedPreKeyRecord obj); - -SignalFfiError *signal_signed_pre_key_record_get_timestamp(uint64_t *out, SignalConstPointerSignedPreKeyRecord obj); - -SignalFfiError *signal_signed_pre_key_record_new(SignalMutPointerSignedPreKeyRecord *out, uint32_t id, uint64_t timestamp, SignalConstPointerPublicKey pub_key, SignalConstPointerPrivateKey priv_key, SignalBorrowedBuffer signature); - -SignalFfiError *signal_signed_pre_key_record_serialize(SignalOwnedBuffer *out, SignalConstPointerSignedPreKeyRecord obj); - -SignalFfiError *signal_svr2_client_new(SignalMutPointerSgxClientState *out, SignalBorrowedBuffer mrenclave, SignalBorrowedBuffer attestation_msg, uint64_t current_timestamp); - -SignalFfiError *signal_tokio_async_context_cancel(SignalConstPointerTokioAsyncContext context, uint64_t raw_cancellation_id); - -SignalFfiError *signal_tokio_async_context_destroy(SignalMutPointerTokioAsyncContext p); - -SignalFfiError *signal_tokio_async_context_new(SignalMutPointerTokioAsyncContext *out); - -SignalFfiError *signal_unauthenticated_chat_connection_account_exists(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, const SignalServiceIdFixedWidthBinaryBytes *account); - -SignalFfiError *signal_unauthenticated_chat_connection_backup_copy_media(SignalMutPointerCopyBackupMediaStream *out, SignalConstPointerUnauthenticatedChatConnection chat, SignalBorrowedBuffer credential, SignalBorrowedBuffer server_keys, SignalConstPointerPrivateKey signing_key, SignalBorrowedSliceOfBridgeCopyBackupMediaItemFfiArg items, int64_t rng); - -SignalFfiError *signal_unauthenticated_chat_connection_backup_delete_all(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, SignalBorrowedBuffer credential, SignalBorrowedBuffer server_keys, SignalConstPointerPrivateKey signing_key, int64_t rng); - -SignalFfiError *signal_unauthenticated_chat_connection_backup_get_cdn_credentials(SignalCPromisePairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, SignalBorrowedBuffer credential, SignalBorrowedBuffer server_keys, SignalConstPointerPrivateKey signing_key, int32_t cdn, int64_t rng); - -SignalFfiError *signal_unauthenticated_chat_connection_backup_get_media_upload_form(SignalCPromiseFfiUploadForm *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, SignalBorrowedBuffer credential, SignalBorrowedBuffer server_keys, SignalConstPointerPrivateKey signing_key, uint64_t upload_size, int64_t rng); - -SignalFfiError *signal_unauthenticated_chat_connection_backup_get_svrb_credentials(SignalCPromisePairOfCStringPtrCStringPtr *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, SignalBorrowedBuffer credential, SignalBorrowedBuffer server_keys, SignalConstPointerPrivateKey signing_key, int64_t rng); - -SignalFfiError *signal_unauthenticated_chat_connection_backup_get_upload_form(SignalCPromiseFfiUploadForm *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, SignalBorrowedBuffer credential, SignalBorrowedBuffer server_keys, SignalConstPointerPrivateKey signing_key, uint64_t upload_size, int64_t rng); - -SignalFfiError *signal_unauthenticated_chat_connection_backup_refresh(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, SignalBorrowedBuffer credential, SignalBorrowedBuffer server_keys, SignalConstPointerPrivateKey signing_key, int64_t rng); - -SignalFfiError *signal_unauthenticated_chat_connection_backup_set_public_key(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, SignalBorrowedBuffer credential, SignalBorrowedBuffer server_keys, SignalConstPointerPrivateKey signing_key, int64_t rng); - -SignalFfiError *signal_unauthenticated_chat_connection_connect(SignalCPromiseMutPointerUnauthenticatedChatConnection *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerConnectionManager connection_manager, SignalBorrowedBytestringArray languages); - -SignalFfiError *signal_unauthenticated_chat_connection_destroy(SignalMutPointerUnauthenticatedChatConnection p); - -SignalFfiError *signal_unauthenticated_chat_connection_disconnect(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat); - -SignalFfiError *signal_unauthenticated_chat_connection_get_pre_keys_access_key_auth(SignalCPromiseFfiPreKeysResponse *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, const uint8_t (*auth)[16], const SignalServiceIdFixedWidthBinaryBytes *target, int32_t device); - -SignalFfiError *signal_unauthenticated_chat_connection_get_pre_keys_group_auth(SignalCPromiseFfiPreKeysResponse *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, SignalBorrowedBuffer auth, const SignalServiceIdFixedWidthBinaryBytes *target, int32_t device); - -SignalFfiError *signal_unauthenticated_chat_connection_get_pre_keys_unrestricted_auth(SignalCPromiseFfiPreKeysResponse *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, const SignalServiceIdFixedWidthBinaryBytes *target, int32_t device); - -SignalFfiError *signal_unauthenticated_chat_connection_info(SignalMutPointerChatConnectionInfo *out, SignalConstPointerUnauthenticatedChatConnection chat); - -SignalFfiError *signal_unauthenticated_chat_connection_init_listener(SignalConstPointerUnauthenticatedChatConnection chat, SignalConstPointerFfiChatListenerStruct listener); - -SignalFfiError *signal_unauthenticated_chat_connection_look_up_username_hash(SignalCPromiseOptionalUuid *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, SignalBorrowedBuffer hash); - -SignalFfiError *signal_unauthenticated_chat_connection_look_up_username_link(SignalCPromiseOptionalPairOfCStringPtru832 *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, SignalUuid uuid, SignalBorrowedBuffer entropy); - -SignalFfiError *signal_unauthenticated_chat_connection_send(SignalCPromiseFfiChatResponse *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, SignalConstPointerHttpRequest http_request, uint32_t timeout_millis); - -SignalFfiError *signal_unauthenticated_chat_connection_send_message(SignalCPromisebool *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, const SignalServiceIdFixedWidthBinaryBytes *destination, uint64_t timestamp, SignalBorrowedSliceOfu32 device_ids, SignalBorrowedSliceOfu32 registration_ids, SignalBorrowedSliceOfBuffers contents, uint8_t auth_kind, SignalOptionalBorrowedSliceOfc_uchar auth_buffer, bool online_only, bool is_urgent); - -SignalFfiError *signal_unauthenticated_chat_connection_send_multi_recipient_message(SignalCPromiseOwnedBufferOfServiceIdFixedWidthBinaryBytes *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, SignalBorrowedBuffer payload, uint64_t timestamp, SignalBorrowedBuffer auth, bool online_only, bool is_urgent); - -SignalFfiError *signal_unauthenticated_chat_connection_send_raw_grpc(SignalCPromiseOwnedBufferOfc_uchar *promise, SignalConstPointerTokioAsyncContext async_runtime, SignalConstPointerUnauthenticatedChatConnection chat, SignalCStringPtr service, SignalCStringPtr method, SignalBorrowedBuffer payload); - -SignalFfiError *signal_unidentified_sender_message_content_deserialize(SignalMutPointerUnidentifiedSenderMessageContent *out, SignalBorrowedBuffer data); - -SignalFfiError *signal_unidentified_sender_message_content_destroy(SignalMutPointerUnidentifiedSenderMessageContent p); - -SignalFfiError *signal_unidentified_sender_message_content_get_content_hint(uint32_t *out, SignalConstPointerUnidentifiedSenderMessageContent m); - -SignalFfiError *signal_unidentified_sender_message_content_get_contents(SignalOwnedBuffer *out, SignalConstPointerUnidentifiedSenderMessageContent obj); - -SignalFfiError *signal_unidentified_sender_message_content_get_group_id_or_empty(SignalOwnedBuffer *out, SignalConstPointerUnidentifiedSenderMessageContent m); - -SignalFfiError *signal_unidentified_sender_message_content_get_msg_type(uint8_t *out, SignalConstPointerUnidentifiedSenderMessageContent m); - -SignalFfiError *signal_unidentified_sender_message_content_get_sender_cert(SignalMutPointerSenderCertificate *out, SignalConstPointerUnidentifiedSenderMessageContent m); - -SignalFfiError *signal_unidentified_sender_message_content_new(SignalMutPointerUnidentifiedSenderMessageContent *out, SignalConstPointerCiphertextMessage message, SignalConstPointerSenderCertificate sender, uint32_t content_hint, SignalBorrowedBuffer group_id); - -SignalFfiError *signal_unidentified_sender_message_content_new_from_content_and_type(SignalMutPointerUnidentifiedSenderMessageContent *out, SignalBorrowedBuffer message_content, uint8_t message_type, SignalConstPointerSenderCertificate sender, uint32_t content_hint, SignalBorrowedBuffer group_id); - -SignalFfiError *signal_unidentified_sender_message_content_serialize(SignalOwnedBuffer *out, SignalConstPointerUnidentifiedSenderMessageContent obj); - -SignalFfiError *signal_username_candidates_from(SignalStringArray *out, SignalCStringPtr nickname, uint32_t min_len, uint32_t max_len); - -SignalFfiError *signal_username_hash(uint8_t (*out)[32], SignalCStringPtr username); - -SignalFfiError *signal_username_hash_from_parts(uint8_t (*out)[32], SignalCStringPtr nickname, SignalCStringPtr discriminator, uint32_t min_len, uint32_t max_len); - -SignalFfiError *signal_username_link_create(SignalOwnedBuffer *out, SignalCStringPtr username, SignalBorrowedBuffer entropy); - -SignalFfiError *signal_username_link_decrypt_username(SignalCStringPtr *out, SignalBorrowedBuffer entropy, SignalBorrowedBuffer encrypted_username); - -SignalFfiError *signal_username_proof(SignalOwnedBuffer *out, SignalCStringPtr username, const uint8_t (*randomness)[32]); - -SignalFfiError *signal_username_verify(SignalBorrowedBuffer proof, SignalBorrowedBuffer hash); - -SignalFfiError *signal_uuid_ciphertext_check_valid_contents(SignalBorrowedBuffer buffer); - -SignalFfiError *signal_validating_mac_destroy(SignalMutPointerValidatingMac p); - -SignalFfiError *signal_validating_mac_finalize(int32_t *out, SignalMutPointerValidatingMac mac); - -SignalFfiError *signal_validating_mac_initialize(SignalMutPointerValidatingMac *out, SignalBorrowedBuffer key, uint32_t chunk_size, SignalBorrowedBuffer digests); - -SignalFfiError *signal_validating_mac_update(int32_t *out, SignalMutPointerValidatingMac mac, SignalBorrowedBuffer bytes, uint32_t offset, uint32_t length); - -SignalFfiError *signal_webp_sanitizer_sanitize(SignalConstPointerFfiSyncInputStreamStruct input); - -SignalFfiError *signal_zk_credential_key_pair_check_valid_contents(SignalBorrowedBuffer key_pair_bytes); - -SignalFfiError *signal_zk_credential_key_pair_generate_deterministic(SignalOwnedBuffer *out, const uint8_t (*randomness)[SignalRANDOMNESS_LEN]); - -SignalFfiError *signal_zk_credential_key_pair_get_public_key(SignalOwnedBuffer *out, SignalBorrowedBuffer key_pair_bytes); - -SignalFfiError *signal_zk_credential_public_key_check_valid_contents(SignalBorrowedBuffer public_key_bytes); - -#endif /* SIGNAL_FFI_H_ */ +static_assert_64bit(offsetof(SignalFfiLoggerStruct, ctx) == 0); +static_assert_64bit(offsetof(SignalFfiLoggerStruct, log) == 8); +static_assert_64bit(offsetof(SignalFfiLoggerStruct, flush) == 16); +static_assert_64bit(offsetof(SignalFfiLoggerStruct, destroy) == 24); +static_assert_64bit(sizeof(SignalFfiLoggerStruct) == 32); +static_assert_64bit(alignof(SignalFfiLoggerStruct) == 8); +SignalFfiError* signal_account_entropy_pool_derive_backup_key( + SignalType_FixedArray32_uint8_t* out, + const int8_t* account_entropy +); +SignalFfiError* signal_account_entropy_pool_derive_svr_key( + SignalType_FixedArray32_uint8_t* out, + const int8_t* account_entropy +); +SignalFfiError* signal_account_entropy_pool_generate( + SignalCStringPtr* out +); +SignalFfiError* signal_account_entropy_pool_is_valid( + bool* out, + const int8_t* account_entropy +); +SignalFfiError* signal_address_clone( + SignalMutPointerProtocolAddress* new_obj, + SignalConstPointerProtocolAddress obj +); +SignalFfiError* signal_address_destroy( + SignalMutPointerProtocolAddress p +); +SignalFfiError* signal_address_get_device_id( + uint32_t* out, + SignalConstPointerProtocolAddress obj +); +SignalFfiError* signal_address_get_name( + SignalCStringPtr* out, + SignalConstPointerProtocolAddress obj +); +SignalFfiError* signal_address_new( + SignalMutPointerProtocolAddress* out, + const int8_t* name, + uint32_t device_id +); +SignalFfiError* signal_aes256_ctr32_destroy( + SignalMutPointerAes256Ctr32 p +); +SignalFfiError* signal_aes256_ctr32_new( + SignalMutPointerAes256Ctr32* out, + SignalBorrowedBuffer key, + SignalBorrowedBuffer nonce, + uint32_t initial_ctr +); +SignalFfiError* signal_aes256_ctr32_process( + SignalMutPointerAes256Ctr32 ctr, + SignalBorrowedMutableBuffer data, + uint32_t offset, + uint32_t length +); +SignalFfiError* signal_aes256_gcm_decryption_destroy( + SignalMutPointerAes256GcmDecryption p +); +SignalFfiError* signal_aes256_gcm_decryption_new( + SignalMutPointerAes256GcmDecryption* out, + SignalBorrowedBuffer key, + SignalBorrowedBuffer nonce, + SignalBorrowedBuffer associated_data +); +SignalFfiError* signal_aes256_gcm_decryption_update( + SignalMutPointerAes256GcmDecryption gcm, + SignalBorrowedMutableBuffer data, + uint32_t offset, + uint32_t length +); +SignalFfiError* signal_aes256_gcm_decryption_verify_tag( + bool* out, + SignalMutPointerAes256GcmDecryption gcm, + SignalBorrowedBuffer tag +); +SignalFfiError* signal_aes256_gcm_encryption_compute_tag( + SignalOwnedBuffer* out, + SignalMutPointerAes256GcmEncryption gcm +); +SignalFfiError* signal_aes256_gcm_encryption_destroy( + SignalMutPointerAes256GcmEncryption p +); +SignalFfiError* signal_aes256_gcm_encryption_new( + SignalMutPointerAes256GcmEncryption* out, + SignalBorrowedBuffer key, + SignalBorrowedBuffer nonce, + SignalBorrowedBuffer associated_data +); +SignalFfiError* signal_aes256_gcm_encryption_update( + SignalMutPointerAes256GcmEncryption gcm, + SignalBorrowedMutableBuffer data, + uint32_t offset, + uint32_t length +); +SignalFfiError* signal_aes256_gcm_siv_decrypt( + SignalOwnedBuffer* out, + SignalConstPointerAes256GcmSiv aes_gcm_siv, + SignalBorrowedBuffer ctext, + SignalBorrowedBuffer nonce, + SignalBorrowedBuffer associated_data +); +SignalFfiError* signal_aes256_gcm_siv_destroy( + SignalMutPointerAes256GcmSiv p +); +SignalFfiError* signal_aes256_gcm_siv_encrypt( + SignalOwnedBuffer* out, + SignalConstPointerAes256GcmSiv aes_gcm_siv_obj, + SignalBorrowedBuffer ptext, + SignalBorrowedBuffer nonce, + SignalBorrowedBuffer associated_data +); +SignalFfiError* signal_aes256_gcm_siv_new( + SignalMutPointerAes256GcmSiv* out, + SignalBorrowedBuffer key +); +SignalFfiError* signal_auth_credential_presentation_check_valid_contents( + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_auth_credential_presentation_get_pni_ciphertext( + SignalType_FixedArray65_uint8_t* out, + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_auth_credential_presentation_get_redemption_time( + uint64_t* out, + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_auth_credential_presentation_get_uuid_ciphertext( + SignalType_FixedArray65_uint8_t* out, + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_auth_credential_with_pni_check_valid_contents( + SignalBorrowedBuffer bytes +); +SignalFfiError* signal_auth_credential_with_pni_response_check_valid_contents( + SignalBorrowedBuffer bytes +); +SignalFfiError* signal_authenticated_chat_connection_clear_push_token( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat +); +SignalFfiError* signal_authenticated_chat_connection_clear_registration_lock( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat +); +SignalFfiError* signal_authenticated_chat_connection_connect( + SignalCPromiseMutPointerAuthenticatedChatConnection* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerConnectionManager connection_manager, + const int8_t* username, + const int8_t* password, + bool receive_stories, + SignalBorrowedBytestringArray languages +); +SignalFfiError* signal_authenticated_chat_connection_delete_username_hash( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat +); +SignalFfiError* signal_authenticated_chat_connection_delete_username_link( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat +); +SignalFfiError* signal_authenticated_chat_connection_destroy( + SignalMutPointerAuthenticatedChatConnection p +); +SignalFfiError* signal_authenticated_chat_connection_disconnect( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat +); +SignalFfiError* signal_authenticated_chat_connection_get_devices( + SignalCPromiseOwnedBufferOfMaxAlignedLinkedDeviceInternalFfiResult* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat +); +SignalFfiError* signal_authenticated_chat_connection_get_upload_form( + SignalCPromiseFfiUploadForm* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat, + uint64_t upload_length +); +SignalFfiError* signal_authenticated_chat_connection_info( + SignalMutPointerChatConnectionInfo* out, + SignalConstPointerAuthenticatedChatConnection chat +); +SignalFfiError* signal_authenticated_chat_connection_init_listener( + SignalConstPointerAuthenticatedChatConnection chat, + SignalConstPointerFfiChatListenerStruct listener +); +SignalFfiError* signal_authenticated_chat_connection_preconnect( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerConnectionManager connection_manager +); +SignalFfiError* signal_authenticated_chat_connection_remove_device( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat, + uint8_t device_id +); +SignalFfiError* signal_authenticated_chat_connection_reserve_username_hash( + SignalCPromisec_uchar32* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat, + SignalBorrowedSliceOfc_uchar32 username_hashes +); +SignalFfiError* signal_authenticated_chat_connection_send( + SignalCPromiseFfiChatResponse* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat, + SignalConstPointerHttpRequest http_request, + uint32_t timeout_millis +); +SignalFfiError* signal_authenticated_chat_connection_send_message( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat, + const SignalType_FixedArray17_uint8_t* destination, + uint64_t timestamp, + SignalBorrowedSliceOfu32 device_ids, + SignalBorrowedSliceOfu32 registration_ids, + SignalBorrowedSliceOfConstPointerCiphertextMessage contents, + bool online_only, + bool is_urgent +); +SignalFfiError* signal_authenticated_chat_connection_send_raw_grpc( + SignalCPromiseOwnedBuffer* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat, + const int8_t* service, + const int8_t* method, + SignalBorrowedBuffer payload +); +SignalFfiError* signal_authenticated_chat_connection_send_sync_message( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat, + uint64_t timestamp, + SignalBorrowedSliceOfu32 device_ids, + SignalBorrowedSliceOfu32 registration_ids, + SignalBorrowedSliceOfConstPointerCiphertextMessage contents, + bool is_urgent +); +SignalFfiError* signal_authenticated_chat_connection_set_device_name( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat, + uint8_t device_id, + SignalBorrowedBuffer encrypted_name +); +SignalFfiError* signal_authenticated_chat_connection_set_discoverable_by_phone_number( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat, + bool discoverable +); +SignalFfiError* signal_authenticated_chat_connection_set_push_token_apns( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat, + const int8_t* apns_token +); +SignalFfiError* signal_authenticated_chat_connection_set_registration_lock( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat, + const SignalType_FixedArray32_uint8_t* svr_key +); +SignalFfiError* signal_authenticated_chat_connection_set_registration_recovery_password( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat, + const SignalType_FixedArray32_uint8_t* svr_key +); +SignalFfiError* signal_authenticated_chat_connection_set_username_link( + SignalCPromiseUuid* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerAuthenticatedChatConnection chat, + SignalBorrowedBuffer username_ciphertext, + bool keep_link_handle +); +SignalFfiError* signal_avatar_upload_credential_check_valid_contents( + SignalBorrowedBuffer credential_bytes +); +SignalFfiError* signal_avatar_upload_credential_get_cm( + SignalType_FixedArray32_uint8_t* out, + SignalBorrowedBuffer credential_bytes +); +SignalFfiError* signal_avatar_upload_credential_get_redemption_time( + uint64_t* out, + SignalBorrowedBuffer credential_bytes +); +SignalFfiError* signal_avatar_upload_credential_present_deterministic( + SignalOwnedBuffer* out, + SignalBorrowedBuffer credential_bytes, + SignalBorrowedBuffer server_params_bytes, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_avatar_upload_credential_presentation_check_valid_contents( + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_avatar_upload_credential_presentation_get_cm( + SignalType_FixedArray32_uint8_t* out, + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_avatar_upload_credential_presentation_get_redemption_time( + uint64_t* out, + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_avatar_upload_credential_presentation_verify( + SignalBorrowedBuffer presentation_bytes, + uint64_t current_time, + SignalBorrowedBuffer server_params_bytes +); +SignalFfiError* signal_avatar_upload_credential_request_check_valid_contents( + SignalBorrowedBuffer request_bytes +); +SignalFfiError* signal_avatar_upload_credential_request_context_check_valid_contents( + SignalBorrowedBuffer context_bytes +); +SignalFfiError* signal_avatar_upload_credential_request_context_get_request( + SignalOwnedBuffer* out, + SignalBorrowedBuffer context_bytes +); +SignalFfiError* signal_avatar_upload_credential_request_context_new( + SignalOwnedBuffer* out, + const SignalType_FixedArray17_uint8_t* aci, + SignalBorrowedBuffer zk_credential_key_pair_bytes, + uint64_t rotation_id, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_avatar_upload_credential_request_context_receive_response( + SignalOwnedBuffer* out, + SignalBorrowedBuffer context_bytes, + SignalBorrowedBuffer response_bytes, + uint64_t current_time, + SignalBorrowedBuffer params_bytes +); +SignalFfiError* signal_avatar_upload_credential_request_issue_deterministic( + SignalOwnedBuffer* out, + SignalBorrowedBuffer request_bytes, + const SignalType_FixedArray17_uint8_t* aci, + SignalBorrowedBuffer zk_credential_key_pub_bytes, + uint64_t rotation_id, + uint64_t redemption_time, + SignalBorrowedBuffer params_bytes, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_avatar_upload_credential_response_check_valid_contents( + SignalBorrowedBuffer response_bytes +); +SignalFfiError* signal_backup_auth_credential_check_valid_contents( + SignalBorrowedBuffer params_bytes +); +SignalFfiError* signal_backup_auth_credential_get_backup_id( + SignalType_FixedArray16_uint8_t* out, + SignalBorrowedBuffer credential_bytes +); +SignalFfiError* signal_backup_auth_credential_get_backup_level( + uint8_t* out, + SignalBorrowedBuffer credential_bytes +); +SignalFfiError* signal_backup_auth_credential_get_type( + uint8_t* out, + SignalBorrowedBuffer credential_bytes +); +SignalFfiError* signal_backup_auth_credential_present_deterministic( + SignalOwnedBuffer* out, + SignalBorrowedBuffer credential_bytes, + SignalBorrowedBuffer server_params_bytes, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_backup_auth_credential_presentation_check_valid_contents( + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_backup_auth_credential_presentation_verify( + SignalBorrowedBuffer presentation_bytes, + uint64_t now, + SignalBorrowedBuffer server_params_bytes +); +SignalFfiError* signal_backup_auth_credential_request_check_valid_contents( + SignalBorrowedBuffer request_bytes +); +SignalFfiError* signal_backup_auth_credential_request_context_check_valid_contents( + SignalBorrowedBuffer context_bytes +); +SignalFfiError* signal_backup_auth_credential_request_context_get_request( + SignalOwnedBuffer* out, + SignalBorrowedBuffer context_bytes +); +SignalFfiError* signal_backup_auth_credential_request_context_new( + SignalOwnedBuffer* out, + const SignalType_FixedArray32_uint8_t* backup_key, + SignalUuid uuid +); +SignalFfiError* signal_backup_auth_credential_request_context_receive_response( + SignalOwnedBuffer* out, + SignalBorrowedBuffer context_bytes, + SignalBorrowedBuffer response_bytes, + uint64_t expected_redemption_time, + SignalBorrowedBuffer params_bytes +); +SignalFfiError* signal_backup_auth_credential_request_issue_deterministic( + SignalOwnedBuffer* out, + SignalBorrowedBuffer request_bytes, + uint64_t redemption_time, + uint8_t backup_level, + uint8_t credential_type, + SignalBorrowedBuffer params_bytes, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_backup_auth_credential_response_check_valid_contents( + SignalBorrowedBuffer response_bytes +); +SignalFfiError* signal_backup_key_derive_backup_id( + SignalType_FixedArray16_uint8_t* out, + const SignalType_FixedArray32_uint8_t* backup_key, + const SignalType_FixedArray17_uint8_t* aci +); +SignalFfiError* signal_backup_key_derive_ec_key( + SignalMutPointerPrivateKey* out, + const SignalType_FixedArray32_uint8_t* backup_key, + const SignalType_FixedArray17_uint8_t* aci +); +SignalFfiError* signal_backup_key_derive_local_backup_metadata_key( + SignalType_FixedArray32_uint8_t* out, + const SignalType_FixedArray32_uint8_t* backup_key +); +SignalFfiError* signal_backup_key_derive_media_encryption_key( + SignalType_FixedArray64_uint8_t* out, + const SignalType_FixedArray32_uint8_t* backup_key, + const SignalType_FixedArray15_uint8_t* media_id +); +SignalFfiError* signal_backup_key_derive_media_id( + SignalType_FixedArray15_uint8_t* out, + const SignalType_FixedArray32_uint8_t* backup_key, + const int8_t* media_name +); +SignalFfiError* signal_backup_key_derive_thumbnail_transit_encryption_key( + SignalType_FixedArray64_uint8_t* out, + const SignalType_FixedArray32_uint8_t* backup_key, + const SignalType_FixedArray15_uint8_t* media_id +); +SignalFfiError* signal_backup_restore_response_destroy( + SignalMutPointerBackupRestoreResponse p +); +SignalFfiError* signal_backup_restore_response_get_forward_secrecy_token( + SignalType_FixedArray32_uint8_t* out, + SignalConstPointerBackupRestoreResponse response +); +SignalFfiError* signal_backup_restore_response_get_next_backup_secret_data( + SignalOwnedBuffer* out, + SignalConstPointerBackupRestoreResponse response +); +SignalFfiError* signal_backup_store_response_destroy( + SignalMutPointerBackupStoreResponse p +); +SignalFfiError* signal_backup_store_response_get_forward_secrecy_token( + SignalType_FixedArray32_uint8_t* out, + SignalConstPointerBackupStoreResponse response +); +SignalFfiError* signal_backup_store_response_get_next_backup_secret_data( + SignalOwnedBuffer* out, + SignalConstPointerBackupStoreResponse response +); +SignalFfiError* signal_backup_store_response_get_opaque_metadata( + SignalOwnedBuffer* out, + SignalConstPointerBackupStoreResponse response +); +SignalFfiError* signal_bridged_string_map_clone( + SignalMutPointerBridgedStringMap* new_obj, + SignalConstPointerBridgedStringMap obj +); +SignalFfiError* signal_bridged_string_map_destroy( + SignalMutPointerBridgedStringMap p +); +SignalFfiError* signal_bridged_string_map_insert( + SignalMutPointerBridgedStringMap map, + const int8_t* key, + const int8_t* value +); +SignalFfiError* signal_bridged_string_map_new( + SignalMutPointerBridgedStringMap* out, + uint32_t initial_capacity +); +SignalFfiError* signal_call_link_auth_credential_check_valid_contents( + SignalBorrowedBuffer credential_bytes +); +SignalFfiError* signal_call_link_auth_credential_present_deterministic( + SignalOwnedBuffer* out, + SignalBorrowedBuffer credential_bytes, + const SignalType_FixedArray17_uint8_t* user_id, + uint64_t redemption_time, + SignalBorrowedBuffer server_params_bytes, + SignalBorrowedBuffer call_link_params_bytes, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_call_link_auth_credential_presentation_check_valid_contents( + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_call_link_auth_credential_presentation_get_user_id( + SignalType_FixedArray65_uint8_t* out, + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_call_link_auth_credential_presentation_verify( + SignalBorrowedBuffer presentation_bytes, + uint64_t now, + SignalBorrowedBuffer server_params_bytes, + SignalBorrowedBuffer call_link_params_bytes +); +SignalFfiError* signal_call_link_auth_credential_response_check_valid_contents( + SignalBorrowedBuffer response_bytes +); +SignalFfiError* signal_call_link_auth_credential_response_issue_deterministic( + SignalOwnedBuffer* out, + const SignalType_FixedArray17_uint8_t* user_id, + uint64_t redemption_time, + SignalBorrowedBuffer params_bytes, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_call_link_auth_credential_response_receive( + SignalOwnedBuffer* out, + SignalBorrowedBuffer response_bytes, + const SignalType_FixedArray17_uint8_t* user_id, + uint64_t redemption_time, + SignalBorrowedBuffer params_bytes +); +SignalFfiError* signal_call_link_public_params_check_valid_contents( + SignalBorrowedBuffer params_bytes +); +SignalFfiError* signal_call_link_secret_params_check_valid_contents( + SignalBorrowedBuffer params_bytes +); +SignalFfiError* signal_call_link_secret_params_decrypt_user_id( + SignalType_FixedArray17_uint8_t* out, + SignalBorrowedBuffer params_bytes, + const SignalType_FixedArray65_uint8_t* user_id +); +SignalFfiError* signal_call_link_secret_params_derive_from_root_key( + SignalOwnedBuffer* out, + SignalBorrowedBuffer root_key +); +SignalFfiError* signal_call_link_secret_params_encrypt_user_id( + SignalType_FixedArray65_uint8_t* out, + SignalBorrowedBuffer params_bytes, + const SignalType_FixedArray17_uint8_t* user_id +); +SignalFfiError* signal_call_link_secret_params_get_public_params( + SignalOwnedBuffer* out, + SignalBorrowedBuffer params_bytes +); +SignalFfiError* signal_cds2_client_state_new( + SignalMutPointerSgxClientState* out, + SignalBorrowedBuffer mrenclave, + SignalBorrowedBuffer attestation_msg, + uint64_t current_timestamp +); +SignalFfiError* signal_cdsi_lookup_complete( + SignalCPromiseFfiCdsiLookupResponse* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerCdsiLookup lookup +); +SignalFfiError* signal_cdsi_lookup_destroy( + SignalMutPointerCdsiLookup p +); +SignalFfiError* signal_cdsi_lookup_new( + SignalCPromiseMutPointerCdsiLookup* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerConnectionManager connection_manager, + const int8_t* username, + const int8_t* password, + SignalConstPointerLookupRequest request +); +SignalFfiError* signal_cdsi_lookup_token( + SignalOwnedBuffer* out, + SignalConstPointerCdsiLookup lookup +); +SignalFfiError* signal_chat_connection_info_description( + SignalCStringPtr* out, + SignalConstPointerChatConnectionInfo connection_info +); +SignalFfiError* signal_chat_connection_info_destroy( + SignalMutPointerChatConnectionInfo p +); +SignalFfiError* signal_chat_connection_info_ip_version( + uint8_t* out, + SignalConstPointerChatConnectionInfo connection_info +); +SignalFfiError* signal_chat_connection_info_local_port( + uint16_t* out, + SignalConstPointerChatConnectionInfo connection_info +); +SignalFfiError* signal_ciphertext_message_destroy( + SignalMutPointerCiphertextMessage p +); +SignalFfiError* signal_ciphertext_message_from_plaintext_content( + SignalMutPointerCiphertextMessage* out, + SignalConstPointerPlaintextContent m +); +SignalFfiError* signal_ciphertext_message_serialize( + SignalOwnedBuffer* out, + SignalConstPointerCiphertextMessage obj +); +SignalFfiError* signal_ciphertext_message_type( + uint8_t* out, + SignalConstPointerCiphertextMessage msg +); +SignalFfiError* signal_connection_manager_clear_proxy( + SignalConstPointerConnectionManager connection_manager +); +SignalFfiError* signal_connection_manager_destroy( + SignalMutPointerConnectionManager p +); +SignalFfiError* signal_connection_manager_new( + SignalMutPointerConnectionManager* out, + uint8_t environment, + const int8_t* user_agent, + SignalMutPointerBridgedStringMap remote_config, + uint8_t build_variant +); +SignalFfiError* signal_connection_manager_on_network_change( + SignalConstPointerConnectionManager connection_manager +); +SignalFfiError* signal_connection_manager_set_censorship_circumvention_enabled( + SignalConstPointerConnectionManager connection_manager, + bool enabled +); +SignalFfiError* signal_connection_manager_set_invalid_proxy( + SignalConstPointerConnectionManager connection_manager +); +SignalFfiError* signal_connection_manager_set_proxy( + SignalConstPointerConnectionManager connection_manager, + SignalConstPointerConnectionProxyConfig proxy +); +SignalFfiError* signal_connection_manager_set_remote_config( + SignalConstPointerConnectionManager connection_manager, + SignalMutPointerBridgedStringMap remote_config, + uint8_t build_variant +); +SignalFfiError* signal_connection_proxy_config_clone( + SignalMutPointerConnectionProxyConfig* new_obj, + SignalConstPointerConnectionProxyConfig obj +); +SignalFfiError* signal_connection_proxy_config_destroy( + SignalMutPointerConnectionProxyConfig p +); +SignalFfiError* signal_connection_proxy_config_new( + SignalMutPointerConnectionProxyConfig* out, + const int8_t* scheme, + const int8_t* host, + int32_t port, + const int8_t* username, + const int8_t* password +); +SignalFfiError* signal_copy_backup_media_stream_cancel( + SignalConstPointerCopyBackupMediaStream stream +); +SignalFfiError* signal_copy_backup_media_stream_destroy( + SignalMutPointerCopyBackupMediaStream p +); +SignalFfiError* signal_copy_backup_media_stream_next( + SignalCPromiseCopyBackupMediaNextChunkFfiResult* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerCopyBackupMediaStream stream +); +SignalFfiError* signal_create_call_link_credential_check_valid_contents( + SignalBorrowedBuffer params_bytes +); +SignalFfiError* signal_create_call_link_credential_present_deterministic( + SignalOwnedBuffer* out, + SignalBorrowedBuffer credential_bytes, + SignalBorrowedBuffer room_id, + const SignalType_FixedArray17_uint8_t* user_id, + SignalBorrowedBuffer server_params_bytes, + SignalBorrowedBuffer call_link_params_bytes, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_create_call_link_credential_presentation_check_valid_contents( + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_create_call_link_credential_presentation_verify( + SignalBorrowedBuffer presentation_bytes, + SignalBorrowedBuffer room_id, + uint64_t now, + SignalBorrowedBuffer server_params_bytes, + SignalBorrowedBuffer call_link_params_bytes +); +SignalFfiError* signal_create_call_link_credential_request_check_valid_contents( + SignalBorrowedBuffer request_bytes +); +SignalFfiError* signal_create_call_link_credential_request_context_check_valid_contents( + SignalBorrowedBuffer context_bytes +); +SignalFfiError* signal_create_call_link_credential_request_context_get_request( + SignalOwnedBuffer* out, + SignalBorrowedBuffer context_bytes +); +SignalFfiError* signal_create_call_link_credential_request_context_new_deterministic( + SignalOwnedBuffer* out, + SignalBorrowedBuffer room_id, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_create_call_link_credential_request_context_receive_response( + SignalOwnedBuffer* out, + SignalBorrowedBuffer context_bytes, + SignalBorrowedBuffer response_bytes, + const SignalType_FixedArray17_uint8_t* user_id, + SignalBorrowedBuffer params_bytes +); +SignalFfiError* signal_create_call_link_credential_request_issue_deterministic( + SignalOwnedBuffer* out, + SignalBorrowedBuffer request_bytes, + const SignalType_FixedArray17_uint8_t* user_id, + uint64_t timestamp, + SignalBorrowedBuffer params_bytes, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_create_call_link_credential_response_check_valid_contents( + SignalBorrowedBuffer response_bytes +); +SignalFfiError* signal_decrypt_message( + SignalOwnedBuffer* out, + SignalConstPointerSignalMessage message, + SignalConstPointerProtocolAddress protocol_address, + SignalConstPointerProtocolAddress local_address, + SignalConstPointerFfiSessionStoreStruct session_store, + SignalConstPointerFfiIdentityKeyStoreStruct identity_key_store +); +SignalFfiError* signal_decrypt_pre_key_message( + SignalOwnedBuffer* out, + SignalConstPointerPreKeySignalMessage message, + SignalConstPointerProtocolAddress protocol_address, + SignalConstPointerProtocolAddress local_address, + SignalConstPointerFfiSessionStoreStruct session_store, + SignalConstPointerFfiIdentityKeyStoreStruct identity_key_store, + SignalConstPointerFfiPreKeyStoreStruct prekey_store, + SignalConstPointerFfiSignedPreKeyStoreStruct signed_prekey_store, + SignalConstPointerFfiKyberPreKeyStoreStruct kyber_prekey_store +); +SignalFfiError* signal_decryption_error_message_clone( + SignalMutPointerDecryptionErrorMessage* new_obj, + SignalConstPointerDecryptionErrorMessage obj +); +SignalFfiError* signal_decryption_error_message_deserialize( + SignalMutPointerDecryptionErrorMessage* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_decryption_error_message_destroy( + SignalMutPointerDecryptionErrorMessage p +); +SignalFfiError* signal_decryption_error_message_extract_from_serialized_content( + SignalMutPointerDecryptionErrorMessage* out, + SignalBorrowedBuffer bytes +); +SignalFfiError* signal_decryption_error_message_for_original_message( + SignalMutPointerDecryptionErrorMessage* out, + SignalBorrowedBuffer original_bytes, + uint8_t original_type, + uint64_t original_timestamp, + uint32_t original_sender_device_id +); +SignalFfiError* signal_decryption_error_message_get_device_id( + uint32_t* out, + SignalConstPointerDecryptionErrorMessage obj +); +SignalFfiError* signal_decryption_error_message_get_ratchet_key( + SignalMutPointerPublicKey* out, + SignalConstPointerDecryptionErrorMessage m +); +SignalFfiError* signal_decryption_error_message_get_timestamp( + uint64_t* out, + SignalConstPointerDecryptionErrorMessage obj +); +SignalFfiError* signal_decryption_error_message_serialize( + SignalOwnedBuffer* out, + SignalConstPointerDecryptionErrorMessage obj +); +SignalFfiError* signal_delete_backup_media_stream_cancel( + SignalConstPointerDeleteBackupMediaStream stream +); +SignalFfiError* signal_delete_backup_media_stream_destroy( + SignalMutPointerDeleteBackupMediaStream p +); +SignalFfiError* signal_delete_backup_media_stream_next( + SignalCPromiseDeleteBackupMediaNextChunkFfiResult* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerDeleteBackupMediaStream stream +); +SignalFfiError* signal_device_transfer_generate_certificate( + SignalOwnedBuffer* out, + SignalBorrowedBuffer private_key, + const int8_t* name, + uint32_t days_to_expire +); +SignalFfiError* signal_device_transfer_generate_private_key( + SignalOwnedBuffer* out +); +SignalFfiError* signal_device_transfer_generate_private_key_with_format( + SignalOwnedBuffer* out, + uint8_t key_format +); +SignalFfiError* signal_donation_permit_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_donation_permit_derived_key_pair_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_donation_permit_derived_key_pair_for_expiration( + SignalOwnedBuffer* out, + uint64_t timestamp, + SignalConstPointerServerSecretParams root +); +SignalFfiError* signal_donation_permit_expiration( + uint64_t* out, + SignalBorrowedBuffer donation_permit +); +SignalFfiError* signal_donation_permit_request_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_donation_permit_request_context_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_donation_permit_request_context_new_deterministic( + SignalOwnedBuffer* out, + int32_t count, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_donation_permit_request_context_receive( + SignalBytestringArray* out, + SignalBorrowedBuffer context, + SignalBorrowedBuffer response, + SignalConstPointerServerPublicParams public_params, + uint64_t now +); +SignalFfiError* signal_donation_permit_request_context_request( + SignalOwnedBuffer* out, + SignalBorrowedBuffer ctx +); +SignalFfiError* signal_donation_permit_request_len( + int32_t* out, + SignalBorrowedBuffer donation_permit_request +); +SignalFfiError* signal_donation_permit_response_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_donation_permit_response_default_expiration( + uint64_t* out, + uint64_t current_time +); +SignalFfiError* signal_donation_permit_response_get_expiration( + uint64_t* out, + SignalBorrowedBuffer response +); +SignalFfiError* signal_donation_permit_response_issue_deterministic( + SignalOwnedBuffer* out, + SignalBorrowedBuffer request, + SignalBorrowedBuffer key_pair, + const SignalType_FixedArray32_uint8_t* seed +); +SignalFfiError* signal_donation_permit_spend_id( + SignalOwnedBuffer* out, + SignalBorrowedBuffer donation_permit +); +SignalFfiError* signal_donation_permit_verify( + SignalBorrowedBuffer permit, + uint64_t now, + SignalBorrowedBuffer key_pair +); +SignalFfiError* signal_encrypt_message( + SignalMutPointerCiphertextMessage* out, + SignalBorrowedBuffer ptext, + SignalConstPointerProtocolAddress protocol_address, + SignalConstPointerProtocolAddress local_address, + SignalConstPointerFfiSessionStoreStruct session_store, + SignalConstPointerFfiIdentityKeyStoreStruct identity_key_store, + uint64_t now +); +void signal_error_free( + SignalFfiError* err +); +SignalFfiError* signal_error_get_address( + SignalMutPointerProtocolAddress* out, + const SignalFfiError* err +); +SignalFfiError* signal_error_get_invalid_protocol_address( + SignalPairOfCStringPtru32* out, + const SignalFfiError* err +); +SignalFfiError* signal_error_get_message( + SignalCStringPtr* out, + const SignalFfiError* err +); +SignalFfiError* signal_error_get_mismatched_device_errors( + SignalOwnedBufferOfFfiMismatchedDevicesError* out, + const SignalFfiError* err +); +SignalFfiError* signal_error_get_our_fingerprint_version( + uint32_t* out, + const SignalFfiError* err +); +SignalFfiError* signal_error_get_rate_limit_challenge( + SignalPairOfPairOfCStringPtrOwnedBufferi64* out, + const SignalFfiError* err +); +SignalFfiError* signal_error_get_registration_error_not_deliverable( + SignalPairOfCStringPtrbool* out, + const SignalFfiError* err +); +SignalFfiError* signal_error_get_registration_lock( + uint64_t* out_time_remaining_seconds, + SignalPairOfCStringPtrCStringPtr* out_svr2_credentials, + const SignalFfiError* err +); +SignalFfiError* signal_error_get_retry_after_seconds( + uint32_t* out, + const SignalFfiError* err +); +SignalFfiError* signal_error_get_their_fingerprint_version( + uint32_t* out, + const SignalFfiError* err +); +SignalFfiError* signal_error_get_tries_remaining( + uint32_t* out, + const SignalFfiError* err +); +uint32_t signal_error_get_type( + const SignalFfiError* err +); +SignalFfiError* signal_error_get_unknown_fields( + SignalBytestringArray* out, + const SignalFfiError* err +); +SignalFfiError* signal_error_get_uuid( + SignalUuid* out, + const SignalFfiError* err +); +SignalFfiError* signal_expiring_profile_key_credential_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_expiring_profile_key_credential_get_expiration_time( + uint64_t* out, + const SignalType_FixedArray153_uint8_t* credential +); +SignalFfiError* signal_expiring_profile_key_credential_response_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_fingerprint_clone( + SignalMutPointerFingerprint* new_obj, + SignalConstPointerFingerprint obj +); +SignalFfiError* signal_fingerprint_compare( + bool* out, + SignalBorrowedBuffer fprint1, + SignalBorrowedBuffer fprint2 +); +SignalFfiError* signal_fingerprint_destroy( + SignalMutPointerFingerprint p +); +SignalFfiError* signal_fingerprint_display_string( + SignalCStringPtr* out, + SignalConstPointerFingerprint obj +); +SignalFfiError* signal_fingerprint_new( + SignalMutPointerFingerprint* out, + uint32_t iterations, + uint32_t version, + SignalBorrowedBuffer local_identifier, + SignalConstPointerPublicKey local_key, + SignalBorrowedBuffer remote_identifier, + SignalConstPointerPublicKey remote_key +); +SignalFfiError* signal_fingerprint_scannable_encoding( + SignalOwnedBuffer* out, + SignalConstPointerFingerprint obj +); +void signal_free_buffer( + const uint8_t* buf, + size_t buf_len +); +void signal_free_bytestring_array( + SignalBytestringArray array +); +void signal_free_list_of_mismatched_device_errors( + SignalOwnedBufferOfFfiMismatchedDevicesError buffer +); +void signal_free_list_of_register_response_badges( + SignalOwnedBufferOfFfiRegisterResponseBadge buffer +); +void signal_free_list_of_service_ids( + SignalOwnedBufferOfc_uchar17 buffer +); +void signal_free_list_of_strings( + SignalOwnedBufferOfCStringPtr buffer +); +void signal_free_lookup_response_entry_list( + SignalOwnedLookupResponseEntryList buffer +); +void signal_free_outer_buffer_list_of_prekey_bundles( + SignalOwnedBufferOfMutPointerPreKeyBundle buffer +); +void signal_free_owned_buffer_of_max_aligned( + SignalOwnedBufferOfMaxAlignedc_void buffer +); +void signal_free_string( + const int8_t* buf +); +SignalFfiError* signal_generic_server_public_params_check_valid_contents( + SignalBorrowedBuffer params_bytes +); +SignalFfiError* signal_generic_server_secret_params_check_valid_contents( + SignalBorrowedBuffer params_bytes +); +SignalFfiError* signal_generic_server_secret_params_generate_deterministic( + SignalOwnedBuffer* out, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_generic_server_secret_params_get_public_params( + SignalOwnedBuffer* out, + SignalBorrowedBuffer params_bytes +); +SignalFfiError* signal_group_decrypt_message( + SignalOwnedBuffer* out, + SignalConstPointerProtocolAddress sender, + SignalBorrowedBuffer message, + SignalConstPointerFfiSenderKeyStoreStruct store +); +SignalFfiError* signal_group_encrypt_message( + SignalMutPointerCiphertextMessage* out, + SignalConstPointerProtocolAddress sender, + SignalUuid distribution_id, + SignalBorrowedBuffer message, + SignalConstPointerFfiSenderKeyStoreStruct store +); +SignalFfiError* signal_group_master_key_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_group_public_params_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_group_public_params_get_group_identifier( + SignalType_FixedArray32_uint8_t* out, + const SignalType_FixedArray97_uint8_t* group_public_params +); +SignalFfiError* signal_group_secret_params_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_group_secret_params_decrypt_blob_with_padding( + SignalOwnedBuffer* out, + const SignalType_FixedArray289_uint8_t* params, + SignalBorrowedBuffer ciphertext +); +SignalFfiError* signal_group_secret_params_decrypt_profile_key( + SignalType_FixedArray32_uint8_t* out, + const SignalType_FixedArray289_uint8_t* params, + const SignalType_FixedArray65_uint8_t* profile_key, + const SignalType_FixedArray17_uint8_t* user_id +); +SignalFfiError* signal_group_secret_params_decrypt_service_id( + SignalType_FixedArray17_uint8_t* out, + const SignalType_FixedArray289_uint8_t* params, + const SignalType_FixedArray65_uint8_t* ciphertext +); +SignalFfiError* signal_group_secret_params_derive_from_master_key( + SignalType_FixedArray289_uint8_t* out, + const SignalType_FixedArray32_uint8_t* master_key +); +SignalFfiError* signal_group_secret_params_encrypt_blob_with_padding_deterministic( + SignalOwnedBuffer* out, + const SignalType_FixedArray289_uint8_t* params, + const SignalType_FixedArray32_uint8_t* randomness, + SignalBorrowedBuffer plaintext, + uint32_t padding_len +); +SignalFfiError* signal_group_secret_params_encrypt_profile_key( + SignalType_FixedArray65_uint8_t* out, + const SignalType_FixedArray289_uint8_t* params, + const SignalType_FixedArray32_uint8_t* profile_key, + const SignalType_FixedArray17_uint8_t* user_id +); +SignalFfiError* signal_group_secret_params_encrypt_service_id( + SignalType_FixedArray65_uint8_t* out, + const SignalType_FixedArray289_uint8_t* params, + const SignalType_FixedArray17_uint8_t* service_id +); +SignalFfiError* signal_group_secret_params_generate_deterministic( + SignalType_FixedArray289_uint8_t* out, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_group_secret_params_get_master_key( + SignalType_FixedArray32_uint8_t* out, + const SignalType_FixedArray289_uint8_t* params +); +SignalFfiError* signal_group_secret_params_get_public_params( + SignalType_FixedArray97_uint8_t* out, + const SignalType_FixedArray289_uint8_t* params +); +SignalFfiError* signal_group_send_derived_key_pair_check_valid_contents( + SignalBorrowedBuffer bytes +); +SignalFfiError* signal_group_send_derived_key_pair_for_expiration( + SignalOwnedBuffer* out, + uint64_t expiration, + SignalConstPointerServerSecretParams server_params +); +SignalFfiError* signal_group_send_endorsement_call_link_params_to_token( + SignalOwnedBuffer* out, + SignalBorrowedBuffer endorsement, + SignalBorrowedBuffer call_link_secret_params_serialized +); +SignalFfiError* signal_group_send_endorsement_check_valid_contents( + SignalBorrowedBuffer bytes +); +SignalFfiError* signal_group_send_endorsement_combine( + SignalOwnedBuffer* out, + SignalBorrowedSliceOfBuffers endorsements +); +SignalFfiError* signal_group_send_endorsement_remove( + SignalOwnedBuffer* out, + SignalBorrowedBuffer endorsement, + SignalBorrowedBuffer to_remove +); +SignalFfiError* signal_group_send_endorsement_to_token( + SignalOwnedBuffer* out, + SignalBorrowedBuffer endorsement, + const SignalType_FixedArray289_uint8_t* group_params +); +SignalFfiError* signal_group_send_endorsements_response_check_valid_contents( + SignalBorrowedBuffer bytes +); +SignalFfiError* signal_group_send_endorsements_response_get_expiration( + uint64_t* out, + SignalBorrowedBuffer response_bytes +); +SignalFfiError* signal_group_send_endorsements_response_issue_deterministic( + SignalOwnedBuffer* out, + SignalBorrowedBuffer concatenated_group_member_ciphertexts, + SignalBorrowedBuffer key_pair, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_group_send_endorsements_response_receive_and_combine_with_ciphertexts( + SignalBytestringArray* out, + SignalBorrowedBuffer response_bytes, + SignalBorrowedBuffer concatenated_group_member_ciphertexts, + SignalBorrowedBuffer local_user_ciphertext, + uint64_t now, + SignalConstPointerServerPublicParams server_params +); +SignalFfiError* signal_group_send_endorsements_response_receive_and_combine_with_service_ids( + SignalBytestringArray* out, + SignalBorrowedBuffer response_bytes, + SignalBorrowedBuffer group_members, + const SignalType_FixedArray17_uint8_t* local_user, + uint64_t now, + const SignalType_FixedArray289_uint8_t* group_params, + SignalConstPointerServerPublicParams server_params +); +SignalFfiError* signal_group_send_full_token_check_valid_contents( + SignalBorrowedBuffer bytes +); +SignalFfiError* signal_group_send_full_token_get_expiration( + uint64_t* out, + SignalBorrowedBuffer token +); +SignalFfiError* signal_group_send_full_token_verify( + SignalBorrowedBuffer token, + SignalBorrowedBuffer user_ids, + uint64_t now, + SignalBorrowedBuffer key_pair +); +SignalFfiError* signal_group_send_token_check_valid_contents( + SignalBorrowedBuffer bytes +); +SignalFfiError* signal_group_send_token_to_full_token( + SignalOwnedBuffer* out, + SignalBorrowedBuffer token, + uint64_t expiration +); +SignalFfiError* signal_hex_encode( + SignalBorrowedMutableBuffer output, + SignalBorrowedBuffer input +); +SignalFfiError* signal_hkdf_derive( + SignalBorrowedMutableBuffer output, + SignalBorrowedBuffer ikm, + SignalBorrowedBuffer label, + SignalBorrowedBuffer salt +); +SignalFfiError* signal_hsm_enclave_client_complete_handshake( + SignalMutPointerHsmEnclaveClient cli, + SignalBorrowedBuffer handshake_received +); +SignalFfiError* signal_hsm_enclave_client_destroy( + SignalMutPointerHsmEnclaveClient p +); +SignalFfiError* signal_hsm_enclave_client_established_recv( + SignalOwnedBuffer* out, + SignalMutPointerHsmEnclaveClient cli, + SignalBorrowedBuffer received_ciphertext +); +SignalFfiError* signal_hsm_enclave_client_established_send( + SignalOwnedBuffer* out, + SignalMutPointerHsmEnclaveClient cli, + SignalBorrowedBuffer plaintext_to_send +); +SignalFfiError* signal_hsm_enclave_client_initial_request( + SignalOwnedBuffer* out, + SignalConstPointerHsmEnclaveClient obj +); +SignalFfiError* signal_hsm_enclave_client_new( + SignalMutPointerHsmEnclaveClient* out, + SignalBorrowedBuffer trusted_public_key, + SignalBorrowedBuffer trusted_code_hashes +); +SignalFfiError* signal_http_request_add_header( + SignalConstPointerHttpRequest request, + const int8_t* name, + const int8_t* value +); +SignalFfiError* signal_http_request_destroy( + SignalMutPointerHttpRequest p +); +SignalFfiError* signal_http_request_new_with_body( + SignalMutPointerHttpRequest* out, + const int8_t* method, + const int8_t* path, + SignalBorrowedBuffer body_as_slice +); +SignalFfiError* signal_http_request_new_without_body( + SignalMutPointerHttpRequest* out, + const int8_t* method, + const int8_t* path +); +SignalFfiError* signal_identitykey_verify_alternate_identity( + bool* out, + SignalConstPointerPublicKey public_key, + SignalConstPointerPublicKey other_identity, + SignalBorrowedBuffer signature +); +SignalFfiError* signal_identitykeypair_deserialize( + SignalPairOfMutPointerPublicKeyMutPointerPrivateKey* out, + SignalBorrowedBuffer input +); +SignalFfiError* signal_identitykeypair_serialize( + SignalOwnedBuffer* out, + SignalConstPointerPublicKey public_key, + SignalConstPointerPrivateKey private_key +); +SignalFfiError* signal_identitykeypair_sign_alternate_identity( + SignalOwnedBuffer* out, + SignalConstPointerPublicKey public_key, + SignalConstPointerPrivateKey private_key, + SignalConstPointerPublicKey other_identity +); +SignalFfiError* signal_incremental_mac_calculate_chunk_size( + uint32_t* out, + uint32_t data_size +); +SignalFfiError* signal_incremental_mac_destroy( + SignalMutPointerIncrementalMac p +); +SignalFfiError* signal_incremental_mac_finalize( + SignalOwnedBuffer* out, + SignalMutPointerIncrementalMac mac +); +SignalFfiError* signal_incremental_mac_initialize( + SignalMutPointerIncrementalMac* out, + SignalBorrowedBuffer key, + uint32_t chunk_size +); +SignalFfiError* signal_incremental_mac_update( + SignalOwnedBuffer* out, + SignalMutPointerIncrementalMac mac, + SignalBorrowedBuffer bytes, + uint32_t offset, + uint32_t length +); +bool signal_init_logger( + SignalLogLevel max_level, + SignalFfiLoggerStruct logger +); +SignalFfiError* signal_key_transparency_aci_search_key( + SignalOwnedBuffer* out, + const SignalType_FixedArray17_uint8_t* aci +); +SignalFfiError* signal_key_transparency_check( + SignalCPromisePairOfOwnedBufferOwnedBuffer* promise, + SignalConstPointerTokioAsyncContext async_runtime, + uint8_t environment, + SignalConstPointerUnauthenticatedChatConnection chat_connection, + const SignalType_FixedArray17_uint8_t* aci, + SignalConstPointerPublicKey aci_identity_key, + const int8_t* e164, + SignalOptionalBorrowedSliceOfc_uchar unidentified_access_key, + SignalOptionalBorrowedSliceOfc_uchar username_hash, + SignalOptionalBorrowedSliceOfc_uchar account_data, + SignalOptionalBorrowedSliceOfc_uchar last_distinguished_tree_head, + bool is_self_check, + bool is_e164_discoverable +); +SignalFfiError* signal_key_transparency_e164_search_key( + SignalOwnedBuffer* out, + const int8_t* e164 +); +SignalFfiError* signal_key_transparency_reset_data_field( + SignalOwnedBuffer* out, + SignalBorrowedBuffer account_data, + uint8_t field +); +SignalFfiError* signal_key_transparency_username_hash_search_key( + SignalOwnedBuffer* out, + SignalBorrowedBuffer hash +); +SignalFfiError* signal_kyber_key_pair_clone( + SignalMutPointerKyberKeyPair* new_obj, + SignalConstPointerKyberKeyPair obj +); +SignalFfiError* signal_kyber_key_pair_destroy( + SignalMutPointerKyberKeyPair p +); +SignalFfiError* signal_kyber_key_pair_generate( + SignalMutPointerKyberKeyPair* out +); +SignalFfiError* signal_kyber_key_pair_get_public_key( + SignalMutPointerKyberPublicKey* out, + SignalConstPointerKyberKeyPair key_pair +); +SignalFfiError* signal_kyber_key_pair_get_secret_key( + SignalMutPointerKyberSecretKey* out, + SignalConstPointerKyberKeyPair key_pair +); +SignalFfiError* signal_kyber_pre_key_record_clone( + SignalMutPointerKyberPreKeyRecord* new_obj, + SignalConstPointerKyberPreKeyRecord obj +); +SignalFfiError* signal_kyber_pre_key_record_deserialize( + SignalMutPointerKyberPreKeyRecord* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_kyber_pre_key_record_destroy( + SignalMutPointerKyberPreKeyRecord p +); +SignalFfiError* signal_kyber_pre_key_record_get_id( + uint32_t* out, + SignalConstPointerKyberPreKeyRecord obj +); +SignalFfiError* signal_kyber_pre_key_record_get_key_pair( + SignalMutPointerKyberKeyPair* out, + SignalConstPointerKyberPreKeyRecord obj +); +SignalFfiError* signal_kyber_pre_key_record_get_public_key( + SignalMutPointerKyberPublicKey* out, + SignalConstPointerKyberPreKeyRecord obj +); +SignalFfiError* signal_kyber_pre_key_record_get_secret_key( + SignalMutPointerKyberSecretKey* out, + SignalConstPointerKyberPreKeyRecord obj +); +SignalFfiError* signal_kyber_pre_key_record_get_signature( + SignalOwnedBuffer* out, + SignalConstPointerKyberPreKeyRecord obj +); +SignalFfiError* signal_kyber_pre_key_record_get_timestamp( + uint64_t* out, + SignalConstPointerKyberPreKeyRecord obj +); +SignalFfiError* signal_kyber_pre_key_record_new( + SignalMutPointerKyberPreKeyRecord* out, + uint32_t id, + uint64_t timestamp, + SignalConstPointerKyberKeyPair key_pair, + SignalBorrowedBuffer signature +); +SignalFfiError* signal_kyber_pre_key_record_serialize( + SignalOwnedBuffer* out, + SignalConstPointerKyberPreKeyRecord obj +); +SignalFfiError* signal_kyber_public_key_clone( + SignalMutPointerKyberPublicKey* new_obj, + SignalConstPointerKyberPublicKey obj +); +SignalFfiError* signal_kyber_public_key_deserialize( + SignalMutPointerKyberPublicKey* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_kyber_public_key_destroy( + SignalMutPointerKyberPublicKey p +); +SignalFfiError* signal_kyber_public_key_equals( + bool* out, + SignalConstPointerKyberPublicKey lhs, + SignalConstPointerKyberPublicKey rhs +); +SignalFfiError* signal_kyber_public_key_serialize( + SignalOwnedBuffer* out, + SignalConstPointerKyberPublicKey obj +); +SignalFfiError* signal_kyber_secret_key_clone( + SignalMutPointerKyberSecretKey* new_obj, + SignalConstPointerKyberSecretKey obj +); +SignalFfiError* signal_kyber_secret_key_deserialize( + SignalMutPointerKyberSecretKey* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_kyber_secret_key_destroy( + SignalMutPointerKyberSecretKey p +); +SignalFfiError* signal_kyber_secret_key_serialize( + SignalOwnedBuffer* out, + SignalConstPointerKyberSecretKey obj +); +SignalFfiError* signal_lookup_request_add_aci_and_access_key( + SignalConstPointerLookupRequest request, + const SignalType_FixedArray17_uint8_t* aci, + SignalBorrowedBuffer access_key +); +SignalFfiError* signal_lookup_request_add_e164( + SignalConstPointerLookupRequest request, + const int8_t* e164 +); +SignalFfiError* signal_lookup_request_add_previous_e164( + SignalConstPointerLookupRequest request, + const int8_t* e164 +); +SignalFfiError* signal_lookup_request_destroy( + SignalMutPointerLookupRequest p +); +SignalFfiError* signal_lookup_request_new( + SignalMutPointerLookupRequest* out +); +SignalFfiError* signal_lookup_request_set_token( + SignalConstPointerLookupRequest request, + SignalBorrowedBuffer token +); +SignalFfiError* signal_message_backup_key_destroy( + SignalMutPointerMessageBackupKey p +); +SignalFfiError* signal_message_backup_key_from_account_entropy_pool( + SignalMutPointerMessageBackupKey* out, + const int8_t* account_entropy, + const SignalType_FixedArray17_uint8_t* aci, + const SignalType_FixedArray32_uint8_t* forward_secrecy_token +); +SignalFfiError* signal_message_backup_key_from_backup_key_and_backup_id( + SignalMutPointerMessageBackupKey* out, + const SignalType_FixedArray32_uint8_t* backup_key, + const SignalType_FixedArray16_uint8_t* backup_id, + const SignalType_FixedArray32_uint8_t* forward_secrecy_token +); +SignalFfiError* signal_message_backup_key_get_aes_key( + SignalType_FixedArray32_uint8_t* out, + SignalConstPointerMessageBackupKey key +); +SignalFfiError* signal_message_backup_key_get_hmac_key( + SignalType_FixedArray32_uint8_t* out, + SignalConstPointerMessageBackupKey key +); +SignalFfiError* signal_message_backup_validation_outcome_destroy( + SignalMutPointerMessageBackupValidationOutcome p +); +SignalFfiError* signal_message_backup_validation_outcome_get_error_message( + SignalCStringPtr* out, + SignalConstPointerMessageBackupValidationOutcome outcome +); +SignalFfiError* signal_message_backup_validation_outcome_get_unknown_fields( + SignalBytestringArray* out, + SignalConstPointerMessageBackupValidationOutcome outcome +); +SignalFfiError* signal_message_backup_validator_validate( + SignalMutPointerMessageBackupValidationOutcome* out, + SignalConstPointerMessageBackupKey key, + SignalConstPointerFfiSyncInputStreamStruct first_stream, + SignalConstPointerFfiSyncInputStreamStruct second_stream, + uint64_t len, + uint8_t purpose +); +SignalFfiError* signal_message_clone( + SignalMutPointerSignalMessage* new_obj, + SignalConstPointerSignalMessage obj +); +SignalFfiError* signal_message_deserialize( + SignalMutPointerSignalMessage* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_message_destroy( + SignalMutPointerSignalMessage p +); +SignalFfiError* signal_message_get_body( + SignalOwnedBuffer* out, + SignalConstPointerSignalMessage obj +); +SignalFfiError* signal_message_get_counter( + uint32_t* out, + SignalConstPointerSignalMessage obj +); +SignalFfiError* signal_message_get_message_version( + uint32_t* out, + SignalConstPointerSignalMessage obj +); +SignalFfiError* signal_message_get_pq_ratchet( + SignalOwnedBuffer* out, + SignalConstPointerSignalMessage msg +); +SignalFfiError* signal_message_get_sender_ratchet_key( + SignalMutPointerPublicKey* out, + SignalConstPointerSignalMessage m +); +SignalFfiError* signal_message_get_serialized( + SignalOwnedBuffer* out, + SignalConstPointerSignalMessage obj +); +SignalFfiError* signal_message_new( + SignalMutPointerSignalMessage* out, + uint8_t message_version, + SignalBorrowedBuffer mac_key, + SignalConstPointerPublicKey sender_ratchet_key, + uint32_t counter, + uint32_t previous_counter, + SignalBorrowedBuffer ciphertext, + SignalConstPointerPublicKey sender_identity_key, + SignalConstPointerPublicKey receiver_identity_key, + SignalBorrowedBuffer pq_ratchet +); +SignalFfiError* signal_online_backup_validator_add_frame( + SignalMutPointerOnlineBackupValidator backup, + SignalBorrowedBuffer frame +); +SignalFfiError* signal_online_backup_validator_destroy( + SignalMutPointerOnlineBackupValidator p +); +SignalFfiError* signal_online_backup_validator_finalize( + SignalMutPointerOnlineBackupValidator backup +); +SignalFfiError* signal_online_backup_validator_new( + SignalMutPointerOnlineBackupValidator* out, + SignalBorrowedBuffer backup_info_frame, + uint8_t purpose +); +SignalFfiError* signal_pin_hash_access_key( + SignalType_FixedArray32_uint8_t* out, + SignalConstPointerPinHash ph +); +SignalFfiError* signal_pin_hash_clone( + SignalMutPointerPinHash* new_obj, + SignalConstPointerPinHash obj +); +SignalFfiError* signal_pin_hash_destroy( + SignalMutPointerPinHash p +); +SignalFfiError* signal_pin_hash_encryption_key( + SignalType_FixedArray32_uint8_t* out, + SignalConstPointerPinHash ph +); +SignalFfiError* signal_pin_hash_from_salt( + SignalMutPointerPinHash* out, + SignalBorrowedBuffer pin, + const SignalType_FixedArray32_uint8_t* salt +); +SignalFfiError* signal_pin_hash_from_username_mrenclave( + SignalMutPointerPinHash* out, + SignalBorrowedBuffer pin, + const int8_t* username, + SignalBorrowedBuffer mrenclave +); +SignalFfiError* signal_pin_local_hash( + SignalCStringPtr* out, + SignalBorrowedBuffer pin +); +SignalFfiError* signal_pin_verify_local_hash( + bool* out, + const int8_t* encoded_hash, + SignalBorrowedBuffer pin +); +SignalFfiError* signal_plaintext_content_clone( + SignalMutPointerPlaintextContent* new_obj, + SignalConstPointerPlaintextContent obj +); +SignalFfiError* signal_plaintext_content_deserialize( + SignalMutPointerPlaintextContent* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_plaintext_content_destroy( + SignalMutPointerPlaintextContent p +); +SignalFfiError* signal_plaintext_content_from_decryption_error_message( + SignalMutPointerPlaintextContent* out, + SignalConstPointerDecryptionErrorMessage m +); +SignalFfiError* signal_plaintext_content_get_body( + SignalOwnedBuffer* out, + SignalConstPointerPlaintextContent obj +); +SignalFfiError* signal_plaintext_content_serialize( + SignalOwnedBuffer* out, + SignalConstPointerPlaintextContent obj +); +SignalFfiError* signal_pre_key_bundle_clone( + SignalMutPointerPreKeyBundle* new_obj, + SignalConstPointerPreKeyBundle obj +); +SignalFfiError* signal_pre_key_bundle_destroy( + SignalMutPointerPreKeyBundle p +); +SignalFfiError* signal_pre_key_bundle_get_device_id( + uint32_t* out, + SignalConstPointerPreKeyBundle obj +); +SignalFfiError* signal_pre_key_bundle_get_identity_key( + SignalMutPointerPublicKey* out, + SignalConstPointerPreKeyBundle p +); +SignalFfiError* signal_pre_key_bundle_get_kyber_pre_key_id( + uint32_t* out, + SignalConstPointerPreKeyBundle obj +); +SignalFfiError* signal_pre_key_bundle_get_kyber_pre_key_public( + SignalMutPointerKyberPublicKey* out, + SignalConstPointerPreKeyBundle bundle +); +SignalFfiError* signal_pre_key_bundle_get_kyber_pre_key_signature( + SignalOwnedBuffer* out, + SignalConstPointerPreKeyBundle obj +); +SignalFfiError* signal_pre_key_bundle_get_pre_key_id( + uint32_t* out, + SignalConstPointerPreKeyBundle obj +); +SignalFfiError* signal_pre_key_bundle_get_pre_key_public( + SignalMutPointerPublicKey* out, + SignalConstPointerPreKeyBundle obj +); +SignalFfiError* signal_pre_key_bundle_get_registration_id( + uint32_t* out, + SignalConstPointerPreKeyBundle obj +); +SignalFfiError* signal_pre_key_bundle_get_signed_pre_key_id( + uint32_t* out, + SignalConstPointerPreKeyBundle obj +); +SignalFfiError* signal_pre_key_bundle_get_signed_pre_key_public( + SignalMutPointerPublicKey* out, + SignalConstPointerPreKeyBundle obj +); +SignalFfiError* signal_pre_key_bundle_get_signed_pre_key_signature( + SignalOwnedBuffer* out, + SignalConstPointerPreKeyBundle obj +); +SignalFfiError* signal_pre_key_bundle_new( + SignalMutPointerPreKeyBundle* out, + uint32_t registration_id, + uint32_t device_id, + uint32_t prekey_id, + SignalConstPointerPublicKey prekey, + uint32_t signed_prekey_id, + SignalConstPointerPublicKey signed_prekey, + SignalBorrowedBuffer signed_prekey_signature, + SignalConstPointerPublicKey identity_key, + uint32_t kyber_prekey_id, + SignalConstPointerKyberPublicKey kyber_prekey, + SignalBorrowedBuffer kyber_prekey_signature +); +SignalFfiError* signal_pre_key_record_clone( + SignalMutPointerPreKeyRecord* new_obj, + SignalConstPointerPreKeyRecord obj +); +SignalFfiError* signal_pre_key_record_deserialize( + SignalMutPointerPreKeyRecord* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_pre_key_record_destroy( + SignalMutPointerPreKeyRecord p +); +SignalFfiError* signal_pre_key_record_get_id( + uint32_t* out, + SignalConstPointerPreKeyRecord obj +); +SignalFfiError* signal_pre_key_record_get_private_key( + SignalMutPointerPrivateKey* out, + SignalConstPointerPreKeyRecord obj +); +SignalFfiError* signal_pre_key_record_get_public_key( + SignalMutPointerPublicKey* out, + SignalConstPointerPreKeyRecord obj +); +SignalFfiError* signal_pre_key_record_new( + SignalMutPointerPreKeyRecord* out, + uint32_t id, + SignalConstPointerPublicKey pub_key, + SignalConstPointerPrivateKey priv_key +); +SignalFfiError* signal_pre_key_record_serialize( + SignalOwnedBuffer* out, + SignalConstPointerPreKeyRecord obj +); +SignalFfiError* signal_pre_key_signal_message_clone( + SignalMutPointerPreKeySignalMessage* new_obj, + SignalConstPointerPreKeySignalMessage obj +); +SignalFfiError* signal_pre_key_signal_message_deserialize( + SignalMutPointerPreKeySignalMessage* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_pre_key_signal_message_destroy( + SignalMutPointerPreKeySignalMessage p +); +SignalFfiError* signal_pre_key_signal_message_get_base_key( + SignalMutPointerPublicKey* out, + SignalConstPointerPreKeySignalMessage m +); +SignalFfiError* signal_pre_key_signal_message_get_identity_key( + SignalMutPointerPublicKey* out, + SignalConstPointerPreKeySignalMessage m +); +SignalFfiError* signal_pre_key_signal_message_get_pre_key_id( + uint32_t* out, + SignalConstPointerPreKeySignalMessage obj +); +SignalFfiError* signal_pre_key_signal_message_get_registration_id( + uint32_t* out, + SignalConstPointerPreKeySignalMessage obj +); +SignalFfiError* signal_pre_key_signal_message_get_signal_message( + SignalMutPointerSignalMessage* out, + SignalConstPointerPreKeySignalMessage m +); +SignalFfiError* signal_pre_key_signal_message_get_signed_pre_key_id( + uint32_t* out, + SignalConstPointerPreKeySignalMessage obj +); +SignalFfiError* signal_pre_key_signal_message_get_version( + uint32_t* out, + SignalConstPointerPreKeySignalMessage obj +); +SignalFfiError* signal_pre_key_signal_message_new( + SignalMutPointerPreKeySignalMessage* out, + uint8_t message_version, + uint32_t registration_id, + uint32_t pre_key_id, + uint32_t signed_pre_key_id, + SignalConstPointerPublicKey base_key, + SignalConstPointerPublicKey identity_key, + SignalConstPointerSignalMessage signal_message +); +SignalFfiError* signal_pre_key_signal_message_serialize( + SignalOwnedBuffer* out, + SignalConstPointerPreKeySignalMessage obj +); +void signal_print_ptr( + const void* p +); +SignalFfiError* signal_privatekey_agree( + SignalOwnedBuffer* out, + SignalConstPointerPrivateKey private_key, + SignalConstPointerPublicKey public_key +); +SignalFfiError* signal_privatekey_clone( + SignalMutPointerPrivateKey* new_obj, + SignalConstPointerPrivateKey obj +); +SignalFfiError* signal_privatekey_deserialize( + SignalMutPointerPrivateKey* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_privatekey_destroy( + SignalMutPointerPrivateKey p +); +SignalFfiError* signal_privatekey_generate( + SignalMutPointerPrivateKey* out +); +SignalFfiError* signal_privatekey_get_public_key( + SignalMutPointerPublicKey* out, + SignalConstPointerPrivateKey k +); +SignalFfiError* signal_privatekey_hpke_open( + SignalOwnedBuffer* out, + SignalConstPointerPrivateKey sk, + SignalBorrowedBuffer ciphertext, + SignalBorrowedBuffer info, + SignalBorrowedBuffer associated_data +); +SignalFfiError* signal_privatekey_serialize( + SignalOwnedBuffer* out, + SignalConstPointerPrivateKey obj +); +SignalFfiError* signal_privatekey_sign( + SignalOwnedBuffer* out, + SignalConstPointerPrivateKey key, + SignalBorrowedBuffer message +); +SignalFfiError* signal_process_prekey_bundle( + SignalConstPointerPreKeyBundle bundle, + SignalConstPointerProtocolAddress protocol_address, + SignalConstPointerProtocolAddress local_address, + SignalConstPointerFfiSessionStoreStruct session_store, + SignalConstPointerFfiIdentityKeyStoreStruct identity_key_store, + uint64_t now +); +SignalFfiError* signal_process_sender_key_distribution_message( + SignalConstPointerProtocolAddress sender, + SignalConstPointerSenderKeyDistributionMessage sender_key_distribution_message, + SignalConstPointerFfiSenderKeyStoreStruct store +); +SignalFfiError* signal_profile_key_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_profile_key_ciphertext_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_profile_key_commitment_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_profile_key_credential_presentation_check_valid_contents( + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_profile_key_credential_presentation_get_profile_key_ciphertext( + SignalType_FixedArray65_uint8_t* out, + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_profile_key_credential_presentation_get_uuid_ciphertext( + SignalType_FixedArray65_uint8_t* out, + SignalBorrowedBuffer presentation_bytes +); +SignalFfiError* signal_profile_key_credential_request_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_profile_key_credential_request_context_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_profile_key_credential_request_context_get_request( + SignalType_FixedArray329_uint8_t* out, + const SignalType_FixedArray473_uint8_t* context +); +SignalFfiError* signal_profile_key_derive_access_key( + SignalType_FixedArray16_uint8_t* out, + const SignalType_FixedArray32_uint8_t* profile_key +); +SignalFfiError* signal_profile_key_get_commitment( + SignalType_FixedArray97_uint8_t* out, + const SignalType_FixedArray32_uint8_t* profile_key, + const SignalType_FixedArray17_uint8_t* user_id +); +SignalFfiError* signal_profile_key_get_profile_key_version( + SignalType_FixedArray64_uint8_t* out, + const SignalType_FixedArray32_uint8_t* profile_key, + const SignalType_FixedArray17_uint8_t* user_id +); +SignalFfiError* signal_provisioning_chat_connection_connect( + SignalCPromiseMutPointerProvisioningChatConnection* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerConnectionManager connection_manager +); +SignalFfiError* signal_provisioning_chat_connection_destroy( + SignalMutPointerProvisioningChatConnection p +); +SignalFfiError* signal_provisioning_chat_connection_disconnect( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerProvisioningChatConnection chat +); +SignalFfiError* signal_provisioning_chat_connection_info( + SignalMutPointerChatConnectionInfo* out, + SignalConstPointerProvisioningChatConnection chat +); +SignalFfiError* signal_provisioning_chat_connection_init_listener( + SignalConstPointerProvisioningChatConnection chat, + SignalConstPointerFfiProvisioningListenerStruct listener +); +SignalFfiError* signal_publickey_clone( + SignalMutPointerPublicKey* new_obj, + SignalConstPointerPublicKey obj +); +SignalFfiError* signal_publickey_deserialize( + SignalMutPointerPublicKey* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_publickey_destroy( + SignalMutPointerPublicKey p +); +SignalFfiError* signal_publickey_equals( + bool* out, + SignalConstPointerPublicKey lhs, + SignalConstPointerPublicKey rhs +); +SignalFfiError* signal_publickey_get_public_key_bytes( + SignalOwnedBuffer* out, + SignalConstPointerPublicKey obj +); +SignalFfiError* signal_publickey_hpke_seal( + SignalOwnedBuffer* out, + SignalConstPointerPublicKey pk, + SignalBorrowedBuffer plaintext, + SignalBorrowedBuffer info, + SignalBorrowedBuffer associated_data +); +SignalFfiError* signal_publickey_serialize( + SignalOwnedBuffer* out, + SignalConstPointerPublicKey obj +); +SignalFfiError* signal_publickey_verify( + bool* out, + SignalConstPointerPublicKey key, + SignalBorrowedBuffer message, + SignalBorrowedBuffer signature +); +SignalFfiError* signal_receipt_credential_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_receipt_credential_get_receipt_expiration_time( + uint64_t* out, + const SignalType_FixedArray129_uint8_t* receipt_credential +); +SignalFfiError* signal_receipt_credential_get_receipt_level( + uint64_t* out, + const SignalType_FixedArray129_uint8_t* receipt_credential +); +SignalFfiError* signal_receipt_credential_presentation_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_receipt_credential_presentation_get_receipt_expiration_time( + uint64_t* out, + const SignalType_FixedArray329_uint8_t* presentation +); +SignalFfiError* signal_receipt_credential_presentation_get_receipt_level( + uint64_t* out, + const SignalType_FixedArray329_uint8_t* presentation +); +SignalFfiError* signal_receipt_credential_presentation_get_receipt_serial( + SignalType_FixedArray16_uint8_t* out, + const SignalType_FixedArray329_uint8_t* presentation +); +SignalFfiError* signal_receipt_credential_request_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_receipt_credential_request_context_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_receipt_credential_request_context_get_request( + SignalType_FixedArray97_uint8_t* out, + const SignalType_FixedArray177_uint8_t* request_context +); +SignalFfiError* signal_receipt_credential_response_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_register_account_request_create( + SignalMutPointerRegisterAccountRequest* out +); +SignalFfiError* signal_register_account_request_destroy( + SignalMutPointerRegisterAccountRequest p +); +SignalFfiError* signal_register_account_request_set_account_password( + SignalConstPointerRegisterAccountRequest register_account, + const int8_t* account_password +); +SignalFfiError* signal_register_account_request_set_apn_push_token( + SignalConstPointerRegisterAccountRequest register_account, + const int8_t* apn_push_token +); +SignalFfiError* signal_register_account_request_set_identity_pq_last_resort_pre_key( + SignalConstPointerRegisterAccountRequest register_account, + uint8_t identity_type, + SignalFfiSignedPublicPreKey pq_last_resort_pre_key +); +SignalFfiError* signal_register_account_request_set_identity_public_key( + SignalConstPointerRegisterAccountRequest register_account, + uint8_t identity_type, + SignalConstPointerPublicKey identity_key +); +SignalFfiError* signal_register_account_request_set_identity_signed_pre_key( + SignalConstPointerRegisterAccountRequest register_account, + uint8_t identity_type, + SignalFfiSignedPublicPreKey signed_pre_key +); +SignalFfiError* signal_register_account_request_set_skip_device_transfer( + SignalConstPointerRegisterAccountRequest register_account +); +SignalFfiError* signal_register_account_response_destroy( + SignalMutPointerRegisterAccountResponse p +); +SignalFfiError* signal_register_account_response_get_entitlement_backup_expiration_seconds( + uint64_t* out, + SignalConstPointerRegisterAccountResponse response +); +SignalFfiError* signal_register_account_response_get_entitlement_backup_level( + uint64_t* out, + SignalConstPointerRegisterAccountResponse response +); +SignalFfiError* signal_register_account_response_get_entitlement_badges( + SignalOwnedBufferOfFfiRegisterResponseBadge* out, + SignalConstPointerRegisterAccountResponse response +); +SignalFfiError* signal_register_account_response_get_identity( + SignalType_FixedArray17_uint8_t* out, + SignalConstPointerRegisterAccountResponse response, + uint8_t identity_type +); +SignalFfiError* signal_register_account_response_get_number( + SignalCStringPtr* out, + SignalConstPointerRegisterAccountResponse response +); +SignalFfiError* signal_register_account_response_get_reregistration( + bool* out, + SignalConstPointerRegisterAccountResponse response +); +SignalFfiError* signal_register_account_response_get_storage_capable( + bool* out, + SignalConstPointerRegisterAccountResponse response +); +SignalFfiError* signal_register_account_response_get_username_hash( + SignalOwnedBuffer* out, + SignalConstPointerRegisterAccountResponse response +); +SignalFfiError* signal_register_account_response_get_username_link_handle( + SignalOptionalUuid* out, + SignalConstPointerRegisterAccountResponse response +); +SignalFfiError* signal_registration_account_attributes_create( + SignalMutPointerRegistrationAccountAttributes* out, + SignalBorrowedBuffer recovery_password, + uint16_t aci_registration_id, + uint16_t pni_registration_id, + const int8_t* registration_lock, + const SignalType_FixedArray16_uint8_t* unidentified_access_key, + bool unrestricted_unidentified_access, + SignalBorrowedBytestringArray capabilities, + bool discoverable_by_phone_number +); +SignalFfiError* signal_registration_account_attributes_destroy( + SignalMutPointerRegistrationAccountAttributes p +); +SignalFfiError* signal_registration_service_check_svr2_credentials( + SignalCPromiseFfiCheckSvr2CredentialsResponse* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerRegistrationService service, + SignalBorrowedBytestringArray svr_tokens +); +SignalFfiError* signal_registration_service_create_session( + SignalCPromiseMutPointerRegistrationService* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalFfiRegistrationCreateSessionRequest create_session, + SignalConstPointerFfiConnectChatBridgeStruct connect_chat +); +SignalFfiError* signal_registration_service_destroy( + SignalMutPointerRegistrationService p +); +SignalFfiError* signal_registration_service_register_account( + SignalCPromiseMutPointerRegisterAccountResponse* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerRegistrationService service, + SignalConstPointerRegisterAccountRequest register_account, + SignalConstPointerRegistrationAccountAttributes account_attributes +); +SignalFfiError* signal_registration_service_registration_session( + SignalMutPointerRegistrationSession* out, + SignalConstPointerRegistrationService service +); +SignalFfiError* signal_registration_service_request_push_challenge( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerRegistrationService service, + const int8_t* push_token +); +SignalFfiError* signal_registration_service_request_verification_code( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerRegistrationService service, + const int8_t* transport, + const int8_t* client, + SignalBorrowedBytestringArray languages +); +SignalFfiError* signal_registration_service_reregister_account( + SignalCPromiseMutPointerRegisterAccountResponse* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerFfiConnectChatBridgeStruct connect_chat, + const int8_t* number, + SignalConstPointerRegisterAccountRequest register_account, + SignalConstPointerRegistrationAccountAttributes account_attributes +); +SignalFfiError* signal_registration_service_resume_session( + SignalCPromiseMutPointerRegistrationService* promise, + SignalConstPointerTokioAsyncContext async_runtime, + const int8_t* session_id, + const int8_t* number, + SignalConstPointerFfiConnectChatBridgeStruct connect_chat +); +SignalFfiError* signal_registration_service_session_id( + SignalCStringPtr* out, + SignalConstPointerRegistrationService service +); +SignalFfiError* signal_registration_service_submit_captcha( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerRegistrationService service, + const int8_t* captcha_value +); +SignalFfiError* signal_registration_service_submit_push_challenge( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerRegistrationService service, + const int8_t* push_challenge +); +SignalFfiError* signal_registration_service_submit_verification_code( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerRegistrationService service, + const int8_t* code +); +SignalFfiError* signal_registration_session_destroy( + SignalMutPointerRegistrationSession p +); +SignalFfiError* signal_registration_session_get_allowed_to_request_code( + bool* out, + SignalConstPointerRegistrationSession session +); +SignalFfiError* signal_registration_session_get_next_call_seconds( + uint32_t* out, + SignalConstPointerRegistrationSession session +); +SignalFfiError* signal_registration_session_get_next_sms_seconds( + uint32_t* out, + SignalConstPointerRegistrationSession session +); +SignalFfiError* signal_registration_session_get_next_verification_attempt_seconds( + uint32_t* out, + SignalConstPointerRegistrationSession session +); +SignalFfiError* signal_registration_session_get_requested_information( + SignalOwnedBuffer* out, + SignalConstPointerRegistrationSession session +); +SignalFfiError* signal_registration_session_get_verified( + bool* out, + SignalConstPointerRegistrationSession session +); +SignalFfiError* signal_sealed_sender_multi_recipient_encrypt( + SignalOwnedBuffer* out, + SignalBorrowedSliceOfConstPointerProtocolAddress recipients, + SignalBorrowedSliceOfConstPointerSessionRecord recipient_sessions, + SignalBorrowedBuffer excluded_recipients, + SignalConstPointerUnidentifiedSenderMessageContent content, + SignalConstPointerFfiIdentityKeyStoreStruct identity_key_store +); +SignalFfiError* signal_sealed_sender_multi_recipient_message_for_single_recipient( + SignalOwnedBuffer* out, + SignalBorrowedBuffer encoded_multi_recipient_message +); +SignalFfiError* signal_sealed_session_cipher_decrypt_to_usmc( + SignalMutPointerUnidentifiedSenderMessageContent* out, + SignalBorrowedBuffer ctext, + SignalConstPointerFfiIdentityKeyStoreStruct identity_store +); +SignalFfiError* signal_sealed_session_cipher_encrypt( + SignalOwnedBuffer* out, + SignalConstPointerProtocolAddress destination, + SignalConstPointerUnidentifiedSenderMessageContent content, + SignalConstPointerFfiIdentityKeyStoreStruct identity_key_store +); +SignalFfiError* signal_secure_value_recovery_for_backups_create_new_backup_chain( + SignalOwnedBuffer* out, + uint8_t environment, + const SignalType_FixedArray32_uint8_t* backup_key +); +SignalFfiError* signal_secure_value_recovery_for_backups_remove_backup( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerConnectionManager connection_manager, + const int8_t* username, + const int8_t* password +); +SignalFfiError* signal_secure_value_recovery_for_backups_restore_backup_from_server( + SignalCPromiseMutPointerBackupRestoreResponse* promise, + SignalConstPointerTokioAsyncContext async_runtime, + const SignalType_FixedArray32_uint8_t* backup_key, + SignalBorrowedBuffer metadata, + SignalConstPointerConnectionManager connection_manager, + const int8_t* username, + const int8_t* password +); +SignalFfiError* signal_secure_value_recovery_for_backups_store_backup( + SignalCPromiseMutPointerBackupStoreResponse* promise, + SignalConstPointerTokioAsyncContext async_runtime, + const SignalType_FixedArray32_uint8_t* backup_key, + SignalBorrowedBuffer previous_secret_data, + SignalConstPointerConnectionManager connection_manager, + const int8_t* username, + const int8_t* password +); +SignalFfiError* signal_sender_certificate_clone( + SignalMutPointerSenderCertificate* new_obj, + SignalConstPointerSenderCertificate obj +); +SignalFfiError* signal_sender_certificate_deserialize( + SignalMutPointerSenderCertificate* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_sender_certificate_destroy( + SignalMutPointerSenderCertificate p +); +SignalFfiError* signal_sender_certificate_get_certificate( + SignalOwnedBuffer* out, + SignalConstPointerSenderCertificate obj +); +SignalFfiError* signal_sender_certificate_get_device_id( + uint32_t* out, + SignalConstPointerSenderCertificate obj +); +SignalFfiError* signal_sender_certificate_get_expiration( + uint64_t* out, + SignalConstPointerSenderCertificate obj +); +SignalFfiError* signal_sender_certificate_get_key( + SignalMutPointerPublicKey* out, + SignalConstPointerSenderCertificate obj +); +SignalFfiError* signal_sender_certificate_get_sender_e164( + SignalCStringPtr* out, + SignalConstPointerSenderCertificate obj +); +SignalFfiError* signal_sender_certificate_get_sender_uuid( + SignalCStringPtr* out, + SignalConstPointerSenderCertificate obj +); +SignalFfiError* signal_sender_certificate_get_serialized( + SignalOwnedBuffer* out, + SignalConstPointerSenderCertificate obj +); +SignalFfiError* signal_sender_certificate_get_server_certificate( + SignalMutPointerServerCertificate* out, + SignalConstPointerSenderCertificate cert +); +SignalFfiError* signal_sender_certificate_get_signature( + SignalOwnedBuffer* out, + SignalConstPointerSenderCertificate obj +); +SignalFfiError* signal_sender_certificate_new( + SignalMutPointerSenderCertificate* out, + const int8_t* sender_uuid, + const int8_t* sender_e164, + uint32_t sender_device_id, + SignalConstPointerPublicKey sender_key, + uint64_t expiration, + SignalConstPointerServerCertificate signer_cert, + SignalConstPointerPrivateKey signer_key +); +SignalFfiError* signal_sender_certificate_validate( + bool* out, + SignalConstPointerSenderCertificate cert, + SignalBorrowedSliceOfConstPointerPublicKey trust_roots, + uint64_t time +); +SignalFfiError* signal_sender_key_distribution_message_clone( + SignalMutPointerSenderKeyDistributionMessage* new_obj, + SignalConstPointerSenderKeyDistributionMessage obj +); +SignalFfiError* signal_sender_key_distribution_message_create( + SignalMutPointerSenderKeyDistributionMessage* out, + SignalConstPointerProtocolAddress sender, + SignalUuid distribution_id, + SignalConstPointerFfiSenderKeyStoreStruct store +); +SignalFfiError* signal_sender_key_distribution_message_deserialize( + SignalMutPointerSenderKeyDistributionMessage* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_sender_key_distribution_message_destroy( + SignalMutPointerSenderKeyDistributionMessage p +); +SignalFfiError* signal_sender_key_distribution_message_get_chain_id( + uint32_t* out, + SignalConstPointerSenderKeyDistributionMessage obj +); +SignalFfiError* signal_sender_key_distribution_message_get_chain_key( + SignalOwnedBuffer* out, + SignalConstPointerSenderKeyDistributionMessage obj +); +SignalFfiError* signal_sender_key_distribution_message_get_distribution_id( + SignalUuid* out, + SignalConstPointerSenderKeyDistributionMessage obj +); +SignalFfiError* signal_sender_key_distribution_message_get_iteration( + uint32_t* out, + SignalConstPointerSenderKeyDistributionMessage obj +); +SignalFfiError* signal_sender_key_distribution_message_get_signature_key( + SignalMutPointerPublicKey* out, + SignalConstPointerSenderKeyDistributionMessage m +); +SignalFfiError* signal_sender_key_distribution_message_new( + SignalMutPointerSenderKeyDistributionMessage* out, + uint8_t message_version, + SignalUuid distribution_id, + uint32_t chain_id, + uint32_t iteration, + SignalBorrowedBuffer chainkey, + SignalConstPointerPublicKey pk +); +SignalFfiError* signal_sender_key_distribution_message_serialize( + SignalOwnedBuffer* out, + SignalConstPointerSenderKeyDistributionMessage obj +); +SignalFfiError* signal_sender_key_message_clone( + SignalMutPointerSenderKeyMessage* new_obj, + SignalConstPointerSenderKeyMessage obj +); +SignalFfiError* signal_sender_key_message_deserialize( + SignalMutPointerSenderKeyMessage* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_sender_key_message_destroy( + SignalMutPointerSenderKeyMessage p +); +SignalFfiError* signal_sender_key_message_get_chain_id( + uint32_t* out, + SignalConstPointerSenderKeyMessage obj +); +SignalFfiError* signal_sender_key_message_get_cipher_text( + SignalOwnedBuffer* out, + SignalConstPointerSenderKeyMessage obj +); +SignalFfiError* signal_sender_key_message_get_distribution_id( + SignalUuid* out, + SignalConstPointerSenderKeyMessage obj +); +SignalFfiError* signal_sender_key_message_get_iteration( + uint32_t* out, + SignalConstPointerSenderKeyMessage obj +); +SignalFfiError* signal_sender_key_message_new( + SignalMutPointerSenderKeyMessage* out, + uint8_t message_version, + SignalUuid distribution_id, + uint32_t chain_id, + uint32_t iteration, + SignalBorrowedBuffer ciphertext, + SignalConstPointerPrivateKey pk +); +SignalFfiError* signal_sender_key_message_serialize( + SignalOwnedBuffer* out, + SignalConstPointerSenderKeyMessage obj +); +SignalFfiError* signal_sender_key_message_verify_signature( + bool* out, + SignalConstPointerSenderKeyMessage skm, + SignalConstPointerPublicKey pubkey +); +SignalFfiError* signal_sender_key_record_clone( + SignalMutPointerSenderKeyRecord* new_obj, + SignalConstPointerSenderKeyRecord obj +); +SignalFfiError* signal_sender_key_record_deserialize( + SignalMutPointerSenderKeyRecord* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_sender_key_record_destroy( + SignalMutPointerSenderKeyRecord p +); +SignalFfiError* signal_sender_key_record_serialize( + SignalOwnedBuffer* out, + SignalConstPointerSenderKeyRecord obj +); +SignalFfiError* signal_server_certificate_clone( + SignalMutPointerServerCertificate* new_obj, + SignalConstPointerServerCertificate obj +); +SignalFfiError* signal_server_certificate_deserialize( + SignalMutPointerServerCertificate* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_server_certificate_destroy( + SignalMutPointerServerCertificate p +); +SignalFfiError* signal_server_certificate_get_certificate( + SignalOwnedBuffer* out, + SignalConstPointerServerCertificate obj +); +SignalFfiError* signal_server_certificate_get_key( + SignalMutPointerPublicKey* out, + SignalConstPointerServerCertificate obj +); +SignalFfiError* signal_server_certificate_get_key_id( + uint32_t* out, + SignalConstPointerServerCertificate obj +); +SignalFfiError* signal_server_certificate_get_serialized( + SignalOwnedBuffer* out, + SignalConstPointerServerCertificate obj +); +SignalFfiError* signal_server_certificate_get_signature( + SignalOwnedBuffer* out, + SignalConstPointerServerCertificate obj +); +SignalFfiError* signal_server_certificate_new( + SignalMutPointerServerCertificate* out, + uint32_t key_id, + SignalConstPointerPublicKey server_key, + SignalConstPointerPrivateKey trust_root +); +SignalFfiError* signal_server_message_ack_destroy( + SignalMutPointerServerMessageAck p +); +SignalFfiError* signal_server_message_ack_send( + SignalConstPointerServerMessageAck ack +); +SignalFfiError* signal_server_public_params_create_auth_credential_with_pni_presentation_deterministic( + SignalOwnedBuffer* out, + SignalConstPointerServerPublicParams server_public_params, + const SignalType_FixedArray32_uint8_t* randomness, + const SignalType_FixedArray289_uint8_t* group_secret_params, + SignalBorrowedBuffer auth_credential_with_pni_bytes +); +SignalFfiError* signal_server_public_params_create_expiring_profile_key_credential_presentation_deterministic( + SignalOwnedBuffer* out, + SignalConstPointerServerPublicParams server_public_params, + const SignalType_FixedArray32_uint8_t* randomness, + const SignalType_FixedArray289_uint8_t* group_secret_params, + const SignalType_FixedArray153_uint8_t* profile_key_credential +); +SignalFfiError* signal_server_public_params_create_profile_key_credential_request_context_deterministic( + SignalType_FixedArray473_uint8_t* out, + SignalConstPointerServerPublicParams server_public_params, + const SignalType_FixedArray32_uint8_t* randomness, + const SignalType_FixedArray17_uint8_t* user_id, + const SignalType_FixedArray32_uint8_t* profile_key +); +SignalFfiError* signal_server_public_params_create_receipt_credential_presentation_deterministic( + SignalType_FixedArray329_uint8_t* out, + SignalConstPointerServerPublicParams server_public_params, + const SignalType_FixedArray32_uint8_t* randomness, + const SignalType_FixedArray129_uint8_t* receipt_credential +); +SignalFfiError* signal_server_public_params_create_receipt_credential_request_context_deterministic( + SignalType_FixedArray177_uint8_t* out, + SignalConstPointerServerPublicParams server_public_params, + const SignalType_FixedArray32_uint8_t* randomness, + const SignalType_FixedArray16_uint8_t* receipt_serial +); +SignalFfiError* signal_server_public_params_deserialize( + SignalMutPointerServerPublicParams* out, + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_server_public_params_destroy( + SignalMutPointerServerPublicParams p +); +SignalFfiError* signal_server_public_params_get_endorsement_public_key( + SignalOwnedBuffer* out, + SignalConstPointerServerPublicParams params +); +SignalFfiError* signal_server_public_params_receive_auth_credential_with_pni_as_service_id( + SignalOwnedBuffer* out, + SignalConstPointerServerPublicParams params, + const SignalType_FixedArray17_uint8_t* aci, + const SignalType_FixedArray17_uint8_t* pni, + uint64_t redemption_time, + SignalBorrowedBuffer auth_credential_with_pni_response_bytes +); +SignalFfiError* signal_server_public_params_receive_auth_credential_zkc_without_pni( + SignalOwnedBuffer* out, + SignalConstPointerServerPublicParams params, + const SignalType_FixedArray17_uint8_t* aci, + SignalBorrowedBuffer salt, + uint64_t redemption_time, + SignalBorrowedBuffer auth_credential_with_pni_response_bytes +); +SignalFfiError* signal_server_public_params_receive_expiring_profile_key_credential( + SignalType_FixedArray153_uint8_t* out, + SignalConstPointerServerPublicParams server_public_params, + const SignalType_FixedArray473_uint8_t* request_context, + const SignalType_FixedArray497_uint8_t* response, + uint64_t current_time_in_seconds +); +SignalFfiError* signal_server_public_params_receive_receipt_credential( + SignalType_FixedArray129_uint8_t* out, + SignalConstPointerServerPublicParams server_public_params, + const SignalType_FixedArray177_uint8_t* request_context, + const SignalType_FixedArray409_uint8_t* response +); +SignalFfiError* signal_server_public_params_serialize( + SignalOwnedBuffer* out, + SignalConstPointerServerPublicParams handle +); +SignalFfiError* signal_server_public_params_verify_signature( + SignalConstPointerServerPublicParams server_public_params, + SignalBorrowedBuffer message, + const SignalType_FixedArray64_uint8_t* notary_signature +); +SignalFfiError* signal_server_secret_params_deserialize( + SignalMutPointerServerSecretParams* out, + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_server_secret_params_destroy( + SignalMutPointerServerSecretParams p +); +SignalFfiError* signal_server_secret_params_generate_deterministic( + SignalMutPointerServerSecretParams* out, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_server_secret_params_get_public_params( + SignalMutPointerServerPublicParams* out, + SignalConstPointerServerSecretParams params +); +SignalFfiError* signal_server_secret_params_issue_auth_credential_with_pni_zkc_deterministic( + SignalOwnedBuffer* out, + SignalConstPointerServerSecretParams server_secret_params, + const SignalType_FixedArray32_uint8_t* randomness, + const SignalType_FixedArray17_uint8_t* aci, + const SignalType_FixedArray17_uint8_t* pni, + uint64_t redemption_time +); +SignalFfiError* signal_server_secret_params_issue_auth_credential_zkc_without_pni_deterministic( + SignalOwnedBuffer* out, + SignalConstPointerServerSecretParams server_secret_params, + const SignalType_FixedArray32_uint8_t* randomness, + const SignalType_FixedArray17_uint8_t* aci, + SignalBorrowedBuffer salt, + uint64_t redemption_time +); +SignalFfiError* signal_server_secret_params_issue_expiring_profile_key_credential_deterministic( + SignalType_FixedArray497_uint8_t* out, + SignalConstPointerServerSecretParams server_secret_params, + const SignalType_FixedArray32_uint8_t* randomness, + const SignalType_FixedArray329_uint8_t* request, + const SignalType_FixedArray17_uint8_t* user_id, + const SignalType_FixedArray97_uint8_t* commitment, + uint64_t expiration_in_seconds +); +SignalFfiError* signal_server_secret_params_issue_receipt_credential_deterministic( + SignalType_FixedArray409_uint8_t* out, + SignalConstPointerServerSecretParams server_secret_params, + const SignalType_FixedArray32_uint8_t* randomness, + const SignalType_FixedArray97_uint8_t* request, + uint64_t receipt_expiration_time, + uint64_t receipt_level +); +SignalFfiError* signal_server_secret_params_serialize( + SignalOwnedBuffer* out, + SignalConstPointerServerSecretParams handle +); +SignalFfiError* signal_server_secret_params_sign_deterministic( + SignalType_FixedArray64_uint8_t* out, + SignalConstPointerServerSecretParams params, + const SignalType_FixedArray32_uint8_t* randomness, + SignalBorrowedBuffer message +); +SignalFfiError* signal_server_secret_params_verify_auth_credential_presentation( + SignalConstPointerServerSecretParams server_secret_params, + const SignalType_FixedArray97_uint8_t* group_public_params, + SignalBorrowedBuffer presentation_bytes, + uint64_t current_time_in_seconds +); +SignalFfiError* signal_server_secret_params_verify_profile_key_credential_presentation( + SignalConstPointerServerSecretParams server_secret_params, + const SignalType_FixedArray97_uint8_t* group_public_params, + SignalBorrowedBuffer presentation_bytes, + uint64_t current_time_in_seconds +); +SignalFfiError* signal_server_secret_params_verify_receipt_credential_presentation( + SignalConstPointerServerSecretParams server_secret_params, + const SignalType_FixedArray329_uint8_t* presentation +); +SignalFfiError* signal_service_id_parse_from_service_id_binary( + SignalType_FixedArray17_uint8_t* out, + SignalBorrowedBuffer input +); +SignalFfiError* signal_service_id_parse_from_service_id_string( + SignalType_FixedArray17_uint8_t* out, + const int8_t* input +); +SignalFfiError* signal_service_id_service_id_binary( + SignalOwnedBuffer* out, + const SignalType_FixedArray17_uint8_t* value +); +SignalFfiError* signal_service_id_service_id_log( + SignalCStringPtr* out, + const SignalType_FixedArray17_uint8_t* value +); +SignalFfiError* signal_service_id_service_id_string( + SignalCStringPtr* out, + const SignalType_FixedArray17_uint8_t* value +); +SignalFfiError* signal_session_record_archive_current_state( + SignalMutPointerSessionRecord session_record +); +SignalFfiError* signal_session_record_clone( + SignalMutPointerSessionRecord* new_obj, + SignalConstPointerSessionRecord obj +); +SignalFfiError* signal_session_record_current_ratchet_key_matches( + bool* out, + SignalConstPointerSessionRecord s, + SignalConstPointerPublicKey key +); +SignalFfiError* signal_session_record_deserialize( + SignalMutPointerSessionRecord* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_session_record_destroy( + SignalMutPointerSessionRecord p +); +SignalFfiError* signal_session_record_get_local_registration_id( + uint32_t* out, + SignalConstPointerSessionRecord obj +); +SignalFfiError* signal_session_record_get_remote_registration_id( + uint32_t* out, + SignalConstPointerSessionRecord obj +); +SignalFfiError* signal_session_record_has_usable_sender_chain( + bool* out, + SignalConstPointerSessionRecord s, + uint64_t now +); +SignalFfiError* signal_session_record_serialize( + SignalOwnedBuffer* out, + SignalConstPointerSessionRecord obj +); +SignalFfiError* signal_sgx_client_state_complete_handshake( + SignalMutPointerSgxClientState cli, + SignalBorrowedBuffer handshake_received +); +SignalFfiError* signal_sgx_client_state_destroy( + SignalMutPointerSgxClientState p +); +SignalFfiError* signal_sgx_client_state_established_recv( + SignalOwnedBuffer* out, + SignalMutPointerSgxClientState cli, + SignalBorrowedBuffer received_ciphertext +); +SignalFfiError* signal_sgx_client_state_established_send( + SignalOwnedBuffer* out, + SignalMutPointerSgxClientState cli, + SignalBorrowedBuffer plaintext_to_send +); +SignalFfiError* signal_sgx_client_state_initial_request( + SignalOwnedBuffer* out, + SignalConstPointerSgxClientState obj +); +SignalFfiError* signal_signed_pre_key_record_clone( + SignalMutPointerSignedPreKeyRecord* new_obj, + SignalConstPointerSignedPreKeyRecord obj +); +SignalFfiError* signal_signed_pre_key_record_deserialize( + SignalMutPointerSignedPreKeyRecord* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_signed_pre_key_record_destroy( + SignalMutPointerSignedPreKeyRecord p +); +SignalFfiError* signal_signed_pre_key_record_get_id( + uint32_t* out, + SignalConstPointerSignedPreKeyRecord obj +); +SignalFfiError* signal_signed_pre_key_record_get_private_key( + SignalMutPointerPrivateKey* out, + SignalConstPointerSignedPreKeyRecord obj +); +SignalFfiError* signal_signed_pre_key_record_get_public_key( + SignalMutPointerPublicKey* out, + SignalConstPointerSignedPreKeyRecord obj +); +SignalFfiError* signal_signed_pre_key_record_get_signature( + SignalOwnedBuffer* out, + SignalConstPointerSignedPreKeyRecord obj +); +SignalFfiError* signal_signed_pre_key_record_get_timestamp( + uint64_t* out, + SignalConstPointerSignedPreKeyRecord obj +); +SignalFfiError* signal_signed_pre_key_record_new( + SignalMutPointerSignedPreKeyRecord* out, + uint32_t id, + uint64_t timestamp, + SignalConstPointerPublicKey pub_key, + SignalConstPointerPrivateKey priv_key, + SignalBorrowedBuffer signature +); +SignalFfiError* signal_signed_pre_key_record_serialize( + SignalOwnedBuffer* out, + SignalConstPointerSignedPreKeyRecord obj +); +SignalFfiError* signal_svr2_client_new( + SignalMutPointerSgxClientState* out, + SignalBorrowedBuffer mrenclave, + SignalBorrowedBuffer attestation_msg, + uint64_t current_timestamp +); +SignalFfiError* signal_svr_key_derive_logging_key( + SignalType_FixedArray32_uint8_t* out, + const SignalType_FixedArray32_uint8_t* svr_key +); +SignalFfiError* signal_svr_key_derive_registration_lock( + SignalType_FixedArray32_uint8_t* out, + const SignalType_FixedArray32_uint8_t* svr_key +); +SignalFfiError* signal_svr_key_derive_registration_recovery_password( + SignalType_FixedArray32_uint8_t* out, + const SignalType_FixedArray32_uint8_t* svr_key +); +SignalFfiError* signal_svr_key_derive_storage_service_key( + SignalType_FixedArray32_uint8_t* out, + const SignalType_FixedArray32_uint8_t* svr_key +); +SignalFfiError* signal_tokio_async_context_cancel( + SignalConstPointerTokioAsyncContext context, + uint64_t raw_cancellation_id +); +SignalFfiError* signal_tokio_async_context_destroy( + SignalMutPointerTokioAsyncContext p +); +SignalFfiError* signal_tokio_async_context_new( + SignalMutPointerTokioAsyncContext* out +); +SignalFfiError* signal_unauthenticated_chat_connection_account_exists( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + const SignalType_FixedArray17_uint8_t* account +); +SignalFfiError* signal_unauthenticated_chat_connection_backup_copy_media( + SignalMutPointerCopyBackupMediaStream* out, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer credential, + SignalBorrowedBuffer server_keys, + SignalConstPointerPrivateKey signing_key, + SignalBorrowedSliceOfBridgeCopyBackupMediaItemFfiArg items, + int64_t rng +); +SignalFfiError* signal_unauthenticated_chat_connection_backup_delete_all( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer credential, + SignalBorrowedBuffer server_keys, + SignalConstPointerPrivateKey signing_key, + int64_t rng +); +SignalFfiError* signal_unauthenticated_chat_connection_backup_delete_media( + SignalMutPointerDeleteBackupMediaStream* out, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer credential, + SignalBorrowedBuffer server_keys, + SignalConstPointerPrivateKey signing_key, + SignalBorrowedSliceOfBridgeDeleteBackupMediaItemFfiArg items, + int64_t rng +); +SignalFfiError* signal_unauthenticated_chat_connection_backup_get_cdn_credentials( + SignalCPromisePairOfOwnedBufferOfCStringPtrOwnedBufferOfCStringPtr* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer credential, + SignalBorrowedBuffer server_keys, + SignalConstPointerPrivateKey signing_key, + int32_t cdn, + int64_t rng +); +SignalFfiError* signal_unauthenticated_chat_connection_backup_get_media_backup_info( + SignalCPromiseBridgeMediaBackupInfoFfiResult* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer credential, + SignalBorrowedBuffer server_keys, + SignalConstPointerPrivateKey signing_key, + int64_t rng +); +SignalFfiError* signal_unauthenticated_chat_connection_backup_get_media_upload_form( + SignalCPromiseFfiUploadForm* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer credential, + SignalBorrowedBuffer server_keys, + SignalConstPointerPrivateKey signing_key, + uint64_t upload_size, + int64_t rng +); +SignalFfiError* signal_unauthenticated_chat_connection_backup_get_message_backup_info( + SignalCPromiseBridgeMessageBackupInfoFfiResult* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer credential, + SignalBorrowedBuffer server_keys, + SignalConstPointerPrivateKey signing_key, + int64_t rng +); +SignalFfiError* signal_unauthenticated_chat_connection_backup_get_svrb_credentials( + SignalCPromisePairOfCStringPtrCStringPtr* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer credential, + SignalBorrowedBuffer server_keys, + SignalConstPointerPrivateKey signing_key, + int64_t rng +); +SignalFfiError* signal_unauthenticated_chat_connection_backup_get_upload_form( + SignalCPromiseFfiUploadForm* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer credential, + SignalBorrowedBuffer server_keys, + SignalConstPointerPrivateKey signing_key, + uint64_t upload_size, + int64_t rng +); +SignalFfiError* signal_unauthenticated_chat_connection_backup_list_media( + SignalCPromiseListMediaResponseFfiResult* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer credential, + SignalBorrowedBuffer server_keys, + SignalConstPointerPrivateKey signing_key, + const int8_t* cursor, + int32_t limit, + int64_t rng +); +SignalFfiError* signal_unauthenticated_chat_connection_backup_refresh( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer credential, + SignalBorrowedBuffer server_keys, + SignalConstPointerPrivateKey signing_key, + int64_t rng +); +SignalFfiError* signal_unauthenticated_chat_connection_backup_set_public_key( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer credential, + SignalBorrowedBuffer server_keys, + SignalConstPointerPrivateKey signing_key, + int64_t rng +); +SignalFfiError* signal_unauthenticated_chat_connection_connect( + SignalCPromiseMutPointerUnauthenticatedChatConnection* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerConnectionManager connection_manager, + SignalBorrowedBytestringArray languages +); +SignalFfiError* signal_unauthenticated_chat_connection_destroy( + SignalMutPointerUnauthenticatedChatConnection p +); +SignalFfiError* signal_unauthenticated_chat_connection_disconnect( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat +); +SignalFfiError* signal_unauthenticated_chat_connection_get_pre_keys_access_key_auth( + SignalCPromiseFfiPreKeysResponse* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + const SignalType_FixedArray16_uint8_t* auth, + const SignalType_FixedArray17_uint8_t* target, + int32_t device +); +SignalFfiError* signal_unauthenticated_chat_connection_get_pre_keys_group_auth( + SignalCPromiseFfiPreKeysResponse* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer auth, + const SignalType_FixedArray17_uint8_t* target, + int32_t device +); +SignalFfiError* signal_unauthenticated_chat_connection_get_pre_keys_unrestricted_auth( + SignalCPromiseFfiPreKeysResponse* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + const SignalType_FixedArray17_uint8_t* target, + int32_t device +); +SignalFfiError* signal_unauthenticated_chat_connection_info( + SignalMutPointerChatConnectionInfo* out, + SignalConstPointerUnauthenticatedChatConnection chat +); +SignalFfiError* signal_unauthenticated_chat_connection_init_listener( + SignalConstPointerUnauthenticatedChatConnection chat, + SignalConstPointerFfiChatListenerStruct listener +); +SignalFfiError* signal_unauthenticated_chat_connection_look_up_username_hash( + SignalCPromiseOptionalUuid* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer hash +); +SignalFfiError* signal_unauthenticated_chat_connection_look_up_username_link( + SignalCPromiseOptionalPairOfCStringPtrc_uchar32* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalUuid uuid, + SignalBorrowedBuffer entropy +); +SignalFfiError* signal_unauthenticated_chat_connection_send( + SignalCPromiseFfiChatResponse* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalConstPointerHttpRequest http_request, + uint32_t timeout_millis +); +SignalFfiError* signal_unauthenticated_chat_connection_send_message( + SignalCPromisebool* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + const SignalType_FixedArray17_uint8_t* destination, + uint64_t timestamp, + SignalBorrowedSliceOfu32 device_ids, + SignalBorrowedSliceOfu32 registration_ids, + SignalBorrowedSliceOfBuffers contents, + uint8_t auth_kind, + SignalOptionalBorrowedSliceOfc_uchar auth_buffer, + bool online_only, + bool is_urgent +); +SignalFfiError* signal_unauthenticated_chat_connection_send_multi_recipient_message( + SignalCPromiseOwnedBufferOfc_uchar17* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + SignalBorrowedBuffer payload, + uint64_t timestamp, + SignalBorrowedBuffer auth, + bool online_only, + bool is_urgent +); +SignalFfiError* signal_unauthenticated_chat_connection_send_raw_grpc( + SignalCPromiseOwnedBuffer* promise, + SignalConstPointerTokioAsyncContext async_runtime, + SignalConstPointerUnauthenticatedChatConnection chat, + const int8_t* service, + const int8_t* method, + SignalBorrowedBuffer payload +); +SignalFfiError* signal_unidentified_sender_message_content_deserialize( + SignalMutPointerUnidentifiedSenderMessageContent* out, + SignalBorrowedBuffer data +); +SignalFfiError* signal_unidentified_sender_message_content_destroy( + SignalMutPointerUnidentifiedSenderMessageContent p +); +SignalFfiError* signal_unidentified_sender_message_content_get_content_hint( + uint32_t* out, + SignalConstPointerUnidentifiedSenderMessageContent m +); +SignalFfiError* signal_unidentified_sender_message_content_get_contents( + SignalOwnedBuffer* out, + SignalConstPointerUnidentifiedSenderMessageContent obj +); +SignalFfiError* signal_unidentified_sender_message_content_get_group_id_or_empty( + SignalOwnedBuffer* out, + SignalConstPointerUnidentifiedSenderMessageContent m +); +SignalFfiError* signal_unidentified_sender_message_content_get_msg_type( + uint8_t* out, + SignalConstPointerUnidentifiedSenderMessageContent m +); +SignalFfiError* signal_unidentified_sender_message_content_get_sender_cert( + SignalMutPointerSenderCertificate* out, + SignalConstPointerUnidentifiedSenderMessageContent m +); +SignalFfiError* signal_unidentified_sender_message_content_new( + SignalMutPointerUnidentifiedSenderMessageContent* out, + SignalConstPointerCiphertextMessage message, + SignalConstPointerSenderCertificate sender, + uint32_t content_hint, + SignalBorrowedBuffer group_id +); +SignalFfiError* signal_unidentified_sender_message_content_new_from_content_and_type( + SignalMutPointerUnidentifiedSenderMessageContent* out, + SignalBorrowedBuffer message_content, + uint8_t message_type, + SignalConstPointerSenderCertificate sender, + uint32_t content_hint, + SignalBorrowedBuffer group_id +); +SignalFfiError* signal_unidentified_sender_message_content_serialize( + SignalOwnedBuffer* out, + SignalConstPointerUnidentifiedSenderMessageContent obj +); +SignalFfiError* signal_username_candidates_from( + SignalBytestringArray* out, + const int8_t* nickname, + uint32_t min_len, + uint32_t max_len +); +SignalFfiError* signal_username_hash( + SignalType_FixedArray32_uint8_t* out, + const int8_t* username +); +SignalFfiError* signal_username_hash_from_parts( + SignalType_FixedArray32_uint8_t* out, + const int8_t* nickname, + const int8_t* discriminator, + uint32_t min_len, + uint32_t max_len +); +SignalFfiError* signal_username_link_create( + SignalOwnedBuffer* out, + const int8_t* username, + SignalBorrowedBuffer entropy +); +SignalFfiError* signal_username_link_decrypt_username( + SignalCStringPtr* out, + SignalBorrowedBuffer entropy, + SignalBorrowedBuffer encrypted_username +); +SignalFfiError* signal_username_proof( + SignalOwnedBuffer* out, + const int8_t* username, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_username_verify( + SignalBorrowedBuffer proof, + SignalBorrowedBuffer hash +); +SignalFfiError* signal_uuid_ciphertext_check_valid_contents( + SignalBorrowedBuffer buffer +); +SignalFfiError* signal_validating_mac_destroy( + SignalMutPointerValidatingMac p +); +SignalFfiError* signal_validating_mac_finalize( + int32_t* out, + SignalMutPointerValidatingMac mac +); +SignalFfiError* signal_validating_mac_initialize( + SignalMutPointerValidatingMac* out, + SignalBorrowedBuffer key, + uint32_t chunk_size, + SignalBorrowedBuffer digests +); +SignalFfiError* signal_validating_mac_update( + int32_t* out, + SignalMutPointerValidatingMac mac, + SignalBorrowedBuffer bytes, + uint32_t offset, + uint32_t length +); +SignalFfiError* signal_zk_credential_key_pair_check_valid_contents( + SignalBorrowedBuffer key_pair_bytes +); +SignalFfiError* signal_zk_credential_key_pair_generate_deterministic( + SignalOwnedBuffer* out, + const SignalType_FixedArray32_uint8_t* randomness +); +SignalFfiError* signal_zk_credential_key_pair_get_public_key( + SignalOwnedBuffer* out, + SignalBorrowedBuffer key_pair_bytes +); +SignalFfiError* signal_zk_credential_public_key_check_valid_contents( + SignalBorrowedBuffer public_key_bytes +); +typedef SignalBytestringArray SignalStringArray; +typedef SignalCPromiseOptionalPairOfCStringPtrc_uchar32 SignalCPromiseOptionalPairOfCStringPtru832; +typedef SignalCPromiseOwnedBuffer SignalCPromiseOwnedBufferOfc_uchar; +typedef SignalCPromiseOwnedBufferOfc_uchar17 SignalCPromiseOwnedBufferOfServiceIdFixedWidthBinaryBytes; +typedef SignalCPromisePairOfOwnedBufferOwnedBuffer SignalCPromisePairOfOwnedBufferOfc_ucharOwnedBufferOfc_uchar; +typedef SignalConstPointerFfiSyncInputStreamStruct SignalConstPointerFfiInputStreamStruct; +typedef SignalFfiIdentityKeyStoreStruct SignalIdentityKeyStore; +typedef SignalFfiKyberPreKeyStoreStruct SignalKyberPreKeyStore; +typedef SignalFfiPreKeyStoreStruct SignalPreKeyStore; +typedef SignalFfiSenderKeyStoreStruct SignalSenderKeyStore; +typedef SignalFfiSessionStoreStruct SignalSessionStore; +typedef SignalFfiSignedPreKeyStoreStruct SignalSignedPreKeyStore; +typedef SignalFfiSyncInputStreamStruct SignalFfiInputStreamStruct; +typedef SignalFfiSyncInputStreamStruct SignalInputStream; +typedef SignalFfiSyncInputStreamStruct SignalSyncInputStream; +typedef SignalOptionalPairOfCStringPtrc_uchar32 SignalOptionalPairOfCStringPtru832; +typedef SignalOwnedBufferOfc_uchar17 SignalOwnedBufferOfServiceIdFixedWidthBinaryBytes; +typedef SignalOwnedLookupResponseEntryList SignalOwnedBufferOfFfiCdsiLookupResponseEntry; +typedef SignalPairOfOwnedBufferOwnedBuffer SignalPairOfOwnedBufferOfc_ucharOwnedBufferOfc_uchar; +typedef SignalRegistrationAccountAttributes SignalRegistrationAccountAttributes; +typedef SignalType_FixedArray16_uint8_t SignalReceiptSerialBytes; +typedef SignalType_FixedArray16_uint8_t SignalUidBytes; +typedef SignalType_FixedArray16_uint8_t SignalUnidentifiedAccessKey; +typedef SignalType_FixedArray17_uint8_t SignalServiceIdFixedWidthBinaryBytes; +typedef SignalType_FixedArray32_uint8_t SignalAesKeyBytes; +typedef SignalType_FixedArray32_uint8_t SignalBackupKeyBytes; +typedef SignalType_FixedArray32_uint8_t SignalGroupIdentifierBytes; +typedef SignalType_FixedArray32_uint8_t SignalGroupMasterKeyBytes; +typedef SignalType_FixedArray32_uint8_t SignalProfileKeyBytes; +typedef SignalType_FixedArray32_uint8_t SignalProfileKeyVersionBytes; +typedef SignalType_FixedArray32_uint8_t SignalRandomnessBytes; +typedef SignalType_FixedArray64_uint8_t SignalNotarySignatureBytes; +typedef SignalType_FixedArray64_uint8_t SignalProfileKeyVersionEncodedBytes; +typedef SignalType_FixedArray64_uint8_t SignalSignatureBytes; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void SignalFfiChatListenerReceivedQueueEmpty; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void SignalFfiLoggerFlush; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalBytestringArray SignalFfiChatListenerReceivedAlerts; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalCStringPtr_SignalMutPointerServerMessageAck SignalFfiProvisioningListenerReceivedAddress; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalLogLevel_SignalCStringPtr_uint32_t_SignalCStringPtr SignalFfiLoggerLog; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalMutPointerProtocolAddress_SignalMutPointerSessionRecord SignalFfiSessionStoreStoreSession; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalMutPointerProtocolAddress_SignalUuid_SignalMutPointerSenderKeyRecord SignalFfiSenderKeyStoreStoreSenderKey; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalOwnedBuffer_SignalMutPointerServerMessageAck SignalFfiProvisioningListenerReceivedEnvelope; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalOwnedBuffer_uint64_t_SignalMutPointerServerMessageAck SignalFfiChatListenerReceivedIncomingMessage; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalFfiError SignalFfiChatListenerConnectionInterrupted; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalFfiError SignalFfiProvisioningListenerConnectionInterrupted; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerKyberPreKeyRecord_uint32_t SignalFfiKyberPreKeyStoreLoadKyberPreKey; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerPreKeyRecord_uint32_t SignalFfiPreKeyStoreLoadPreKey; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerPublicKey_SignalMutPointerProtocolAddress SignalFfiIdentityKeyStoreGetIdentityKey; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSenderKeyRecord_SignalMutPointerProtocolAddress_SignalUuid SignalFfiSenderKeyStoreLoadSenderKey; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSessionRecord_SignalMutPointerProtocolAddress SignalFfiSessionStoreLoadSession; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalMutPointerSignedPreKeyRecord_uint32_t SignalFfiSignedPreKeyStoreLoadSignedPreKey; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_SignalPairOfMutPointerPrivateKeyMutPointerPublicKey SignalFfiIdentityKeyStoreGetLocalIdentityKeyPair; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_bool_SignalMutPointerProtocolAddress_SignalMutPointerPublicKey_uint32_t SignalFfiIdentityKeyStoreIsTrustedIdentity; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_size_t_SignalBorrowedMutableBuffer SignalFfiSyncInputStreamRead; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_uint32_t SignalFfiIdentityKeyStoreGetLocalRegistrationId; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_SignalType_MutPointer_uint8_t_SignalMutPointerProtocolAddress_SignalMutPointerPublicKey SignalFfiIdentityKeyStoreSaveIdentityKey; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t SignalFfiPreKeyStoreRemovePreKey; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerKyberPreKeyRecord SignalFfiKyberPreKeyStoreStoreKyberPreKey; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerPreKeyRecord SignalFfiPreKeyStoreStorePreKey; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_SignalMutPointerSignedPreKeyRecord SignalFfiSignedPreKeyStoreStoreSignedPreKey; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint32_t_uint32_t_SignalMutPointerPublicKey SignalFfiKyberPreKeyStoreMarkKyberPreKeyUsed; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint64_t SignalFfiChatListenerReceivedServerTimestamp; +typedef SignalType_FunctionPointer_int32_t_SignalType_MutPointer_void_uint64_t SignalFfiSyncInputStreamSkip; +typedef SignalType_FunctionPointer_void_SignalType_MutPointer_void SignalFfiChatListenerDestroy; +typedef SignalType_FunctionPointer_void_SignalType_MutPointer_void SignalFfiIdentityKeyStoreDestroy; +typedef SignalType_FunctionPointer_void_SignalType_MutPointer_void SignalFfiKyberPreKeyStoreDestroy; +typedef SignalType_FunctionPointer_void_SignalType_MutPointer_void SignalFfiLoggerDestroy; +typedef SignalType_FunctionPointer_void_SignalType_MutPointer_void SignalFfiPreKeyStoreDestroy; +typedef SignalType_FunctionPointer_void_SignalType_MutPointer_void SignalFfiProvisioningListenerDestroy; +typedef SignalType_FunctionPointer_void_SignalType_MutPointer_void SignalFfiSenderKeyStoreDestroy; +typedef SignalType_FunctionPointer_void_SignalType_MutPointer_void SignalFfiSessionStoreDestroy; +typedef SignalType_FunctionPointer_void_SignalType_MutPointer_void SignalFfiSignedPreKeyStoreDestroy; +typedef SignalType_FunctionPointer_void_SignalType_MutPointer_void SignalFfiSyncInputStreamDestroy; +typedef uint64_t SignalCancellationId; diff --git a/pkg/libsignalgo/logging.go b/pkg/libsignalgo/logging.go index 59a9ab7..9fdfe65 100644 --- a/pkg/libsignalgo/logging.go +++ b/pkg/libsignalgo/logging.go @@ -33,7 +33,7 @@ var ffiLogger Logger //export signal_log_callback func signal_log_callback(ctx unsafe.Pointer, level C.SignalLogLevel, file C.SignalCStringPtr, line C.uint32_t, message C.SignalCStringPtr) { - ffiLogger.Log(LogLevel(int(level)), C.GoString(file), uint(line), C.GoString(message)) + ffiLogger.Log(LogLevel(int(level)), CopyCStringToString(file), uint(line), CopyCStringToString(message)) } //export signal_log_flush_callback diff --git a/pkg/libsignalgo/message.go b/pkg/libsignalgo/message.go index b781eaf..5496da9 100644 --- a/pkg/libsignalgo/message.go +++ b/pkg/libsignalgo/message.go @@ -71,10 +71,10 @@ func Decrypt(ctx context.Context, message *Message, fromAddress, localAddress *A type Message struct { nc noCopy - ptr *C.SignalMessage + ptr *C.SignalSignalMessage } -func wrapMessage(ptr *C.SignalMessage) *Message { +func wrapMessage(ptr *C.SignalSignalMessage) *Message { message := &Message{ptr: ptr} runtime.SetFinalizer(message, (*Message).Destroy) return message diff --git a/pkg/libsignalgo/messagebackupkey.go b/pkg/libsignalgo/messagebackupkey.go index eb21673..2ca753a 100644 --- a/pkg/libsignalgo/messagebackupkey.go +++ b/pkg/libsignalgo/messagebackupkey.go @@ -20,16 +20,17 @@ package libsignalgo #include "./libsignal-ffi.h" */ import "C" -import ( - "runtime" - "unsafe" -) +import "runtime" type MessageBackupKey struct { nc noCopy ptr *C.SignalMessageBackupKey } +const MessageBackupKeyBytesLength = 32 + +type messageBackupKeyBytes = fixedArray32 + func wrapMessageBackupKey(ptr *C.SignalMessageBackupKey) *MessageBackupKey { backupKey := &MessageBackupKey{ptr: ptr} runtime.SetFinalizer(backupKey, (*MessageBackupKey).Destroy) @@ -43,7 +44,7 @@ func MessageBackupKeyFromAccountEntropyPool(aep AccountEntropyPool, aci ServiceI signalFfiError := C.signal_message_backup_key_from_account_entropy_pool( &bk, aepC, - aci.CFixedBytes(), + aci.cConstFixedArray(), nil, // TODO what's a forward secrecy token? ) runtime.KeepAlive(aep) @@ -57,8 +58,8 @@ func MessageBackupKeyFromBackupKeyAndID(backupKey *BackupKey, backupID *BackupID var bk C.SignalMutPointerMessageBackupKey signalFfiError := C.signal_message_backup_key_from_backup_key_and_backup_id( &bk, - (*[C.SignalBACKUP_KEY_LEN]C.uint8_t)(unsafe.Pointer(backupKey)), - (*[BackupIDLength]C.uint8_t)(unsafe.Pointer(backupID)), + backupKey.cConstFixedArray(), + backupID.cConstFixedArray(), nil, // TODO what's a forward secrecy token? ) runtime.KeepAlive(backupKey) @@ -82,26 +83,26 @@ func (bk *MessageBackupKey) Destroy() error { return wrapError(C.signal_message_backup_key_destroy(bk.mutPtr())) } -func (bk *MessageBackupKey) GetHMACKey() ([32]byte, error) { - var out [32]byte +func (bk *MessageBackupKey) GetHMACKey() ([MessageBackupKeyBytesLength]byte, error) { + var out messageBackupKeyBytes signalFfiError := C.signal_message_backup_key_get_hmac_key( - (*[32]C.uint8_t)(unsafe.Pointer(&out)), + out.cFixedArray(), bk.constPtr(), ) if signalFfiError != nil { - return out, wrapError(signalFfiError) + return [MessageBackupKeyBytesLength]byte(out), wrapError(signalFfiError) } - return out, nil + return [MessageBackupKeyBytesLength]byte(out), nil } -func (bk *MessageBackupKey) GetAESKey() ([32]byte, error) { - var out [32]byte +func (bk *MessageBackupKey) GetAESKey() ([MessageBackupKeyBytesLength]byte, error) { + var out messageBackupKeyBytes signalFfiError := C.signal_message_backup_key_get_aes_key( - (*[32]C.uint8_t)(unsafe.Pointer(&out)), + out.cFixedArray(), bk.constPtr(), ) if signalFfiError != nil { - return out, wrapError(signalFfiError) + return [MessageBackupKeyBytesLength]byte(out), wrapError(signalFfiError) } - return out, nil + return [MessageBackupKeyBytesLength]byte(out), nil } diff --git a/pkg/libsignalgo/profilekey.go b/pkg/libsignalgo/profilekey.go index e49801a..007c635 100644 --- a/pkg/libsignalgo/profilekey.go +++ b/pkg/libsignalgo/profilekey.go @@ -32,12 +32,38 @@ import ( "go.mau.fi/util/random" ) -const ProfileKeyLength = C.SignalPROFILE_KEY_LEN +const ProfileKeyLength = 32 +const AccessKeyLength = 16 +const ProfileKeyVersionLength = 64 type ProfileKey [ProfileKeyLength]byte -type ProfileKeyCommitment [C.SignalPROFILE_KEY_COMMITMENT_LEN]byte -type ProfileKeyVersion [C.SignalPROFILE_KEY_VERSION_ENCODED_LEN]byte -type AccessKey [C.SignalACCESS_KEY_LEN]byte +type ProfileKeyCommitment = fixedArray97 +type ProfileKeyVersion [ProfileKeyVersionLength]byte +type AccessKey [AccessKeyLength]byte + +func (pk *ProfileKey) cFixedArray() *C.SignalType_FixedArray32_uint8_t { + return (*C.SignalType_FixedArray32_uint8_t)(unsafe.Pointer(pk)) +} + +func (pk *ProfileKey) cConstFixedArray() cFixedArray32Compat { + return cFixedArray32Compat(pk.cFixedArray()) +} + +func (pkv *ProfileKeyVersion) cFixedArray() *C.SignalType_FixedArray64_uint8_t { + return (*C.SignalType_FixedArray64_uint8_t)(unsafe.Pointer(pkv)) +} + +func (pkv *ProfileKeyVersion) cConstFixedArray() cFixedArray64Compat { + return cFixedArray64Compat(pkv.cFixedArray()) +} + +func (ak *AccessKey) cFixedArray() *C.SignalType_FixedArray16_uint8_t { + return (*C.SignalType_FixedArray16_uint8_t)(unsafe.Pointer(ak)) +} + +func (ak *AccessKey) cConstFixedArray() cFixedArray16Compat { + return cFixedArray16Compat(ak.cFixedArray()) +} func DeserializeProfileKey(bytes []byte) (*ProfileKey, error) { if len(bytes) == 0 { @@ -73,7 +99,7 @@ func (ak *AccessKey) Xor(other *AccessKey) *AccessKey { return ak } var result AccessKey - for i := 0; i < C.SignalACCESS_KEY_LEN; i++ { + for i := 0; i < AccessKeyLength; i++ { result[i] = ak[i] ^ other[i] } return &result @@ -84,13 +110,12 @@ func (ak *AccessKey) String() string { } func (pk *ProfileKey) GetCommitment(u uuid.UUID) (*ProfileKeyCommitment, error) { - c_result := [C.SignalPROFILE_KEY_COMMITMENT_LEN]C.uchar{} - c_profileKey := (*[C.SignalPROFILE_KEY_LEN]C.uchar)(unsafe.Pointer(pk)) - c_uuid := NewACIServiceID(u).CFixedBytes() + var result ProfileKeyCommitment + c_uuid := NewACIServiceID(u).cConstFixedArray() signalFfiError := C.signal_profile_key_get_commitment( - &c_result, - c_profileKey, + result.cFixedArray(), + pk.cConstFixedArray(), c_uuid, ) runtime.KeepAlive(pk) @@ -100,19 +125,16 @@ func (pk *ProfileKey) GetCommitment(u uuid.UUID) (*ProfileKeyCommitment, error) return nil, wrapError(signalFfiError) } - var result ProfileKeyCommitment - copy(result[:], C.GoBytes(unsafe.Pointer(&c_result), C.int(C.SignalPROFILE_KEY_COMMITMENT_LEN))) return &result, nil } func (pk *ProfileKey) GetProfileKeyVersion(u uuid.UUID) (*ProfileKeyVersion, error) { - c_result := [C.SignalPROFILE_KEY_VERSION_ENCODED_LEN]C.uchar{} - c_profileKey := (*[C.SignalPROFILE_KEY_LEN]C.uchar)(unsafe.Pointer(pk)) - c_uuid := NewACIServiceID(u).CFixedBytes() + var result ProfileKeyVersion + c_uuid := NewACIServiceID(u).cConstFixedArray() signalFfiError := C.signal_profile_key_get_profile_key_version( - &c_result, - c_profileKey, + result.cFixedArray(), + pk.cConstFixedArray(), c_uuid, ) runtime.KeepAlive(pk) @@ -122,18 +144,15 @@ func (pk *ProfileKey) GetProfileKeyVersion(u uuid.UUID) (*ProfileKeyVersion, err return nil, wrapError(signalFfiError) } - var result ProfileKeyVersion - copy(result[:], C.GoBytes(unsafe.Pointer(&c_result), C.int(C.SignalPROFILE_KEY_VERSION_ENCODED_LEN))) return &result, nil } func (pk *ProfileKey) DeriveAccessKey() (*AccessKey, error) { - c_result := [C.SignalACCESS_KEY_LEN]C.uchar{} - c_profileKey := (*[C.SignalPROFILE_KEY_LEN]C.uchar)(unsafe.Pointer(pk)) + var result AccessKey signalFfiError := C.signal_profile_key_derive_access_key( - &c_result, - c_profileKey, + result.cFixedArray(), + pk.cConstFixedArray(), ) runtime.KeepAlive(pk) @@ -141,31 +160,35 @@ func (pk *ProfileKey) DeriveAccessKey() (*AccessKey, error) { return nil, wrapError(signalFfiError) } - var result AccessKey - copy(result[:], C.GoBytes(unsafe.Pointer(&c_result), C.int(C.SignalACCESS_KEY_LEN))) return &result, nil } -type ProfileKeyCredentialRequestContext [C.SignalPROFILE_KEY_CREDENTIAL_REQUEST_CONTEXT_LEN]byte -type ProfileKeyCredentialRequest [C.SignalPROFILE_KEY_CREDENTIAL_REQUEST_LEN]byte +type ProfileKeyCredentialRequestContext [473]byte +type ProfileKeyCredentialRequest = fixedArray329 type ProfileKeyCredentialResponse []byte type ProfileKeyCredentialPresentation []byte -type ExpiringProfileKeyCredential [C.SignalEXPIRING_PROFILE_KEY_CREDENTIAL_LEN]byte -type ExpiringProfileKeyCredentialResponse [C.SignalEXPIRING_PROFILE_KEY_CREDENTIAL_RESPONSE_LEN]byte +type ExpiringProfileKeyCredential = fixedArray153 +type ExpiringProfileKeyCredentialResponse = fixedArray497 + +func (p *ProfileKeyCredentialRequestContext) cFixedArray() *C.SignalType_FixedArray473_uint8_t { + return (*C.SignalType_FixedArray473_uint8_t)(unsafe.Pointer(p)) +} + +func (p *ProfileKeyCredentialRequestContext) cConstFixedArray() cFixedArray473Compat { + return cFixedArray473Compat(p.cFixedArray()) +} func CreateProfileKeyCredentialRequestContext(serverPublicParams *ServerPublicParams, u uuid.UUID, profileKey ProfileKey) (*ProfileKeyCredentialRequestContext, error) { - c_result := [C.SignalPROFILE_KEY_CREDENTIAL_REQUEST_CONTEXT_LEN]C.uchar{} - randBytes := [32]byte(random.Bytes(32)) - c_random := (*[32]C.uchar)(unsafe.Pointer(&randBytes[0])) - c_profileKey := (*[C.SignalPROFILE_KEY_LEN]C.uchar)(unsafe.Pointer(&profileKey[0])) - c_uuid := NewACIServiceID(u).CFixedBytes() + var result ProfileKeyCredentialRequestContext + randBytes := Randomness(random.Bytes(RandomnessLength)) + c_uuid := NewACIServiceID(u).cConstFixedArray() signalFfiError := C.signal_server_public_params_create_profile_key_credential_request_context_deterministic( - &c_result, + result.cFixedArray(), C.SignalConstPointerServerPublicParams{serverPublicParams}, - c_random, + randBytes.cConstFixedArray(), c_uuid, - c_profileKey, + profileKey.cConstFixedArray(), ) runtime.KeepAlive(u) runtime.KeepAlive(profileKey) @@ -173,23 +196,20 @@ func CreateProfileKeyCredentialRequestContext(serverPublicParams *ServerPublicPa if signalFfiError != nil { return nil, wrapError(signalFfiError) } - result := ProfileKeyCredentialRequestContext(C.GoBytes(unsafe.Pointer(&c_result), C.int(C.SignalPROFILE_KEY_CREDENTIAL_REQUEST_CONTEXT_LEN))) return &result, nil } func (p *ProfileKeyCredentialRequestContext) ProfileKeyCredentialRequestContextGetRequest() (*ProfileKeyCredentialRequest, error) { - c_result := [C.SignalPROFILE_KEY_CREDENTIAL_REQUEST_LEN]C.uchar{} - c_context := (*[C.SignalPROFILE_KEY_CREDENTIAL_REQUEST_CONTEXT_LEN]C.uchar)(unsafe.Pointer(p)) + var result ProfileKeyCredentialRequest signalFfiError := C.signal_profile_key_credential_request_context_get_request( - &c_result, - c_context, + result.cFixedArray(), + p.cConstFixedArray(), ) runtime.KeepAlive(p) if signalFfiError != nil { return nil, wrapError(signalFfiError) } - result := ProfileKeyCredentialRequest(C.GoBytes(unsafe.Pointer(&c_result), C.int(C.SignalPROFILE_KEY_CREDENTIAL_REQUEST_LEN))) return &result, nil } @@ -205,12 +225,12 @@ func NewExpiringProfileKeyCredentialResponse(b []byte) (*ExpiringProfileKeyCrede } func ReceiveExpiringProfileKeyCredential(spp *ServerPublicParams, requestContext *ProfileKeyCredentialRequestContext, response *ExpiringProfileKeyCredentialResponse, currentTimeInSeconds uint64) (*ExpiringProfileKeyCredential, error) { - c_credential := [C.SignalEXPIRING_PROFILE_KEY_CREDENTIAL_LEN]C.uchar{} + var credential ExpiringProfileKeyCredential signalFfiError := C.signal_server_public_params_receive_expiring_profile_key_credential( - &c_credential, + credential.cFixedArray(), C.SignalConstPointerServerPublicParams{spp}, - (*[C.SignalPROFILE_KEY_CREDENTIAL_REQUEST_CONTEXT_LEN]C.uchar)(unsafe.Pointer(requestContext)), - (*[C.SignalEXPIRING_PROFILE_KEY_CREDENTIAL_RESPONSE_LEN]C.uchar)(unsafe.Pointer(response)), + requestContext.cConstFixedArray(), + response.cConstFixedArray(), (C.uint64_t)(currentTimeInSeconds), ) runtime.KeepAlive(requestContext) @@ -219,8 +239,6 @@ func ReceiveExpiringProfileKeyCredential(spp *ServerPublicParams, requestContext if signalFfiError != nil { return nil, wrapError(signalFfiError) } - credential := ExpiringProfileKeyCredential{} - copy(credential[:], C.GoBytes(unsafe.Pointer(&c_credential), C.int(C.SignalEXPIRING_PROFILE_KEY_CREDENTIAL_LEN))) return &credential, nil } @@ -231,25 +249,21 @@ func (a ProfileKeyCredentialPresentation) CheckValidContents() error { } func (a ProfileKeyCredentialPresentation) UUIDCiphertext() (UUIDCiphertext, error) { - out := [C.SignalUUID_CIPHERTEXT_LEN]C.uchar{} - signalFfiError := C.signal_profile_key_credential_presentation_get_uuid_ciphertext(&out, BytesToBuffer(a)) + var out UUIDCiphertext + signalFfiError := C.signal_profile_key_credential_presentation_get_uuid_ciphertext(out.cFixedArray(), BytesToBuffer(a)) runtime.KeepAlive(a) if signalFfiError != nil { return UUIDCiphertext{}, wrapError(signalFfiError) } - var result UUIDCiphertext - copy(result[:], C.GoBytes(unsafe.Pointer(&out), C.int(C.SignalUUID_CIPHERTEXT_LEN))) - return result, nil + return out, nil } func (a ProfileKeyCredentialPresentation) ProfileKeyCiphertext() (ProfileKeyCiphertext, error) { - out := [C.SignalPROFILE_KEY_CIPHERTEXT_LEN]C.uchar{} - signalFfiError := C.signal_profile_key_credential_presentation_get_profile_key_ciphertext(&out, BytesToBuffer(a)) + var out ProfileKeyCiphertext + signalFfiError := C.signal_profile_key_credential_presentation_get_profile_key_ciphertext(out.cFixedArray(), BytesToBuffer(a)) runtime.KeepAlive(a) if signalFfiError != nil { return ProfileKeyCiphertext{}, wrapError(signalFfiError) } - var result ProfileKeyCiphertext - copy(result[:], C.GoBytes(unsafe.Pointer(&out), C.int(C.SignalPROFILE_KEY_CIPHERTEXT_LEN))) - return result, nil + return out, nil } diff --git a/pkg/libsignalgo/serverpublicparams.go b/pkg/libsignalgo/serverpublicparams.go index c1de0cd..752bc2d 100644 --- a/pkg/libsignalgo/serverpublicparams.go +++ b/pkg/libsignalgo/serverpublicparams.go @@ -24,15 +24,16 @@ import "C" import ( "fmt" "runtime" - "unsafe" ) type ServerPublicParams = C.SignalServerPublicParams -type NotarySignature [C.SignalSIGNATURE_LEN]byte +type NotarySignature = fixedArray64 + +const ServerPublicParamsLength = 673 func DeserializeServerPublicParams(params []byte) (*ServerPublicParams, error) { - if len(params) != C.SignalSERVER_PUBLIC_PARAMS_LEN { - return nil, fmt.Errorf("invalid server public params length: %d (expected %d)", len(params), int(C.SignalSERVER_PUBLIC_PARAMS_LEN)) + if len(params) != ServerPublicParamsLength { + return nil, fmt.Errorf("invalid server public params length: %d (expected %d)", len(params), ServerPublicParamsLength) } var out C.SignalMutPointerServerPublicParams signalFfiError := C.signal_server_public_params_deserialize(&out, BytesToBuffer(params[:])) @@ -47,11 +48,10 @@ func ServerPublicParamsVerifySignature( messageBytes []byte, NotarySignature NotarySignature, ) error { - c_notarySignature := (*[C.SignalSIGNATURE_LEN]C.uint8_t)(unsafe.Pointer(&NotarySignature[0])) signalFfiError := C.signal_server_public_params_verify_signature( C.SignalConstPointerServerPublicParams{serverPublicParams}, BytesToBuffer(messageBytes), - c_notarySignature, + NotarySignature.cConstFixedArray(), ) runtime.KeepAlive(messageBytes) return wrapError(signalFfiError) diff --git a/pkg/libsignalgo/serviceid.go b/pkg/libsignalgo/serviceid.go index 21d64b2..38631ee 100644 --- a/pkg/libsignalgo/serviceid.go +++ b/pkg/libsignalgo/serviceid.go @@ -133,7 +133,10 @@ func (s ServiceID) MarshalZerologObject(e *zerolog.Event) { e.Stringer("uuid", s.UUID) } -type ServiceIDFixedBytes [17]byte +const ServiceIDUUIDLength = 16 +const ServiceIDFixedBytesLength = 17 + +type ServiceIDFixedBytes = fixedArray17 func (s ServiceID) FixedBytes() *ServiceIDFixedBytes { var result ServiceIDFixedBytes @@ -162,18 +165,18 @@ func ServiceIDFromString(val string) (ServiceID, error) { } func ServiceIDFromBytes(bytes []byte) (ServiceID, error) { - if len(bytes) == 16 { + if len(bytes) == ServiceIDUUIDLength { return NewACIServiceID(uuid.UUID(bytes)), nil - } else if len(bytes) == 17 { + } else if len(bytes) == ServiceIDFixedBytesLength { return ServiceID{ Type: ServiceIDType(bytes[0]), UUID: uuid.UUID(bytes[1:]), }, nil } - return EmptyServiceID, fmt.Errorf("invalid ServiceID byte length: %d (expected 16 or 17)", len(bytes)) + return EmptyServiceID, fmt.Errorf("invalid ServiceID byte length: %d (expected %d or %d)", len(bytes), ServiceIDUUIDLength, ServiceIDFixedBytesLength) } -func ServiceIDFromCFixedBytes(serviceID *C.SignalServiceIdFixedWidthBinaryBytes) ServiceID { +func ServiceIDFromCFixedBytes(serviceID *C.SignalType_FixedArray17_uint8_t) ServiceID { var id ServiceID fixedBytes := (*ServiceIDFixedBytes)(unsafe.Pointer(serviceID)) id.Type = ServiceIDType(fixedBytes[0]) @@ -181,6 +184,10 @@ func ServiceIDFromCFixedBytes(serviceID *C.SignalServiceIdFixedWidthBinaryBytes) return id } -func (s ServiceID) CFixedBytes() cPNIType { - return cPNIType(unsafe.Pointer(s.FixedBytes())) +func (s ServiceID) cFixedArray() *C.SignalType_FixedArray17_uint8_t { + return s.FixedBytes().cFixedArray() +} + +func (s ServiceID) cConstFixedArray() cFixedArray17Compat { + return cFixedArray17Compat(s.cFixedArray()) } diff --git a/pkg/libsignalgo/serviceid_clang.go b/pkg/libsignalgo/serviceid_clang.go deleted file mode 100644 index 89197b6..0000000 --- a/pkg/libsignalgo/serviceid_clang.go +++ /dev/null @@ -1,11 +0,0 @@ -//go:build darwin || android || ios || (windows && arm64) - -package libsignalgo - -/* -#include "./libsignal-ffi.h" -#include -*/ -import "C" - -type cPNIType = *C.SignalServiceIdFixedWidthBinaryBytes diff --git a/pkg/libsignalgo/serviceid_gcc.go b/pkg/libsignalgo/serviceid_gcc.go deleted file mode 100644 index 0feb627..0000000 --- a/pkg/libsignalgo/serviceid_gcc.go +++ /dev/null @@ -1,14 +0,0 @@ -//go:build !(darwin || android || ios || (windows && arm64)) - -package libsignalgo - -/* -#include "./libsignal-ffi.h" -#include -*/ -import "C" - -// Hack for https://github.com/golang/go/issues/7270 -// The clang version is more correct, but doesn't work with gcc - -type cPNIType = *[17]C.uint8_t diff --git a/pkg/libsignalgo/sessionrecord.go b/pkg/libsignalgo/sessionrecord.go index fddff28..b4f2afb 100644 --- a/pkg/libsignalgo/sessionrecord.go +++ b/pkg/libsignalgo/sessionrecord.go @@ -105,7 +105,6 @@ func (sr *SessionRecord) HasCurrentState() (bool, error) { signalFfiError := C.signal_session_record_has_usable_sender_chain( &result, sr.constPtr(), - C.double(0.0), C.uint64_t(time.Now().Unix()), ) runtime.KeepAlive(sr) diff --git a/pkg/libsignalgo/update-ffi-docker-inner.sh b/pkg/libsignalgo/update-ffi-docker-inner.sh index e343887..5b96bbb 100755 --- a/pkg/libsignalgo/update-ffi-docker-inner.sh +++ b/pkg/libsignalgo/update-ffi-docker-inner.sh @@ -1,11 +1,10 @@ #!/bin/sh cd /data export RUSTFLAGS="-Ctarget-feature=-crt-static" RUSTC_WRAPPER="" -apk add --no-cache git make cmake protobuf-dev musl-dev g++ clang-dev cbindgen +apk add --no-cache git make cmake protobuf-dev musl-dev g++ clang-dev cd libsignal cargo build -p libsignal-ffi --release -cbindgen --profile release rust/bridge/ffi -o libsignal-ffi.h cd .. mv libsignal/target/release/libsignal_ffi.a . -mv libsignal/libsignal-ffi.h . +cp libsignal/swift/Sources/SignalFfi/signal_ffi.h libsignal-ffi.h chown 1000:1000 libsignal_ffi.a libsignal-ffi.h version.go diff --git a/pkg/libsignalgo/update-ffi.sh b/pkg/libsignalgo/update-ffi.sh index 7561b61..b1061b9 100755 --- a/pkg/libsignalgo/update-ffi.sh +++ b/pkg/libsignalgo/update-ffi.sh @@ -28,14 +28,11 @@ echo "const Version = \"$(git describe --tags --always)\"" >> ../version.go # Build libsignal cargo build -p libsignal-ffi --release -# Regenerate the header file -cbindgen --profile release rust/bridge/ffi -o libsignal-ffi.h - # Navigate back to the original directory cd "$ORIGINAL_DIR" # Copy files from the libsignal directory cp "${LIBSIGNAL_DIRECTORY}/target/release/libsignal_ffi.a" . -cp "${LIBSIGNAL_DIRECTORY}/libsignal-ffi.h" . +cp "${LIBSIGNAL_DIRECTORY}/swift/Sources/SignalFfi/signal_ffi.h" libsignal-ffi.h echo "Files copied successfully." diff --git a/pkg/libsignalgo/version.go b/pkg/libsignalgo/version.go index 0bdeccf..b74b511 100644 --- a/pkg/libsignalgo/version.go +++ b/pkg/libsignalgo/version.go @@ -2,4 +2,4 @@ package libsignalgo -const Version = "v0.97.2" +const Version = "v0.100.0" From 979d48aeb14304bb281919b9a062b3adfeeae5b1 Mon Sep 17 00:00:00 2001 From: Tulir Asokan Date: Fri, 7 Aug 2026 15:15:39 +0300 Subject: [PATCH 09/14] libsignalgo/conversions: use unsafe.Pointer for go -> c string too --- pkg/libsignalgo/conversions.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/libsignalgo/conversions.go b/pkg/libsignalgo/conversions.go index 3babfe8..a70e782 100644 --- a/pkg/libsignalgo/conversions.go +++ b/pkg/libsignalgo/conversions.go @@ -25,7 +25,7 @@ import "unsafe" func GoStringToCString(str string) (C.SignalCStringPtr, func()) { cStr := C.CString(str) - return (*C.int8_t)(cStr), func() { + return C.SignalCStringPtr(unsafe.Pointer(cStr)), func() { C.free(unsafe.Pointer(cStr)) } } From 8c7333a033cc8dbaf6676b1f9211d2906154277b Mon Sep 17 00:00:00 2001 From: Tulir Asokan Date: Fri, 7 Aug 2026 15:21:08 +0300 Subject: [PATCH 10/14] msgconv/matrixfmt: fix tests [skip cd] --- pkg/msgconv/matrixfmt/convert_test.go | 25 ++++--------------------- 1 file changed, 4 insertions(+), 21 deletions(-) diff --git a/pkg/msgconv/matrixfmt/convert_test.go b/pkg/msgconv/matrixfmt/convert_test.go index 1ade316..5e243e3 100644 --- a/pkg/msgconv/matrixfmt/convert_test.go +++ b/pkg/msgconv/matrixfmt/convert_test.go @@ -111,22 +111,13 @@ func TestParse_HTML(t *testing.T) { { name: "List", in: "
  • woof
  • meow
  • hmm\nmeow
  • meow

    meow

", - out: "* woof\n* meow\n* hmm\n meow\n* > meow\n > \n > # meow", + out: "* woof\n* meow\n* ```\n hmm\n meow\n ```\n* > meow\n > \n > # meow", ent: signalfmt.BodyRangeList{{ Start: 9, Length: 4, Value: signalfmt.StyleBold, }, { - Start: 16, - Length: 3, - Value: signalfmt.StyleMonospace, - }, { - // FIXME optimally this would be a single range with the previous one so the indent is also monospace - Start: 22, - Length: 4, - Value: signalfmt.StyleMonospace, - }, { - Start: 45, + Start: 57, Length: 6, Value: signalfmt.StyleBold, }}, @@ -134,21 +125,13 @@ func TestParse_HTML(t *testing.T) { { name: "OrderedList", in: "
  1. woof
  2. meow
  3. hmm\nmeow
  4. meow

    meow

", - out: "9. woof\n10. meow\n11. hmm\n meow\n12. > meow\n > \n > # meow", + out: "9. woof\n10. meow\n11. ```\n hmm\n meow\n ```\n12. > meow\n > \n > # meow", ent: signalfmt.BodyRangeList{{ Start: 13, Length: 4, Value: signalfmt.StyleBold, }, { - Start: 22, - Length: 3, - Value: signalfmt.StyleMonospace, - }, { - Start: 30, - Length: 4, - Value: signalfmt.StyleMonospace, - }, { - Start: 59, + Start: 75, Length: 6, Value: signalfmt.StyleBold, }}, From 4eaacd6c5664e4678a43b2d3d5ffb291c0fc174f Mon Sep 17 00:00:00 2001 From: Nick Mills-Barrett Date: Wed, 12 Aug 2026 18:22:22 +0100 Subject: [PATCH 11/14] login: use `ErrInvalidLoginFlowID` for unknown login flow IDs (#663) --- pkg/connector/login.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/connector/login.go b/pkg/connector/login.go index 0446d23..60fb936 100644 --- a/pkg/connector/login.go +++ b/pkg/connector/login.go @@ -44,7 +44,7 @@ func (s *SignalConnector) GetLoginFlows() []bridgev2.LoginFlow { func (s *SignalConnector) CreateLogin(ctx context.Context, user *bridgev2.User, flowID string) (bridgev2.LoginProcess, error) { if flowID != "qr" { - return nil, fmt.Errorf("invalid login flow ID") + return nil, bridgev2.ErrInvalidLoginFlowID } return &QRLogin{User: user, Main: s}, nil } From 771150ee4ac7a85e88a1d224f426b80f243138df Mon Sep 17 00:00:00 2001 From: Nick Mills-Barrett Date: Fri, 14 Aug 2026 14:02:14 +0100 Subject: [PATCH 12/14] signalmeow/storageservice: store own profile key from account record (#664) --- pkg/signalmeow/storageservice.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/pkg/signalmeow/storageservice.go b/pkg/signalmeow/storageservice.go index 899c54b..2326e1c 100644 --- a/pkg/signalmeow/storageservice.go +++ b/pkg/signalmeow/storageservice.go @@ -137,6 +137,12 @@ func (cli *Client) processStorageInTxn(ctx context.Context, update *StorageUpdat case *signalpb.StorageRecord_Account: log.Trace().Any("account_record", data.Account).Msg("Found account record") cli.Store.AccountRecord = data.Account + if len(data.Account.ProfileKey) == libsignalgo.ProfileKeyLength { + err := cli.Store.RecipientStore.StoreProfileKey(ctx, cli.Store.ACI, libsignalgo.ProfileKey(data.Account.ProfileKey)) + if err != nil { + return fmt.Errorf("failed to store own profile key: %w", err) + } + } err := cli.Store.DeviceStore.PutDevice(ctx, &cli.Store.DeviceData) if err != nil { return fmt.Errorf("failed to save device after receiving account record: %w", err) From 77a6664bc563d8909c7fde70dd175fa999eb12b6 Mon Sep 17 00:00:00 2001 From: Nick Mills-Barrett Date: Fri, 14 Aug 2026 14:52:41 +0100 Subject: [PATCH 13/14] dependencies: update mautrix-go --- go.mod | 2 +- go.sum | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/go.mod b/go.mod index 0c92e4c..e6db605 100644 --- a/go.mod +++ b/go.mod @@ -21,7 +21,7 @@ require ( golang.org/x/sync v0.22.0 google.golang.org/protobuf v1.36.11 gopkg.in/yaml.v3 v3.0.1 - maunium.net/go/mautrix v0.29.1-0.20260723095015-f7cfa8766d2b + maunium.net/go/mautrix v0.29.1-0.20260814120312-a6614a03769b ) require ( diff --git a/go.sum b/go.sum index d275694..70b4486 100644 --- a/go.sum +++ b/go.sum @@ -91,5 +91,5 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= maunium.net/go/mauflag v1.0.0 h1:YiaRc0tEI3toYtJMRIfjP+jklH45uDHtT80nUamyD4M= maunium.net/go/mauflag v1.0.0/go.mod h1:nLivPOpTpHnpzEh8jEdSL9UqO9+/KBJFmNRlwKfkPeA= -maunium.net/go/mautrix v0.29.1-0.20260723095015-f7cfa8766d2b h1:5ZKdE95/xcAGDUtS7IYhaa/ENdEmedG5CEjkgkzu6H8= -maunium.net/go/mautrix v0.29.1-0.20260723095015-f7cfa8766d2b/go.mod h1:PeLuIih5jnbwb2xKNNi0Te7AtINEQE2Uv3p6iG3RV80= +maunium.net/go/mautrix v0.29.1-0.20260814120312-a6614a03769b h1:DKy6Vnhoyxq0TY30k9J8mGuaV3/qBgpEnb17V0Ouv9w= +maunium.net/go/mautrix v0.29.1-0.20260814120312-a6614a03769b/go.mod h1:PeLuIih5jnbwb2xKNNi0Te7AtINEQE2Uv3p6iG3RV80= From 0d5f3f457dac53707973f525809fe9c6dc926bd6 Mon Sep 17 00:00:00 2001 From: Tulir Asokan Date: Sun, 16 Aug 2026 15:48:54 +0300 Subject: [PATCH 14/14] Bump version to v26.08 --- CHANGELOG.md | 7 ++++++ cmd/mautrix-signal/main.go | 2 +- go.mod | 24 ++++++++++----------- go.sum | 44 +++++++++++++++++++------------------- 4 files changed, 42 insertions(+), 35 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a8b51a1..468ca95 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,10 @@ +# v26.08 + +* Updated libsignal to v0.100.0 +* Added support for handling own profile key changes. +* Changed attachment bridging behavior to match Signal Desktop. +* Fixed edited messages being bridged twice if certain race conditions occurred. + # v26.07 * Updated Docker image to Alpine 3.24. diff --git a/cmd/mautrix-signal/main.go b/cmd/mautrix-signal/main.go index abe2755..c5f5bf9 100644 --- a/cmd/mautrix-signal/main.go +++ b/cmd/mautrix-signal/main.go @@ -37,7 +37,7 @@ var m = mxmain.BridgeMain{ Name: "mautrix-signal", URL: "https://github.com/mautrix/signal", Description: "A Matrix-Signal puppeting bridge.", - Version: "26.07", + Version: "26.08", SemCalVer: true, Connector: &connector.SignalConnector{}, diff --git a/go.mod b/go.mod index e6db605..5c754b2 100644 --- a/go.mod +++ b/go.mod @@ -2,7 +2,7 @@ module go.mau.fi/mautrix-signal go 1.25.0 -toolchain go1.26.5 +toolchain go1.26.6 tool go.mau.fi/util/cmd/maubuild @@ -14,14 +14,14 @@ require ( github.com/rs/zerolog v1.35.1 github.com/stretchr/testify v1.11.1 github.com/tidwall/gjson v1.19.0 - go.mau.fi/util v0.9.12-0.20260719092501-f9c03d846391 - golang.org/x/crypto v0.54.0 - golang.org/x/exp v0.0.0-20260709172345-9ea1abe57597 - golang.org/x/net v0.57.0 + go.mau.fi/util v0.10.0 + golang.org/x/crypto v0.55.0 + golang.org/x/exp v0.0.0-20260813180055-c1d0aacb2297 + golang.org/x/net v0.58.0 golang.org/x/sync v0.22.0 - google.golang.org/protobuf v1.36.11 + google.golang.org/protobuf v1.36.12 gopkg.in/yaml.v3 v3.0.1 - maunium.net/go/mautrix v0.29.1-0.20260814120312-a6614a03769b + maunium.net/go/mautrix v0.30.0 ) require ( @@ -32,8 +32,8 @@ require ( github.com/lib/pq v1.12.3 // indirect github.com/mattn/go-colorable v0.1.14 // indirect github.com/mattn/go-isatty v0.0.20 // indirect - github.com/mattn/go-sqlite3 v1.14.48 // indirect - github.com/petermattis/goid v0.0.0-20260713124913-97594f28f5ca // indirect + github.com/mattn/go-sqlite3 v1.14.49 // indirect + github.com/petermattis/goid v0.0.0-20260816044145-ed329add6b1b // indirect github.com/pmezard/go-difflib v1.0.0 // indirect github.com/rogpeppe/go-internal v1.10.0 // indirect github.com/rs/xid v1.6.0 // indirect @@ -41,11 +41,11 @@ require ( github.com/tidwall/match v1.2.0 // indirect github.com/tidwall/pretty v1.2.1 // indirect github.com/tidwall/sjson v1.2.5 // indirect - github.com/yuin/goldmark v1.8.4 // indirect + github.com/yuin/goldmark v1.8.5 // indirect go.mau.fi/zeroconfig v0.2.0 // indirect - golang.org/x/mod v0.38.0 // indirect + golang.org/x/mod v0.40.0 // indirect golang.org/x/sys v0.47.0 // indirect - golang.org/x/text v0.40.0 // indirect + golang.org/x/text v0.41.0 // indirect gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect maunium.net/go/mauflag v1.0.0 // indirect diff --git a/go.sum b/go.sum index 70b4486..e212cb7 100644 --- a/go.sum +++ b/go.sum @@ -30,10 +30,10 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-pointer v0.0.1 h1:n+XhsuGeVO6MEAp7xyEukFINEa+Quek5psIR/ylA6o0= github.com/mattn/go-pointer v0.0.1/go.mod h1:2zXcozF6qYGgmsG+SeTZz3oAbFLdD3OWqnUbNvJZAlc= -github.com/mattn/go-sqlite3 v1.14.48 h1:7XHIgl0a8HwOaiK4E47ozLkST78rR9+OtNGx27D/TFs= -github.com/mattn/go-sqlite3 v1.14.48/go.mod h1:6JTjA44L93a0QCyJef5YvlPoKXntQPjzWv5gtm9sB6w= -github.com/petermattis/goid v0.0.0-20260713124913-97594f28f5ca h1:GHSUVE4yOgX4E7kTRzpxCPbCOYkd3Kj8Dgdod30OI1E= -github.com/petermattis/goid v0.0.0-20260713124913-97594f28f5ca/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4= +github.com/mattn/go-sqlite3 v1.14.49 h1:B8jBHC3xhxZgxztrgruTuLucebnULQnx4W7cF7SAE9w= +github.com/mattn/go-sqlite3 v1.14.49/go.mod h1:6JTjA44L93a0QCyJef5YvlPoKXntQPjzWv5gtm9sB6w= +github.com/petermattis/goid v0.0.0-20260816044145-ed329add6b1b h1:sS7HLzwS+dO+gxATgQfeZDEdUZe2pKAB3nGoUwP5zU0= +github.com/petermattis/goid v0.0.0-20260816044145-ed329add6b1b/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= @@ -59,29 +59,29 @@ github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4= github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY= github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28= -github.com/yuin/goldmark v1.8.4 h1:oat/nd3U6NeQqFEL3xpEJq7d7c86NI+DbSNGAs4xnjA= -github.com/yuin/goldmark v1.8.4/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg= -go.mau.fi/util v0.9.12-0.20260719092501-f9c03d846391 h1:lsvBEY8MJfYdV61YbwikiQvb0Al/onbmLW5wfl/0tag= -go.mau.fi/util v0.9.12-0.20260719092501-f9c03d846391/go.mod h1:xunp/oIQfFD68HHcNHfG0pOiHkvEtDhTweeIwKJ//+Q= +github.com/yuin/goldmark v1.8.5 h1:r6N5afV5qj/5S4UTch8agZHJ8UxNCMwX7WjkkJam2NA= +github.com/yuin/goldmark v1.8.5/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg= +go.mau.fi/util v0.10.0 h1:vH9IXZmfBKa96p47HxrVqEPkrj02zDJg3o4EF172+Lk= +go.mau.fi/util v0.10.0/go.mod h1:uZwpm9sK4wO2Qqy+t6QoVq29szMsRxWXp9/BkQLG4xk= go.mau.fi/zeroconfig v0.2.0 h1:e/OGEERqVRRKlgaro7E6bh8xXiKFSXB3eNNIud7FUjU= go.mau.fi/zeroconfig v0.2.0/go.mod h1:J0Vn0prHNOm493oZoQ84kq83ZaNCYZnq+noI1b1eN8w= -golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw= -golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk= -golang.org/x/exp v0.0.0-20260709172345-9ea1abe57597 h1:qLvzZeaANDgyVOA8pyHCOStGlXn0rseXma+GQjeuv2g= -golang.org/x/exp v0.0.0-20260709172345-9ea1abe57597/go.mod h1:EdfpwwqSu+0Li0mzskwHU6FWDV3t9Q+RZDo3QMUtL3Q= -golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk= -golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= +golang.org/x/exp v0.0.0-20260813180055-c1d0aacb2297 h1:YXnL44eJ77R+ji4/ooy8UsXIhz+lbi2Qgdlc8iRN0gY= +golang.org/x/exp v0.0.0-20260813180055-c1d0aacb2297/go.mod h1:Mkmymgv+uMpSQ/XxJ/7GpdrdYoqm3u72jEbpCLiJmNk= +golang.org/x/mod v0.40.0 h1:hUv+3cXcdRHz08UmSiOob7sadHig73uo5bkXxQ/tvUs= +golang.org/x/mod v0.40.0/go.mod h1:0/weTWkPWGBikyTWAX3dkjVztMmBA5hM0DH6BElSupE= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs= -golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= @@ -91,5 +91,5 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= maunium.net/go/mauflag v1.0.0 h1:YiaRc0tEI3toYtJMRIfjP+jklH45uDHtT80nUamyD4M= maunium.net/go/mauflag v1.0.0/go.mod h1:nLivPOpTpHnpzEh8jEdSL9UqO9+/KBJFmNRlwKfkPeA= -maunium.net/go/mautrix v0.29.1-0.20260814120312-a6614a03769b h1:DKy6Vnhoyxq0TY30k9J8mGuaV3/qBgpEnb17V0Ouv9w= -maunium.net/go/mautrix v0.29.1-0.20260814120312-a6614a03769b/go.mod h1:PeLuIih5jnbwb2xKNNi0Te7AtINEQE2Uv3p6iG3RV80= +maunium.net/go/mautrix v0.30.0 h1:bad+q7w5tLqiHpr+oUxVI+8m8ePbV3AvoFKg2jQzPyo= +maunium.net/go/mautrix v0.30.0/go.mod h1:bb0gjxbTFOqTaAYKGw5E7j9XROUR2Sl1Etm3IbmYXbo=