How to use the @casual-simulation/aux-common.fileAdded function in @casual-simulation/aux-common

claims: {
                    [USERNAME_CLAIM]: 'abc',
                    [DEVICE_ID_CLAIM]: 'deviceId',
                    [SESSION_ID_CLAIM]: 'sessionId',
                },
                roles: [ADMIN_ROLE],
            };
            const first = await manager.loadChannel(info);

            let events: DeviceEvent[] = [];
            first.channel.onDeviceEvents.subscribe(e => events.push(...e));

            await manager.sendEvents(first, [
                deviceEvent(
                    device,
                    fileAdded(
                        createFile('testId', {
                            abc: 'def',
                        })
                    )
                ),
            ]);

            // Should map events to DeviceEvent
            expect(events).toEqual([
                {
                    type: 'device',
                    device: device,
                    event: fileAdded(
                        createFile('testId', {
                            abc: 'def',
                        })

protected _updateFile(file: File, data: PartialFile): FileEvent {
        if (!this._fileAdded) {
            // Add the duplicated file.
            this._file = merge(this._file, data || {});
            this._file = createFile(undefined, this._file.tags);
            this._files = [this._file];
            this._fileAdded = true;

            return fileAdded(this._file);
        } else {
            return super._updateFile(this._file, data);
        }
    }

deviceEvent(
                    device,
                    fileAdded(
                        createFile('testId', {
                            abc: 'def',
                        })
                    )
                ),
            ]);

            // Should map events to DeviceEvent
            expect(events).toEqual([
                {
                    type: 'device',
                    device: device,
                    event: fileAdded(
                        createFile('testId', {
                            abc: 'def',
                        })
                    ),
                },
            ]);
        });
    });

it('should find references to tags that are accessed using hashtags', async () => {
            await vm.sendEvents([
                fileAdded(
                    createFile('test', {
                        abc: '=getTag(this, "#def")',
                    })
                ),
                fileAdded(
                    createFile('test2', {
                        fun: '=getTag(this, "#def")',
                    })
                ),
            ]);

            const references = await subject.getReferences('def');

            expect(references).toEqual({
                tag: 'def',
                references: {

it('should send remote events to _sendRemoteEvents()', async () => {
            await channel.initAndWait();

            await channel.sendEvents([
                {
                    type: 'remote',
                    event: fileAdded(createFile('def')),
                },
                fileAdded(createFile('test')),
                {
                    type: 'remote',
                    event: fileAdded(createFile('abc')),
                },
            ]);

            expect(channel.remoteEvents).toEqual([
                remote(fileAdded(createFile('def'))),
                remote(fileAdded(createFile('abc'))),
            ]);
        });

},
                id: 'id',
                treeName: 'treeName',
            };
            let testTree = new AuxCausalTree(storedTree(site(1)));
            await testTree.root();

            let testChannel = new NodeAuxChannel(
                testTree,
                testUser,
                testConfig
            );
            await testChannel.initAndWait();

            await channel.sendEvents([
                fileAdded(
                    createFile('channelFileId', {
                        'aux.channels': true,
                        'aux.channel': 'test',
                    })
                ),
            ]);

            let testDevice1: DeviceInfo = {
                claims: {
                    [USERNAME_CLAIM]: 'testUsername',
                    [DEVICE_ID_CLAIM]: 'deviceId',
                    [SESSION_ID_CLAIM]: 'sessionId',
                },
                roles: [],
            };
            const sub1 = await subject.deviceConnected(

await channel.sendEvents([
                {
                    type: 'remote',
                    event: fileAdded(createFile('def')),
                },
                fileAdded(createFile('test')),
                {
                    type: 'remote',
                    event: fileAdded(createFile('abc')),
                },
            ]);

            expect(channel.remoteEvents).toEqual([
                remote(fileAdded(createFile('def'))),
                remote(fileAdded(createFile('abc'))),
            ]);
        });

event: fileAdded(createFile('abc')),
                },
            ]);

            expect(deviceEvents).toEqual([
                {
                    type: 'device',
                    device: {
                        claims: {
                            [USERNAME_CLAIM]: 'username',
                            [DEVICE_ID_CLAIM]: 'deviceId',
                            [SESSION_ID_CLAIM]: 'sessionId',
                        },
                        roles: ['role'],
                    },
                    event: fileAdded(createFile('def')),
                },
                {
                    type: 'device',
                    device: null,
                    event: fileAdded(createFile('abc')),
                },
            ]);
        });
    });