const _root = Object.create(null);
export const closure = Object.create(_root);
import { core, js, dart, dartx } from 'dart_sdk';
const $toList = dartx.toList;
const $map = dartx.map;
let dynamic__Toint = () => (dynamic__Toint = dart.constFn(dart.fnTypeFuzzy(core.int, [dart.dynamic], [dart.dynamic])))();
let dynamic__Todynamic = () => (dynamic__Todynamic = dart.constFn(dart.fnTypeFuzzy(dart.dynamic, [dart.dynamic], {y: core.String, z: dart.dynamic})))();
let __Tovoid = () => (__Tovoid = dart.constFn(dart.fnTypeFuzzy(dart.void, [], {i: core.int})))();
let StringToList = () => (StringToList = dart.constFn(dart.fnTypeFuzzy(core.List, [core.String])))();
let ListOfint = () => (ListOfint = dart.constFn(core.List$(core.int)))();
let dynamicTodynamic = () => (dynamicTodynamic = dart.constFn(dart.fnTypeFuzzy(dart.dynamic, [dart.dynamic])))();
let FnToListOfint = () => (FnToListOfint = dart.constFn(dart.fnTypeFuzzy(ListOfint(), [dynamicTodynamic()])))();
let MapOfMap$Map = () => (MapOfMap$Map = dart.constFn(core.Map$(core.Map, core.Map)))();
let Foo = () => (Foo = dart.constFn(closure.Foo$()))();
let ListOfTAndTToListOfT = () => (ListOfTAndTToListOfT = dart.constFn(dart.gFnType(T => [core.List$(T), [core.List$(T), T]])))();
let dynamicTovoid = () => (dynamicTovoid = dart.constFn(dart.fnType(dart.void, [dart.dynamic])))();
let VoidToNull = () => (VoidToNull = dart.constFn(dart.fnType(core.Null, [])))();
closure.generic_function = function<T>(T, items: core.List<T> = null, seed: T = null): core.List<T> {
  let strings = items[$map](core.String, dart.fn((i: T = null): string => dart.str`${i}`, dart.fnType(core.String, [T])))[$toList]();
  return items;
};
dart.fn(closure.generic_function, ListOfTAndTToListOfT());
closure.Callback = dart.typedef('Callback', () => dart.fnTypeFuzzy(dart.void, [], {i: core.int}));
const _is_Foo_default = Symbol('_is_Foo_default');
closure.Foo$ = dart.generic(T => {
  let FooOfT = () => (FooOfT = dart.constFn(closure.Foo$(T)))();
  class Foo<T> extends core.Object {
    i: number;
    b: boolean;
    s: string;
    v: T;
    static some_static_constant: string;
    static some_static_final: string;
    static some_static_var: string;
    prop: string;
    static staticProp: string;
    get i() {
      return this[i$];
    }
    set i(value) {
      super.i = value;
    }
    get b() {
      return this[b];
    }
    set b(value) {
      this[b] = value;
    }
    get s() {
      return this[s];
    }
    set s(value) {
      this[s] = value;
    }
    get v() {
      return this[v$];
    }
    set v(value) {
      this[v$] = T._check(value);
    }
    static build() {
      return new (FooOfT()).new(1, null);
    }
    untyped_method(a = null, b = null) {}
    pass(t: T = null) {
      T._check(t);
      return t;
    }
    typed_method(foo: closure.Foo<any> = null, list: core.List<any> = null, i: number = null, n: number = null, d: number = null, b: boolean = null, s: string = null, a: any[] = null, o: Object = null, f: Function = null) {
      return '';
    }
    optional_params(a = null, b = null, c: number = null) {}
    static named_params(a = null, {b = null, c = null}: {b?: any, c?: number} = {}) {}
    nullary_method() {}
    function_params(f: (x: any, y?: any) => number = null, g: (x: any, opts?: {y?: string, z?: any}) => any = null, cb: (opts?: {i?: number}) => void = null) {
      cb({i: this.i});
    }
    run(a: core.List<any> = null, b: string = null, c: (d: string) => core.List<any> = null, e: (f: (g: any) => any) => core.List<number> = null, {h = null}: {h?: core.Map<core.Map<any, any>, core.Map<any, any>>} = {}) {}
    get prop() {
      return null;
    }
    set prop(value: string = null) {}
    static get staticProp() {
      return null;
    }
    static set staticProp(value: string = null) {}
  }
  (Foo.new = function(i: number = null, v: T = null) {
    this[i$] = i;
    this[v$] = v;
    this[b] = null;
    this[s] = null;
  }).prototype = Foo.prototype;
  dart.addTypeTests(Foo);
  Foo.prototype[_is_Foo_default] = true;
  const i$ = Symbol("Foo.i");
  const b = Symbol("Foo.b");
  const s = Symbol("Foo.s");
  const v$ = Symbol("Foo.v");
  dart.setMethodSignature(Foo, () => ({
    __proto__: dart.getMethods(Foo.__proto__),
    untyped_method: dart.fnType(dart.dynamic, [dart.dynamic, dart.dynamic]),
    pass: dart.fnType(T, [core.Object]),
    typed_method: dart.fnType(core.String, [closure.Foo, core.List, core.int, core.num, core.double, core.bool, core.String, js.JsArray, js.JsObject, js.JsFunction]),
    optional_params: dart.fnType(dart.dynamic, [dart.dynamic], [dart.dynamic, core.int]),
    nullary_method: dart.fnType(dart.dynamic, []),
    function_params: dart.fnType(dart.dynamic, [dynamic__Toint(), dynamic__Todynamic(), __Tovoid()]),
    run: dart.fnType(dart.dynamic, [core.List, core.String, StringToList(), FnToListOfint()], {h: MapOfMap$Map()})
  }));
  dart.setStaticMethodSignature(Foo, () => ({named_params: dart.fnType(dart.dynamic, [dart.dynamic], {b: dart.dynamic, c: core.int})}));
  dart.setGetterSignature(Foo, () => ({
    __proto__: dart.getGetters(Foo.__proto__),
    prop: dart.fnType(core.String, [])
  }));
  dart.setSetterSignature(Foo, () => ({
    __proto__: dart.getSetters(Foo.__proto__),
    prop: dart.fnType(dart.void, [core.String])
  }));
  dart.setFieldSignature(Foo, () => ({
    __proto__: dart.getFields(Foo.__proto__),
    i: dart.finalFieldType(core.int),
    b: dart.fieldType(core.bool),
    s: dart.fieldType(core.String),
    v: dart.fieldType(T)
  }));
  return Foo;
});
closure.Foo = Foo();
dart.defineLazy(closure.Foo, {
  get some_static_constant() {
    return "abc";
  },
  get some_static_final() {
    return "abc";
  },
  get some_static_var() {
    return "abc";
  },
  set some_static_var(_) {}
});
dart.addTypeTests(closure.Foo, _is_Foo_default);
closure.Bar = class Bar extends core.Object {};
(closure.Bar.new = function() {
}).prototype = closure.Bar.prototype;
dart.addTypeTests(closure.Bar);
closure.Baz = class Baz extends dart.mixin(closure.Foo$(core.int), closure.Bar) {};
(closure.Baz.new = function(i: number = null) {
  closure.Baz.__proto__.new.call(this, i, 123);
}).prototype = closure.Baz.prototype;
dart.addTypeTests(closure.Baz);
closure.main = function(args = null): void {
};
dart.fn(closure.main, dynamicTovoid());
dart.defineLazy(closure, {
  get closure() {
    return dart.fn((): core.Null => {
      return;
    }, VoidToNull());
  },
  set closure(_) {},
  get some_top_level_constant() {
    return "abc";
  },
  get some_top_level_final() {
    return "abc";
  },
  get some_top_level_var() {
    return "abc";
  },
  set some_top_level_var(_) {}
});
dart.trackLibraries("closure", {
  "closure.dart": closure
}, null);