Question: I want to create a function object, which also has some properties held on it. For example in JavaScript I would do:

```
var f = function() { }
f.someValue = 3;

```

Now in TypeScript I can describe the type of this as:

```
var f: { (): any; someValue: number; };

```

However I can't actually build it, without requiring a cast. Such as:

```
var f: { (): any; someValue: number; } =
    <{ (): any; someValue: number; }>(
        function() { }
    );
f.someValue = 3;

```

How would you build this without a cast?

Answer: 
Update: This answer was the best solution in earlier versions of TypeScript, but there are better options available in newer versions (see other answers).

The accepted answer works and might be required in some situations, but have the downside of providing no type safety for building up the object. This technique will at least throw a type error if you attempt to add an undefined property.

```
interface F { (): any; someValue: number; }

var f = <F>function () { }
f.someValue = 3

// type error
f.notDeclard = 3

```
As a shortcut, you can dynamically assign the object value using the ['property'] accessor:

```
var f = function() { }
f['someValue'] = 3;

```

This bypasses the type checking. However, it is pretty safe because you have to intentionally access the property the same way:

```
var val = f.someValue; // This won't work
var val = f['someValue']; // Yeah, I meant to do that

```

However, if you really want the type checking for the property value, this won't work.