diff --git a/src/main/ts/declare.ts b/src/main/ts/declare.ts
--- a/src/main/ts/declare.ts
+++ b/src/main/ts/declare.ts
@@ -1,10 +1,11 @@
 import declare = require("dojo/_base/declare");
 import { each } from "@implab/core-amd/safe";
 import { Constructor } from "@implab/core-amd/interfaces";
+import dojo = require("dojo/_base/kernel");
 
 // declare const declare: any;
 
-type DeclareConstructor<T> = declare.DeclareConstructor<T>;
+type DeclareConstructor<T> = dojo._base.DeclareConstructor<T>;
 
 export interface AbstractConstructor<T = {}> {
     prototype: T;
diff --git a/src/typings/dijit/_AttachMixin.d.ts b/src/typings/dijit/_AttachMixin.d.ts
--- a/src/typings/dijit/_AttachMixin.d.ts
+++ b/src/typings/dijit/_AttachMixin.d.ts
@@ -1,6 +1,7 @@
 import { Handle } from "dojo/interfaces";
 import _WidgetBase = require("./_WidgetBase");
 import declare = require("dojo/_base/declare");
+import dojo = require("dojo/_base/html");
 
 declare module "./_WidgetBase" {
     interface _WidgetBase {
@@ -81,7 +82,7 @@ interface _AttachMixin {
     destroyRendering(preserveDom?: boolean): void;
 }
 
-interface _AttachMixinConstructor extends declare.DeclareConstructor<_AttachMixin> { }
+interface _AttachMixinConstructor extends dojo._base.DeclareConstructor<_AttachMixin> { }
 
 declare const _AttachMixin: _AttachMixinConstructor;
 export = _AttachMixin;
diff --git a/src/typings/dojo/_base/declare.d.ts b/src/typings/dojo/_base/declare.d.ts
--- a/src/typings/dojo/_base/declare.d.ts
+++ b/src/typings/dojo/_base/declare.d.ts
@@ -1,138 +1,142 @@
+import dojo = require("./kernel");
+
 declare module "./kernel" {
     interface Dojo {
-        declare: declare.Declare;
+        declare: dojo._base.Declare;
         safeMixin: typeof declare.safeMixin;
     }
-}
-
-declare namespace declare {
-    interface DeclareCreatedObject {
-        declaredClass: string;
-
-        /**
-         * Calls a super method.
-         *
-         * This method is used inside method of classes produced with
-         * declare() to call a super method (next in the chain). It is
-         * used for manually controlled chaining. Consider using the regular
-         * chaining, because it is faster. Use "this.inherited()" only in
-         * complex cases.
-         *
-         * This method cannot me called from automatically chained
-         * constructors including the case of a special (legacy)
-         * constructor chaining. It cannot be called from chained methods.
-         *
-         * If "this.inherited()" cannot find the next-in-chain method, it
-         * does nothing and returns "undefined". The last method in chain
-         * can be a default method implemented in Object, which will be
-         * called last.
-         *
-         * If "name" is specified, it is assumed that the method that
-         * received "args" is the parent method for this call. It is looked
-         * up in the chain list and if it is found the next-in-chain method
-         * is called. If it is not found, the first-in-chain method is
-         * called.
-         *
-         * If "name" is not specified, it will be derived from the calling
-         * method (using a methoid property "nom").
-         */
-        inherited<U>(args: IArguments, newArgs?: any[]): U;
-        inherited(args: IArguments, newArgs?: true): Function | void;
-        inherited<U>(name: string, args: IArguments, newArgs?: any[]): U;
-        inherited(name: string, args: IArguments, newArgs?: true): Function | void;
-
-        /**
-         * Returns a super method.
-         *
-         * This method is a convenience method for "this.inherited()".
-         * It uses the same algorithm but instead of executing a super
-         * method, it returns it, or "undefined" if not found.
-         */
-        getInherited(args: IArguments): Function | void;
-        getInherited(name: string, args: IArguments): Function | void;
-
-        /**
-         * Checks the inheritance chain to see if it is inherited from this class.
-         *
-         * This method is used with instances of classes produced with
-         * declare() to determine of they support a certain interface or
-         * not. It models "instanceof" operator.
-         */
-        isInstanceOf(cls: any): boolean;
-    }
 
-    interface DeclareConstructor<T> {
-        new(...args: any[]): T & DeclareCreatedObject;
-        prototype: T;
+    namespace _base {
+        interface DeclareCreatedObject {
+            declaredClass: string;
+
+            /**
+             * Calls a super method.
+             *
+             * This method is used inside method of classes produced with
+             * declare() to call a super method (next in the chain). It is
+             * used for manually controlled chaining. Consider using the regular
+             * chaining, because it is faster. Use "this.inherited()" only in
+             * complex cases.
+             *
+             * This method cannot me called from automatically chained
+             * constructors including the case of a special (legacy)
+             * constructor chaining. It cannot be called from chained methods.
+             *
+             * If "this.inherited()" cannot find the next-in-chain method, it
+             * does nothing and returns "undefined". The last method in chain
+             * can be a default method implemented in Object, which will be
+             * called last.
+             *
+             * If "name" is specified, it is assumed that the method that
+             * received "args" is the parent method for this call. It is looked
+             * up in the chain list and if it is found the next-in-chain method
+             * is called. If it is not found, the first-in-chain method is
+             * called.
+             *
+             * If "name" is not specified, it will be derived from the calling
+             * method (using a methoid property "nom").
+             */
+            inherited<U>(args: IArguments, newArgs?: any[]): U;
+            inherited(args: IArguments, newArgs?: true): Function | void;
+            inherited<U>(name: string, args: IArguments, newArgs?: any[]): U;
+            inherited(name: string, args: IArguments, newArgs?: true): Function | void;
+
+            /**
+             * Returns a super method.
+             *
+             * This method is a convenience method for "this.inherited()".
+             * It uses the same algorithm but instead of executing a super
+             * method, it returns it, or "undefined" if not found.
+             */
+            getInherited(args: IArguments): Function | void;
+            getInherited(name: string, args: IArguments): Function | void;
+
+            /**
+             * Checks the inheritance chain to see if it is inherited from this class.
+             *
+             * This method is used with instances of classes produced with
+             * declare() to determine of they support a certain interface or
+             * not. It models "instanceof" operator.
+             */
+            isInstanceOf(cls: any): boolean;
+        }
+
+        interface DeclareConstructor<T> {
+            new(...args: any[]): T & DeclareCreatedObject;
+            prototype: T;
 
-        /**
-         * Adds all properties and methods of source to constructor's
-         * prototype, making them available to all instances created with
-         * constructor. This method is specific to constructors created with
-         * declare().
-         *
-         * Adds source properties to the constructor's prototype. It can
-         * override existing properties.
-         *
-         * This method is similar to dojo.extend function, but it is specific
-         * to constructors produced by declare(). It is implemented
-         * using dojo.safeMixin, and it skips a constructor property,
-         * and properly decorates copied functions.
-         */
-        extend<U>(source: U): DeclareConstructor<T & U>;
+            /**
+             * Adds all properties and methods of source to constructor's
+             * prototype, making them available to all instances created with
+             * constructor. This method is specific to constructors created with
+             * declare().
+             *
+             * Adds source properties to the constructor's prototype. It can
+             * override existing properties.
+             *
+             * This method is similar to dojo.extend function, but it is specific
+             * to constructors produced by declare(). It is implemented
+             * using dojo.safeMixin, and it skips a constructor property,
+             * and properly decorates copied functions.
+             */
+            extend<U>(source: U): DeclareConstructor<T & U>;
 
-        /**
-         * Create a subclass of the declared class from a list of base classes.
-         *
-         * Create a constructor using a compact notation for inheritance and
-         * prototype extension.
-         *
-         * Mixin ancestors provide a type of multiple inheritance.
-         * Prototypes of mixin ancestors are copied to the new class:
-         * changes to mixin prototypes will not affect classes to which
-         * they have been mixed in.
-         */
-        createSubclass<U, V, X>(mixins: [DeclareConstructor<U>, DeclareConstructor<V>], props: X): DeclareConstructor<T & U & V & X>;
-        createSubclass<U, V>(mixins: [DeclareConstructor<U>], props: V): DeclareConstructor<T & U & V>;
-        createSubclass<U, V>(mixins: DeclareConstructor<U>, props: V): DeclareConstructor<T & U & V>;
-        createSubclass<U>(mixins: [DeclareConstructor<U>]): DeclareConstructor<T & U>;
-        createSubclass<U>(mixins: DeclareConstructor<U>): DeclareConstructor<T & U>;
-        createSubclass<U>(mixins: any, props: U): DeclareConstructor<T & U>;
+            /**
+             * Create a subclass of the declared class from a list of base classes.
+             *
+             * Create a constructor using a compact notation for inheritance and
+             * prototype extension.
+             *
+             * Mixin ancestors provide a type of multiple inheritance.
+             * Prototypes of mixin ancestors are copied to the new class:
+             * changes to mixin prototypes will not affect classes to which
+             * they have been mixed in.
+             */
+            createSubclass<U, V, X>(mixins: [DeclareConstructor<U>, DeclareConstructor<V>], props: X): DeclareConstructor<T & U & V & X>;
+            createSubclass<U, V>(mixins: [DeclareConstructor<U>], props: V): DeclareConstructor<T & U & V>;
+            createSubclass<U, V>(mixins: DeclareConstructor<U>, props: V): DeclareConstructor<T & U & V>;
+            createSubclass<U>(mixins: [DeclareConstructor<U>]): DeclareConstructor<T & U>;
+            createSubclass<U>(mixins: DeclareConstructor<U>): DeclareConstructor<T & U>;
+            createSubclass<U>(mixins: any, props: U): DeclareConstructor<T & U>;
+        }
+
+        interface Declare {
+            <A, B, C, D>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>]): DeclareConstructor<A & B & C & D>;
+            <A, B, C>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>]): DeclareConstructor<A & B & C>;
+            <A, B>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>]): DeclareConstructor<A & B>;
+            <A>(superClass: DeclareConstructor<A> | [DeclareConstructor<A>]): DeclareConstructor<A>;
+
+            <A, B, C, D, E>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>], props: E): DeclareConstructor<A & B & C & D & E>;
+            <A, B, C, D>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>], props: D): DeclareConstructor<A & B & C & D>;
+            <A, B, C>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>], props: C): DeclareConstructor<A & B & C>;
+            <A, B>(superClass: DeclareConstructor<A> | [DeclareConstructor<A>], props: B): DeclareConstructor<A & B>;
+
+            <A, B, C, D>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>]): DeclareConstructor<A & B & C & D>;
+            <A, B, C>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>]): DeclareConstructor<A & B & C>;
+            <A, B>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>]): DeclareConstructor<A & B>;
+            <A>(className: string, superClass: DeclareConstructor<A> | [DeclareConstructor<A>]): DeclareConstructor<A>;
+
+            <A, B, C, D, E>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>], props: E): DeclareConstructor<A & B & C & D & E>;
+            <A, B, C, D>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>], props: D): DeclareConstructor<A & B & C & D>;
+            <A, B, C>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>], props: C): DeclareConstructor<A & B & C>;
+            <A, B>(className: string, superClass: DeclareConstructor<A> | [DeclareConstructor<A>], props: B): DeclareConstructor<A & B>;
+
+            <A>(className: string, superClass: any, props: A): DeclareConstructor<A>;
+            (className: string, superClass: any): DeclareConstructor<any>;
+            <A>(superClass: any, props: A): DeclareConstructor<A>;
+            (superClass: any): DeclareConstructor<any>;
+
+            /**
+             * Mix in properties skipping a constructor and decorating functions
+             * like it is done by declare().
+             */
+            safeMixin<A, B>(target: A, source: B): A & B;
+        }
     }
 
