Index signatures

It is possible to denote obj as any, but that defeats the whole purpose of using typescript. obj = {} implies obj is an Object. Marking it as any makes no sense. To accomplish the desired consistency an interface could be defined as follows, using an index signature

interface LooseObject {
    [key: string]: any
}

var obj: LooseObject = {};

OR to make it compact:

var obj: {[k: string]: any} = {};

LooseObject can accept fields with any string as key and any type as value.

obj.prop = "value";
obj.prop2 = 88;

The real elegance of this solution is that you can include typesafe fields in the interface.

interface MyType {
    typesafeProp1?: number,
    requiredProp1: string,
    [key: string]: any
}

var obj: MyType ;
obj = { requiredProp1: "foo"}; // valid
obj = {} // error. 'requiredProp1' is missing
obj.typesafeProp1 = "bar" // error. typesafeProp1 should be a number

obj.prop = "value";
obj.prop2 = 88;

Record<Keys,Type> utility type

Update (August 2020): @transang brought up the Record<Keys,Type> utility type in comments

Record<Keys,Type> is a Utility type in typescript. It is a much cleaner alternative for key-value pairs where property-names are not known. It's worth noting that Record<Keys,Type> is a named alias to {[k: Keys]: Type} where Keys and Type are generics. IMO, this makes it worth mentioning here

For comparison,

var obj: {[k: string]: any} = {};

becomes

var obj: Record<string,any> = {}

MyType can now be defined by extending Record type

interface MyType extends Record<string,any> {
    typesafeProp1?: number,
    requiredProp1: string,
}

While this answers the Original question, the answer here by @GreeneCreations might give another perspective on how to approach the problem.

Intersection Type

In typescript, If you want to add members, you can use an intersection type:

type DateWithNewMember = T & { newMember: boolean }

Where T is the type you want to add member to.

Then use like this:

dates: DateWithNewMember<Date>[];

Union Type

You could use Union type:

class newDateClass {
   readonly fullYearUTC: number;
}

Then use like this:

date: Date | newDateClass

What you are looking for is intersection type:

https://www.typescriptlang.org/docs/handbook/unions-and-intersections.html

Just declare your custom type like following:

interface DefaultSession {
  user?: {
    name?: string | null;
    email?: string | null;
    image?: string | null;
  };
  expires: ISODateString;
}

type CustomDefaultSession = DefaultSession & {
  user?: {
    role?: string | null;
  }
}

Then you can use it like it is or implement it for your class. Besides if you want the same name for your custom type then just refer library type using alias.

If you have a callback inside library you can override argument type like the following:

// Callback defined inside the library.
type LibraryCallback = (defaultSession: DefaultSession) => void;

// Function inside the library which accepts callback.
function libraryFunction(libraryCallback: LibraryCallback): void
{
    // Do stuff...
}

// Application code which calls library function and changes callback argument type.
libraryFunction((customDefaultSession: CustomDefaultSession) =>
{
    const role = customDefaultSession.user.role;
});

You're re-assigning this.containingJSON['OrderRequest'] in your code, instead of creating new properties. Based on how you want, following is the updated code

export class OrderRequest {
private containingJSON = {"OrderRequest": {}};;
    public rxOrderRequest(_request: any): OrderRequest {

                const tempObject1: object = Object.assign({}, JSON.parse(strInfo));

                const tempObject2: object = Object.assign({}, JSON.parse(strNonType),
                    JSON.parse(strType)
                );
                this.containingJSON['OrderRequest']['tempObject1'] = tempObject1;// assign tempObject1 to a new property "tempObject1"
                this.containingJSON['OrderRequest']['tempObject2'] = tempObject2;


                return this;
            }
}