@signalapp/libsignal-client 0.76.0 → 0.76.2

package/Native.d.ts

@@ -199,7 +199,7 @@ export function AuthCredentialPresentation_GetRedemptionTime(presentationBytes:
 export function AuthCredentialPresentation_GetUuidCiphertext(presentationBytes: Uint8Array): Serialized<UuidCiphertext>;
 export function AuthCredentialWithPniResponse_CheckValidContents(bytes: Uint8Array): void;
 export function AuthCredentialWithPni_CheckValidContents(bytes: Uint8Array): void;
-export function AuthenticatedChatConnection_connect(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>, username: string, password: string, receiveStories: boolean): CancellablePromise<AuthenticatedChatConnection>;
+export function AuthenticatedChatConnection_connect(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>, username: string, password: string, receiveStories: boolean, languages: string[]): CancellablePromise<AuthenticatedChatConnection>;
 export function AuthenticatedChatConnection_disconnect(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<AuthenticatedChatConnection>): CancellablePromise<void>;
 export function AuthenticatedChatConnection_info(chat: Wrapper<AuthenticatedChatConnection>): ChatConnectionInfo;
 export function AuthenticatedChatConnection_init_listener(chat: Wrapper<AuthenticatedChatConnection>, listener: ChatListener): void;
@@ -470,13 +470,11 @@ export function RegistrationService_CheckSvr2Credentials(asyncRuntime: Wrapper<T
 export function RegistrationService_CreateSession(asyncRuntime: Wrapper<TokioAsyncContext>, createSession: RegistrationCreateSessionRequest, connectChat: ConnectChatBridge): CancellablePromise<RegistrationService>;
 export function RegistrationService_RegisterAccount(asyncRuntime: Wrapper<TokioAsyncContext>, service: Wrapper<RegistrationService>, registerAccount: Wrapper<RegisterAccountRequest>, accountAttributes: Wrapper<RegistrationAccountAttributes>): CancellablePromise<RegisterAccountResponse>;
 export function RegistrationService_RegistrationSession(service: Wrapper<RegistrationService>): RegistrationSession;
-export function RegistrationService_RequestPushChallenge(asyncRuntime: Wrapper<TokioAsyncContext>, service: Wrapper<RegistrationService>, pushToken: string, pushTokenType: RegistrationPushTokenType): CancellablePromise<void>;
 export function RegistrationService_RequestVerificationCode(asyncRuntime: Wrapper<TokioAsyncContext>, service: Wrapper<RegistrationService>, transport: string, client: string, languages: string[]): CancellablePromise<void>;
 export function RegistrationService_ReregisterAccount(asyncRuntime: Wrapper<TokioAsyncContext>, connectChat: ConnectChatBridge, number: string, registerAccount: Wrapper<RegisterAccountRequest>, accountAttributes: Wrapper<RegistrationAccountAttributes>): CancellablePromise<RegisterAccountResponse>;
 export function RegistrationService_ResumeSession(asyncRuntime: Wrapper<TokioAsyncContext>, sessionId: string, number: string, connectChat: ConnectChatBridge): CancellablePromise<RegistrationService>;
 export function RegistrationService_SessionId(service: Wrapper<RegistrationService>): string;
 export function RegistrationService_SubmitCaptcha(asyncRuntime: Wrapper<TokioAsyncContext>, service: Wrapper<RegistrationService>, captchaValue: string): CancellablePromise<void>;
-export function RegistrationService_SubmitPushChallenge(asyncRuntime: Wrapper<TokioAsyncContext>, service: Wrapper<RegistrationService>, pushChallenge: string): CancellablePromise<void>;
 export function RegistrationService_SubmitVerificationCode(asyncRuntime: Wrapper<TokioAsyncContext>, service: Wrapper<RegistrationService>, code: string): CancellablePromise<void>;
 export function RegistrationSession_GetAllowedToRequestCode(session: Wrapper<RegistrationSession>): boolean;
 export function RegistrationSession_GetNextCallSeconds(session: Wrapper<RegistrationSession>): number | null;
@@ -679,9 +677,13 @@ export function TESTING_ServerMessageAck_Create(): ServerMessageAck;
 export function TESTING_SignedPublicPreKey_CheckBridgesCorrectly(sourcePublicKey: Wrapper<PublicKey>, signedPreKey: SignedPublicPreKey): void;
 export function TESTING_TestingHandleType_getValue(handle: Wrapper<TestingHandleType>): number;
 export function TESTING_TokioAsyncFuture(asyncRuntime: Wrapper<TokioAsyncContext>, input: number): CancellablePromise<number>;
+export function TestingSemaphore_AddPermits(semaphore: Wrapper<TestingSemaphore>, permits: number): void;
+export function TestingSemaphore_New(initial: number): TestingSemaphore;
+export function TestingValueHolder_Get(holder: Wrapper<TestingValueHolder>): number;
+export function TestingValueHolder_New(value: number): TestingValueHolder;
 export function TokioAsyncContext_cancel(context: Wrapper<TokioAsyncContext>, rawCancellationId: bigint): void;
 export function TokioAsyncContext_new(): TokioAsyncContext;
-export function UnauthenticatedChatConnection_connect(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>): CancellablePromise<UnauthenticatedChatConnection>;
+export function UnauthenticatedChatConnection_connect(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>, languages: string[]): CancellablePromise<UnauthenticatedChatConnection>;
 export function UnauthenticatedChatConnection_disconnect(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<UnauthenticatedChatConnection>): CancellablePromise<void>;
 export function UnauthenticatedChatConnection_info(chat: Wrapper<UnauthenticatedChatConnection>): ChatConnectionInfo;
 export function UnauthenticatedChatConnection_init_listener(chat: Wrapper<UnauthenticatedChatConnection>, listener: ChatListener): void;
@@ -780,6 +782,8 @@ interface SignalMessage { readonly __type: unique symbol; }
 interface SignedPreKeyRecord { readonly __type: unique symbol; }
 interface TestingFutureCancellationCounter { readonly __type: unique symbol; }
 interface TestingHandleType { readonly __type: unique symbol; }
+interface TestingSemaphore { readonly __type: unique symbol; }
+interface TestingValueHolder { readonly __type: unique symbol; }
 interface TokioAsyncContext { readonly __type: unique symbol; }
 interface UnauthenticatedChatConnection { readonly __type: unique symbol; }
 interface UnidentifiedSenderMessageContent { readonly __type: unique symbol; }

package/dist/net/Chat.d.ts

@@ -84,6 +84,7 @@ export declare class UnauthenticatedChatConnection implements ChatConnection {
     private readonly chatListener;
     private readonly env?;
     static connect(asyncContext: TokioAsyncContext, connectionManager: ConnectionManager, listener: ConnectionEventsListener, env?: Environment, options?: {
+        languages?: string[];
         abortSignal?: AbortSignal;
     }): Promise<UnauthenticatedChatConnection>;
     /**
@@ -108,6 +109,7 @@ export declare class AuthenticatedChatConnection implements ChatConnection {
     private readonly chatService;
     private readonly chatListener;
     static connect(asyncContext: TokioAsyncContext, connectionManager: ConnectionManager, username: string, password: string, receiveStories: boolean, listener: ChatServiceListener, options?: {
+        languages?: string[];
         abortSignal?: AbortSignal;
     }): Promise<AuthenticatedChatConnection>;
     /**

package/dist/net/Chat.js

@@ -43,7 +43,7 @@ class ConnectionInfoImpl {
 class UnauthenticatedChatConnection {
     static async connect(asyncContext, connectionManager, listener, env, options) {
         const nativeChatListener = makeNativeChatListener(asyncContext, listener);
-        const connect = Native.UnauthenticatedChatConnection_connect(asyncContext, connectionManager);
+        const connect = Native.UnauthenticatedChatConnection_connect(asyncContext, connectionManager, options?.languages ?? []);
         const chat = await asyncContext.makeCancellable(options?.abortSignal, connect);
         const connection = (0, internal_1.newNativeHandle)(chat);
         Native.UnauthenticatedChatConnection_init_listener(connection, new WeakListenerWrapper(nativeChatListener));
@@ -95,7 +95,7 @@ exports.UnauthenticatedChatConnection = UnauthenticatedChatConnection;
 class AuthenticatedChatConnection {
     static async connect(asyncContext, connectionManager, username, password, receiveStories, listener, options) {
         const nativeChatListener = makeNativeChatListener(asyncContext, listener);
-        const connect = Native.AuthenticatedChatConnection_connect(asyncContext, connectionManager, username, password, receiveStories);
+        const connect = Native.AuthenticatedChatConnection_connect(asyncContext, connectionManager, username, password, receiveStories, options?.languages ?? []);
         const chat = await asyncContext.makeCancellable(options?.abortSignal, connect);
         const connection = (0, internal_1.newNativeHandle)(chat);
         Native.AuthenticatedChatConnection_init_listener(connection, new WeakListenerWrapper(nativeChatListener));

package/dist/net.d.ts

@@ -72,20 +72,24 @@ export declare class Net {
         abortSignal?: AbortSignal;
     }): Promise<void>;
     /**
-     *
      * Creates a new instance of {@link UnauthenticatedChatConnection}.
+     *
      * @param listener the listener for incoming events.
      * @param options additional options to pass through.
+     * @param options.languages If provided, a list of languages in Accept-Language syntax to apply
+     * to all requests made on this connection.
      * @param options.abortSignal an {@link AbortSignal} that will cancel the connection attempt.
      * @returns the connected listener, if the connection succeeds.
      */
     connectUnauthenticatedChat(listener: ConnectionEventsListener, options?: {
+        languages?: string[];
         abortSignal?: AbortSignal;
     }): Promise<UnauthenticatedChatConnection>;
     /**
      * Creates a new instance of {@link AuthenticatedChatConnection}.
      */
     connectAuthenticatedChat(username: string, password: string, receiveStories: boolean, listener: ChatServiceListener, options?: {
+        languages?: string[];
         abortSignal?: AbortSignal;
     }): Promise<AuthenticatedChatConnection>;
     resumeRegistrationSession({ sessionId, e164, }: {

package/dist/net.js

@@ -83,10 +83,12 @@ class Net {
         return this.asyncContext.makeCancellable(options?.abortSignal, Native.AuthenticatedChatConnection_preconnect(this.asyncContext, this._connectionManager));
     }
     /**
-     *
      * Creates a new instance of {@link UnauthenticatedChatConnection}.
+     *
      * @param listener the listener for incoming events.
      * @param options additional options to pass through.
+     * @param options.languages If provided, a list of languages in Accept-Language syntax to apply
+     * to all requests made on this connection.
      * @param options.abortSignal an {@link AbortSignal} that will cancel the connection attempt.
      * @returns the connected listener, if the connection succeeds.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalapp/libsignal-client",
-  "version": "0.76.0",
+  "version": "0.76.2",
   "license": "AGPL-3.0-only",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",