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

[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',
                        })
                    ),

it('should get the full list of tags', async () => {
            await vm.sendEvents([
                fileAdded(
                    createFile('test', {
                        abc: 'test',
                        def: 'other',
                    })
                ),
                fileAdded(
                    createFile('test2', {
                        '123': 456,
                        abc: 'haha',
                        ghi: 'final',
                    })
                ),
            ]);

            const tags = await subject.getTags();

            expect(tags).toEqual(['123', 'abc', 'def', 'ghi']);
        });
    });

it('should return an observable that only resolved when the given file changes', async () => {
            await tree.addFile(
                createFile('test', {
                    hello: true,
                })
            );

            await tree.addFile(
                createFile('test2', {
                    hello: false,
                })
            );

            let files: UpdatedFile[] = [];
            watcher
                .fileChanged(tree.value['test'])
                .subscribe(f => files.push(f));

            fileUpdated.next([{ file: tree.value['test2'], tags: [] }]);

it('should issue an authorization event if the user is not in the designers list in builder', async () => {
            config.config.isBuilder = true;
            await tree.addFile(
                createFile(GLOBALS_FILE_ID, {
                    'aux.designers': ['notusername'],
                })
            );

            let messages: AuthorizationMessage[] = [];
            channel.onConnectionStateChanged.subscribe(m => {
                if (m.type === 'authorization') {
                    messages.push(m);
                }
            });

            await channel.init();

            for (let i = 0; i < 100; i++) {
                await Promise.resolve();
            }

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'))),
            ]);
        });

constructor(helper: FileHelper) {
        this._helper = helper;
        this._onUpdated = new Subject();
        this.files = [createFile('empty')];
    }

beforeEach(async () => {
        tree = new AuxCausalTree(storedTree(site(1)));
        precalc = new PrecalculationManager(
            () => tree.value,
            () => createCalculationContext(values(tree.value), 'user')
        );

        await tree.root();
        await tree.addFile(createFile('user'));
    });

clear() {
        this.files = [createFile('empty')];
        this._onUpdated.next();
    }

);

            await tree.addFile(
                createFile('test2', {
                    formula2: '=getBots("formula3")',
                })
            );

            await tree.addFile(
                createFile('test3', {
                    formula3: '=getBots("name")',
                })
            );

            await tree.addFile(
                createFile('test4', {
                    name: 'file4',
                })
            );

            let updates = subject.addFile(tree.value['test']);

            updates = subject.addFile(tree.value['test2']);

            updates = subject.addFile(tree.value['test3']);

            await tree.updateFile(tree.value['test3'], {
                tags: {
                    name: 'newName',
                },
            });

type: 'device',
                    device: {
                        claims: {
                            [USERNAME_CLAIM]: 'username',
                            [DEVICE_ID_CLAIM]: 'deviceId',
                            [SESSION_ID_CLAIM]: 'sessionId',
                        },
                        roles: ['role'],
                    },
                    event: fileAdded(createFile('def')),
                },
                fileAdded(createFile('test')),
                {
                    type: 'device',
                    device: null,
                    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')),
                },