"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "ts/textsecure.d.ts" between
Signal-Desktop-1.35.2.tar.gz and Signal-Desktop-1.36.1.tar.gz

About: Signal-Desktop is a cross-platform encrypted messaging service (also available for mobile devices).

textsecure.d.ts  (Signal-Desktop-1.35.2):textsecure.d.ts  (Signal-Desktop-1.36.1)
import { import {
KeyPairType, KeyPairType,
SessionRecordType, SessionRecordType,
SignedPreKeyType, SignedPreKeyType,
StorageType, StorageType,
} from './libsignal.d'; } from './libsignal.d';
import Crypto from './textsecure/Crypto'; import Crypto from './textsecure/Crypto';
import MessageReceiver from './textsecure/MessageReceiver'; import MessageReceiver from './textsecure/MessageReceiver';
import MessageSender from './textsecure/SendMessage';
import EventTarget from './textsecure/EventTarget'; import EventTarget from './textsecure/EventTarget';
import { ByteBufferClass } from './window.d'; import { ByteBufferClass } from './window.d';
import SendMessage, { SendOptionsType } from './textsecure/SendMessage'; import SendMessage, { SendOptionsType } from './textsecure/SendMessage';
import { WebAPIType } from './textsecure/WebAPI'; import { WebAPIType } from './textsecure/WebAPI';
import utils from './textsecure/Helpers'; import utils from './textsecure/Helpers';
type AttachmentType = any; type AttachmentType = any;
export type UnprocessedType = { export type UnprocessedType = {
attempts: number; attempts: number;
skipping to change at line 78 skipping to change at line 79
updateAttempts: (id: string, attempts: number) => Promise<void>; updateAttempts: (id: string, attempts: number) => Promise<void>;
addDecryptedDataToList: ( addDecryptedDataToList: (
array: Array<Partial<UnprocessedType>> array: Array<Partial<UnprocessedType>>
) => Promise<void>; ) => Promise<void>;
}; };
get: (key: string, defaultValue?: any) => any; get: (key: string, defaultValue?: any) => any;
put: (key: string, value: any) => Promise<void>; put: (key: string, value: any) => Promise<void>;
remove: (key: string | Array<string>) => Promise<void>; remove: (key: string | Array<string>) => Promise<void>;
protocol: StorageProtocolType; protocol: StorageProtocolType;
}; };
messageReceiver: { messageReceiver: MessageReceiver;
downloadAttachment: (
attachment: AttachmentPointerClass
) => Promise<DownloadAttachmentType>;
};
messaging?: SendMessage; messaging?: SendMessage;
protobuf: ProtobufCollectionType; protobuf: ProtobufCollectionType;
utils: typeof utils; utils: typeof utils;
EventTarget: typeof EventTarget; EventTarget: typeof EventTarget;
MessageReceiver: typeof MessageReceiver; MessageReceiver: typeof MessageReceiver;
}; };
type StoredSignedPreKeyType = SignedPreKeyType & { type StoredSignedPreKeyType = SignedPreKeyType & {
confirmed?: boolean; confirmed?: boolean;
skipping to change at line 148 skipping to change at line 145
encodedAddress: string, encodedAddress: string,
verifiedStatus: number, verifiedStatus: number,
publicKey?: ArrayBuffer publicKey?: ArrayBuffer
) => Promise<void>; ) => Promise<void>;
removeSignedPreKey: (keyId: number) => Promise<void>; removeSignedPreKey: (keyId: number) => Promise<void>;
removeAllData: () => Promise<void>; removeAllData: () => Promise<void>;
}; };
// Protobufs // Protobufs
type StorageServiceProtobufTypes = { type DeviceMessagesProtobufTypes = {
AccountRecord: typeof AccountRecordClass; ProvisioningUuid: typeof ProvisioningUuidClass;
ContactRecord: typeof ContactRecordClass; ProvisionEnvelope: typeof ProvisionEnvelopeClass;
GroupV1Record: typeof GroupV1RecordClass; ProvisionMessage: typeof ProvisionMessageClass;
GroupV2Record: typeof GroupV2RecordClass; };
ManifestRecord: typeof ManifestRecordClass;
ReadOperation: typeof ReadOperation; type DeviceNameProtobufTypes = {
StorageItem: typeof StorageItemClass; DeviceName: typeof DeviceNameClass;
StorageItems: typeof StorageItemsClass; };
StorageManifest: typeof StorageManifest;
StorageRecord: typeof StorageRecordClass; type GroupsProtobufTypes = {
AvatarUploadAttributes: typeof AvatarUploadAttributesClass;
Member: typeof MemberClass;
PendingMember: typeof PendingMemberClass;
AccessControl: typeof AccessControlClass;
Group: typeof GroupClass;
GroupChange: typeof GroupChangeClass;
GroupChanges: typeof GroupChangesClass;
GroupAttributeBlob: typeof GroupAttributeBlobClass;
}; };
type ProtobufCollectionType = StorageServiceProtobufTypes & { type SignalServiceProtobufTypes = {
AttachmentPointer: typeof AttachmentPointerClass; AttachmentPointer: typeof AttachmentPointerClass;
ContactDetails: typeof ContactDetailsClass; ContactDetails: typeof ContactDetailsClass;
Content: typeof ContentClass; Content: typeof ContentClass;
DataMessage: typeof DataMessageClass; DataMessage: typeof DataMessageClass;
DeviceName: typeof DeviceNameClass;
Envelope: typeof EnvelopeClass; Envelope: typeof EnvelopeClass;
GroupContext: typeof GroupContextClass; GroupContext: typeof GroupContextClass;
GroupContextV2: typeof GroupContextV2Class; GroupContextV2: typeof GroupContextV2Class;
GroupDetails: typeof GroupDetailsClass; GroupDetails: typeof GroupDetailsClass;
NullMessage: typeof NullMessageClass; NullMessage: typeof NullMessageClass;
ProvisioningUuid: typeof ProvisioningUuidClass;
ProvisionEnvelope: typeof ProvisionEnvelopeClass;
ProvisionMessage: typeof ProvisionMessageClass;
ReceiptMessage: typeof ReceiptMessageClass; ReceiptMessage: typeof ReceiptMessageClass;
SyncMessage: typeof SyncMessageClass; SyncMessage: typeof SyncMessageClass;
TypingMessage: typeof TypingMessageClass; TypingMessage: typeof TypingMessageClass;
Verified: typeof VerifiedClass; Verified: typeof VerifiedClass;
};
type SignalStorageProtobufTypes = {
AccountRecord: typeof AccountRecordClass;
ContactRecord: typeof ContactRecordClass;
GroupV1Record: typeof GroupV1RecordClass;
GroupV2Record: typeof GroupV2RecordClass;
ManifestRecord: typeof ManifestRecordClass;
ReadOperation: typeof ReadOperationClass;
StorageItem: typeof StorageItemClass;
StorageItems: typeof StorageItemsClass;
StorageManifest: typeof StorageManifestClass;
StorageRecord: typeof StorageRecordClass;
WriteOperation: typeof WriteOperationClass;
};
type SubProtocolProtobufTypes = {
WebSocketMessage: typeof WebSocketMessageClass; WebSocketMessage: typeof WebSocketMessageClass;
WebSocketRequestMessage: typeof WebSocketRequestMessageClass; WebSocketRequestMessage: typeof WebSocketRequestMessageClass;
WebSocketResponseMessage: typeof WebSocketResponseMessageClass; WebSocketResponseMessage: typeof WebSocketResponseMessageClass;
}; };
type ProtobufCollectionType = DeviceMessagesProtobufTypes &
DeviceNameProtobufTypes &
GroupsProtobufTypes &
SignalServiceProtobufTypes &
SignalStorageProtobufTypes &
SubProtocolProtobufTypes;
// Note: there are a lot of places in the code that overwrite a field like this // Note: there are a lot of places in the code that overwrite a field like this
// with a type that the app can use. Being more rigorous with these // with a type that the app can use. Being more rigorous with these
// types would require code changes, out of scope for now. // types would require code changes, out of scope for now.
type ProtoBinaryType = any; type ProtoBinaryType = any;
type ProtoBigNumberType = any; type ProtoBigNumberType = any;
// Groups.proto
export declare class AvatarUploadAttributesClass {
static decode: (
data: ArrayBuffer | ByteBufferClass,
encoding?: string
) => AvatarUploadAttributesClass;
key?: string;
credential?: string;
acl?: string;
algorithm?: string;
date?: string;
policy?: string;
signature?: string;
}
export declare class MemberClass {
static decode: (
data: ArrayBuffer | ByteBufferClass,
encoding?: string
) => MemberClass;
userId?: ProtoBinaryType;
role?: MemberRoleEnum;
profileKey?: ProtoBinaryType;
presentation?: ProtoBinaryType;
joinedAtVersion?: number;
}
type MemberRoleEnum = number;
// Note: we need to use namespaces to express nested classes in Typescript
export declare namespace MemberClass {
class Role {
static UNKNOWN: number;
static DEFAULT: number;
static ADMINISTRATOR: number;
}
}
export declare class PendingMemberClass {
static decode: (
data: ArrayBuffer | ByteBufferClass,
encoding?: string
) => PendingMemberClass;
member?: MemberClass;
addedByUserId?: ProtoBinaryType;
timestamp?: ProtoBigNumberType;
}
type AccessRequiredEnum = number;
export declare class AccessControlClass {
static decode: (
data: ArrayBuffer | ByteBufferClass,
encoding?: string
) => AccessControlClass;
attributes?: AccessRequiredEnum;
members?: AccessRequiredEnum;
}
// Note: we need to use namespaces to express nested classes in Typescript
export declare namespace AccessControlClass {
class AccessRequired {
static UNKNOWN: number;
static MEMBER: number;
static ADMINISTRATOR: number;
}
}
export declare class GroupClass {
static decode: (
data: ArrayBuffer | ByteBufferClass,
encoding?: string
) => GroupClass;
toArrayBuffer: () => ArrayBuffer;
publicKey?: ProtoBinaryType;
title?: ProtoBinaryType;
avatar?: string;
disappearingMessagesTimer?: ProtoBinaryType;
accessControl?: AccessControlClass;
version?: number;
members?: Array<MemberClass>;
pendingMembers?: Array<PendingMemberClass>;
}
export declare class GroupChangeClass {
static decode: (
data: ArrayBuffer | ByteBufferClass,
encoding?: string
) => GroupChangeClass;
actions?: ProtoBinaryType;
serverSignature?: ProtoBinaryType;
}
// Note: we need to use namespaces to express nested classes in Typescript
export declare namespace GroupChangeClass {
class Actions {
static decode: (
data: ArrayBuffer | ByteBufferClass,
encoding?: string
) => Actions;
toArrayBuffer: () => ArrayBuffer;
sourceUuid?: ProtoBinaryType;
version?: number;
addMembers?: Array<GroupChangeClass.Actions.AddMemberAction>;
deleteMembers?: Array<GroupChangeClass.Actions.DeleteMemberAction>;
modifyMemberRoles?: Array<GroupChangeClass.Actions.ModifyMemberRoleAction>;
modifyMemberProfileKeys?: Array<
GroupChangeClass.Actions.ModifyMemberProfileKeyAction
>;
addPendingMembers?: Array<GroupChangeClass.Actions.AddPendingMemberAction>;
deletePendingMembers?: Array<
GroupChangeClass.Actions.DeletePendingMemberAction
>;
promotePendingMembers?: Array<
GroupChangeClass.Actions.PromotePendingMemberAction
>;
modifyTitle?: GroupChangeClass.Actions.ModifyTitleAction;
modifyAvatar?: GroupChangeClass.Actions.ModifyAvatarAction;
modifyDisappearingMessagesTimer?: GroupChangeClass.Actions.ModifyDisappearin
gMessagesTimerAction;
modifyAttributesAccess?: GroupChangeClass.Actions.ModifyAttributesAccessCont
rolAction;
modifyMemberAccess?: GroupChangeClass.Actions.ModifyMembersAccessControlActi
on;
}
}
// Note: we need to use namespaces to express nested classes in Typescript
export declare namespace GroupChangeClass.Actions {
class AddMemberAction {
added?: MemberClass;
}
class DeleteMemberAction {
deletedUserId?: ProtoBinaryType;
}
class ModifyMemberRoleAction {
userId?: ProtoBinaryType;
role?: MemberRoleEnum;
}
class ModifyMemberProfileKeyAction {
presentation?: ProtoBinaryType;
// The result of decryption
profileKey: ArrayBuffer;
uuid: string;
}
class AddPendingMemberAction {
added?: PendingMemberClass;
}
class DeletePendingMemberAction {
deletedUserId?: ProtoBinaryType;
}
class PromotePendingMemberAction {
presentation?: ProtoBinaryType;
// The result of decryption
profileKey: ArrayBuffer;
uuid: string;
}
class ModifyTitleAction {
title?: ProtoBinaryType;
}
class ModifyAvatarAction {
avatar?: string;
}
class ModifyDisappearingMessagesTimerAction {
timer?: ProtoBinaryType;
}
class ModifyAttributesAccessControlAction {
attributesAccess?: AccessRequiredEnum;
}
class ModifyMembersAccessControlAction {
membersAccess?: AccessRequiredEnum;
}
}
export declare class GroupChangesClass {
static decode: (
data: ArrayBuffer | ByteBufferClass,
encoding?: string
) => GroupChangesClass;
groupChanges?: Array<GroupChangesClass.GroupChangeState>;
}
// Note: we need to use namespaces to express nested classes in Typescript
export declare namespace GroupChangesClass {
class GroupChangeState {
groupChange?: GroupChangeClass;
groupState?: GroupClass;
}
}
export declare class GroupAttributeBlobClass {
static decode: (
data: ArrayBuffer | ByteBufferClass,
encoding?: string
) => GroupAttributeBlobClass;
toArrayBuffer(): ArrayBuffer;
title?: string;
avatar?: ProtoBinaryType;
disappearingMessagesDuration?: number;
// Note: this isn't part of the proto, but our protobuf library tells us which
// field has been set with this prop.
content: 'title' | 'avatar' | 'disappearingMessagesDuration';
}
// Previous protos
export declare class AttachmentPointerClass { export declare class AttachmentPointerClass {
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => AttachmentPointerClass; ) => AttachmentPointerClass;
cdnId?: ProtoBigNumberType; cdnId?: ProtoBigNumberType;
cdnKey?: string; cdnKey?: string;
contentType?: string; contentType?: string;
key?: ProtoBinaryType; key?: ProtoBinaryType;
skipping to change at line 437 skipping to change at line 689
export declare class GroupContextV2Class { export declare class GroupContextV2Class {
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => GroupContextV2Class; ) => GroupContextV2Class;
masterKey?: ProtoBinaryType; masterKey?: ProtoBinaryType;
revision?: number; revision?: number;
groupChange?: ProtoBinaryType; groupChange?: ProtoBinaryType;
// Note: these additional properties are added in the course of processing
id?: string;
secretParams?: string;
publicParams?: string;
} }
// Note: we need to use namespaces to express nested classes in Typescript // Note: we need to use namespaces to express nested classes in Typescript
export declare namespace GroupContextClass { export declare namespace GroupContextClass {
class Member { class Member {
uuid?: string; uuid?: string;
e164?: string; e164?: string;
} }
class Type { class Type {
static UNKNOWN: number; static UNKNOWN: number;
skipping to change at line 493 skipping to change at line 750
} }
declare enum ManifestType { declare enum ManifestType {
UNKNOWN, UNKNOWN,
CONTACT, CONTACT,
GROUPV1, GROUPV1,
GROUPV2, GROUPV2,
ACCOUNT, ACCOUNT,
} }
type ManifestRecordIdentifier = { export declare class ManifestRecordIdentifierClass {
static Type: typeof ManifestType;
raw: ProtoBinaryType; raw: ProtoBinaryType;
type: ManifestType; type: ManifestType;
}; toArrayBuffer: () => ArrayBuffer;
}
export declare class ManifestRecordClass { export declare class ManifestRecordClass {
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => ManifestRecordClass; ) => ManifestRecordClass;
toArrayBuffer: () => ArrayBuffer;
static Identifier: { static Identifier: typeof ManifestRecordIdentifierClass;
Type: typeof ManifestType;
};
version: ProtoBigNumberType; version: ProtoBigNumberType;
keys: ManifestRecordIdentifier[]; keys: ManifestRecordIdentifierClass[];
} }
export declare class NullMessageClass { export declare class NullMessageClass {
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => NullMessageClass; ) => NullMessageClass;
padding?: ProtoBinaryType; padding?: ProtoBinaryType;
} }
skipping to change at line 582 skipping to change at line 839
// Note: we need to use namespaces to express nested classes in Typescript // Note: we need to use namespaces to express nested classes in Typescript
export declare namespace ReceiptMessageClass { export declare namespace ReceiptMessageClass {
class Type { class Type {
static DELIVERY: number; static DELIVERY: number;
static READ: number; static READ: number;
} }
} }
// Storage Service related types // Storage Service related types
declare class StorageManifest { export declare class StorageManifestClass {
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => StorageManifest; ) => StorageManifestClass;
version?: ProtoBigNumberType | null; version?: ProtoBigNumberType | null;
value?: ByteBufferClass | null; value?: ProtoBinaryType;
} }
export declare class StorageRecordClass { export declare class StorageRecordClass {
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => StorageRecordClass; ) => StorageRecordClass;
toArrayBuffer: () => ArrayBuffer;
contact?: ContactRecordClass | null; contact?: ContactRecordClass | null;
groupV1?: GroupV1RecordClass | null; groupV1?: GroupV1RecordClass | null;
groupV2?: GroupV2RecordClass | null; groupV2?: GroupV2RecordClass | null;
account?: AccountRecordClass | null; account?: AccountRecordClass | null;
} }
export declare class StorageItemClass { export declare class StorageItemClass {
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => StorageItemClass; ) => StorageItemClass;
key?: ByteBufferClass | null; key?: ProtoBinaryType;
value?: ByteBufferClass | null; value?: ProtoBinaryType;
} }
export declare class StorageItemsClass { export declare class StorageItemsClass {
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => StorageItemsClass; ) => StorageItemsClass;
items?: StorageItemClass[] | null; items?: StorageItemClass[] | null;
} }
skipping to change at line 636 skipping to change at line 894
UNVERIFIED = 2, UNVERIFIED = 2,
} }
export declare class ContactRecordClass { export declare class ContactRecordClass {
static IdentityState: typeof ContactRecordIdentityState; static IdentityState: typeof ContactRecordIdentityState;
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => ContactRecordClass; ) => ContactRecordClass;
toArrayBuffer: () => ArrayBuffer;
serviceUuid?: string | null; serviceUuid?: string | null;
serviceE164?: string | null; serviceE164?: string | null;
profileKey?: ByteBufferClass | null; profileKey?: ProtoBinaryType;
identityKey?: ByteBufferClass | null; identityKey?: ProtoBinaryType;
identityState?: ContactRecordIdentityState | null; identityState?: ContactRecordIdentityState | null;
givenName?: string | null; givenName?: string | null;
familyName?: string | null; familyName?: string | null;
username?: string | null; username?: string | null;
blocked?: boolean | null; blocked?: boolean | null;
whitelisted?: boolean | null; whitelisted?: boolean | null;
archived?: boolean | null; archived?: boolean | null;
__unknownFields?: ArrayBuffer;
} }
export declare class GroupV1RecordClass { export declare class GroupV1RecordClass {
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => GroupV1RecordClass; ) => GroupV1RecordClass;
toArrayBuffer: () => ArrayBuffer;
id?: ByteBufferClass | null; id?: ProtoBinaryType;
blocked?: boolean | null; blocked?: boolean | null;
whitelisted?: boolean | null; whitelisted?: boolean | null;
archived?: boolean | null; archived?: boolean | null;
__unknownFields?: ArrayBuffer;
} }
export declare class GroupV2RecordClass { export declare class GroupV2RecordClass {
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => GroupV2RecordClass; ) => GroupV2RecordClass;
toArrayBuffer: () => ArrayBuffer;
masterKey?: ByteBufferClass | null; masterKey?: ProtoBinaryType | null;
blocked?: boolean | null; blocked?: boolean | null;
whitelisted?: boolean | null; whitelisted?: boolean | null;
archived?: boolean | null; archived?: boolean | null;
__unknownFields?: ArrayBuffer;
} }
export declare class AccountRecordClass { export declare class AccountRecordClass {
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => AccountRecordClass; ) => AccountRecordClass;
toArrayBuffer: () => ArrayBuffer;
profileKey?: ByteBufferClass | null; profileKey?: ProtoBinaryType;
givenName?: string | null; givenName?: string | null;
familyName?: string | null; familyName?: string | null;
avatarUrl?: string | null; avatarUrl?: string | null;
noteToSelfArchived?: boolean | null; noteToSelfArchived?: boolean | null;
readReceipts?: boolean | null; readReceipts?: boolean | null;
sealedSenderIndicators?: boolean | null; sealedSenderIndicators?: boolean | null;
typingIndicators?: boolean | null; typingIndicators?: boolean | null;
linkPreviews?: boolean | null; linkPreviews?: boolean | null;
__unknownFields?: ArrayBuffer;
} }
declare class ReadOperation { declare class ReadOperationClass {
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => ReadOperation; ) => ReadOperationClass;
readKey: ArrayBuffer[] | ByteBufferClass[]; readKey: ArrayBuffer[] | ByteBufferClass[];
toArrayBuffer: () => ArrayBuffer; toArrayBuffer: () => ArrayBuffer;
} }
declare class WriteOperationClass {
static decode: (
data: ArrayBuffer | ByteBufferClass,
encoding?: string
) => WriteOperationClass;
toArrayBuffer: () => ArrayBuffer;
manifest: StorageManifestClass;
insertItem: StorageItemClass[];
deleteKey: ArrayBuffer[] | ByteBufferClass[];
clearAll: boolean;
}
export declare class SyncMessageClass { export declare class SyncMessageClass {
static decode: ( static decode: (
data: ArrayBuffer | ByteBufferClass, data: ArrayBuffer | ByteBufferClass,
encoding?: string encoding?: string
) => SyncMessageClass; ) => SyncMessageClass;
sent?: SyncMessageClass.Sent; sent?: SyncMessageClass.Sent;
contacts?: SyncMessageClass.Contacts; contacts?: SyncMessageClass.Contacts;
groups?: SyncMessageClass.Groups; groups?: SyncMessageClass.Groups;
request?: SyncMessageClass.Request; request?: SyncMessageClass.Request;
skipping to change at line 730 skipping to change at line 1013
keys?: SyncMessageClass.Keys; keys?: SyncMessageClass.Keys;
} }
// Note: we need to use namespaces to express nested classes in Typescript // Note: we need to use namespaces to express nested classes in Typescript
export declare namespace SyncMessageClass { export declare namespace SyncMessageClass {
class Configuration { class Configuration {
readReceipts?: boolean; readReceipts?: boolean;
unidentifiedDeliveryIndicators?: boolean; unidentifiedDeliveryIndicators?: boolean;
typingIndicators?: boolean; typingIndicators?: boolean;
linkPreviews?: boolean; linkPreviews?: boolean;
provisioningVersion?: number;
} }
class Contacts { class Contacts {
blob?: AttachmentPointerClass; blob?: AttachmentPointerClass;
complete?: boolean; complete?: boolean;
} }
class Groups { class Groups {
blob?: AttachmentPointerClass; blob?: AttachmentPointerClass;
} }
class Blocked { class Blocked {
numbers?: Array<string>; numbers?: Array<string>;
skipping to change at line 773 skipping to change at line 1057
packId?: ProtoBinaryType; packId?: ProtoBinaryType;
packKey?: ProtoBinaryType; packKey?: ProtoBinaryType;
type?: number; type?: number;
} }
class ViewOnceOpen { class ViewOnceOpen {
sender?: string; sender?: string;
senderUuid?: string; senderUuid?: string;
timestamp?: ProtoBinaryType; timestamp?: ProtoBinaryType;
} }
class FetchLatest { class FetchLatest {
static Type: {
UNKNOWN: number;
LOCAL_PROFILE: number;
STORAGE_MANIFEST: number;
};
type?: number; type?: number;
} }
class Keys { class Keys {
storageService?: ByteBufferClass; storageService?: ByteBufferClass;
} }
class MessageRequestResponse { class MessageRequestResponse {
threadE164?: string; threadE164?: string;
threadUuid?: string; threadUuid?: string;
groupId?: ProtoBinaryType; groupId?: ProtoBinaryType;
 End of changes. 36 change blocks. 
40 lines changed or deleted 332 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)