Q:

How to describe this object using an interface?

I have an object that looks like this:
var MyObject = {
    property1: {
        name: "name1",
        args: [1, 2, 3, 4],
    },

    property2: {
        name: "name2",
        args: [1, 1],
    },
    ...
}

MyObject contains many properties, each of them is an object that has a string and an array of numbers.
Is it possible to create an interface that describe the type of MyObject?

A:

If you want to define MyObject as an object that holds an arbitrary number of properties all of the same type then you can use the Dictionary array type definition (TypeScript documentation).
Here is a Typescript playground example of the dictionary interface:
/**
 * Define a dictionary interface.
 */
interface IMyObjectDictionary {
    [property: string]: IMyProperty;
}

interface IMyProperty {
    name: string;
    args: number[];
}

// Define `obj1` to be an `IMyObjectDictionary`.
// 
// All properties must be `IMyProperty` instances.
var obj1: IMyObjectDictionary = {
    property1: {name: '', args: []}

    // You define as many `IMyProperty` properties
    // as needed.

    // But all properties *must* match the `IMyProperty` interface.
    //,property2: number    // <-- This would give a compiler error because it's not an `IMyProperty`.
};

// Must access properties using array notation.
var b = obj1['property1'];

// TypeScript knows that `b` is an `IMyProperty`.
b.name; // Valid
b.args; // Valid

// b.temp;  // <-- Invalid - `temp` does not exist on `IMyProperty`.
// b = 1; // <-- This would give a compiler error. 'number' is not an `IMyProperty`.

If you need properties of mixed types then you will need to use a regular interface definition.
e.g. 
interface IMyObjectDictionary {
    property1: IMyProperty;
    property2: IMyProperty;
    // ...

    // Allows properties that aren't `IMyProperty`
    // but you have to define all properties.
    index: number;
}