-    interface Declare {
-        <A, B, C, D>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>]): DeclareConstructor<A & B & C & D>;
-        <A, B, C>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>]): DeclareConstructor<A & B & C>;
-        <A, B>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>]): DeclareConstructor<A & B>;
-        <A>(superClass: DeclareConstructor<A> | [DeclareConstructor<A>]): DeclareConstructor<A>;
-
-        <A, B, C, D, E>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>], props: E): DeclareConstructor<A & B & C & D & E>;
-        <A, B, C, D>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>], props: D): DeclareConstructor<A & B & C & D>;
-        <A, B, C>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>], props: C): DeclareConstructor<A & B & C>;
-        <A, B>(superClass: DeclareConstructor<A> | [DeclareConstructor<A>], props: B): DeclareConstructor<A & B>;
-
-        <A, B, C, D>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>]): DeclareConstructor<A & B & C & D>;
-        <A, B, C>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>]): DeclareConstructor<A & B & C>;
-        <A, B>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>]): DeclareConstructor<A & B>;
-        <A>(className: string, superClass: DeclareConstructor<A> | [DeclareConstructor<A>]): DeclareConstructor<A>;
-
-        <A, B, C, D, E>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>], props: E): DeclareConstructor<A & B & C & D & E>;
-        <A, B, C, D>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>], props: D): DeclareConstructor<A & B & C & D>;
-        <A, B, C>(className: string, superClass: [DeclareConstructor<A>, DeclareConstructor<B>], props: C): DeclareConstructor<A & B & C>;
-        <A, B>(className: string, superClass: DeclareConstructor<A> | [DeclareConstructor<A>], props: B): DeclareConstructor<A & B>;
-
-        <A>(className: string, superClass: any, props: A): DeclareConstructor<A>;
-        (className: string, superClass: any): DeclareConstructor<any>;
-        <A>(superClass: any, props: A): DeclareConstructor<A>;
-        (superClass: any): DeclareConstructor<any>;
-
-        /**
-         * Mix in properties skipping a constructor and decorating functions
-         * like it is done by declare().
-         */
-        safeMixin<A, B>(target: A, source: B): A & B;
-    }
 }
 
-declare const declare: declare.Declare;
+
+declare const declare: dojo._base.Declare;
 export = declare;