Jesus sucks

backend/frontend/node_modules/tcomb/index.d.ts

@@ -0,0 +1,270 @@
+type Predicate<T> = (x: T) => boolean;
+type TypeGuardPredicate<T> = (x: any) => x is T;
+
+interface Type<T> extends Function {
+  (value: T): T;
+  is: TypeGuardPredicate<T>;
+  displayName: string;
+  meta: {
+    kind: string;
+    name: string;
+    identity: boolean;
+  };
+  t: T;
+}
+
+//
+// irreducible
+//
+
+interface Irreducible<T> extends Type<T> {
+  meta: {
+    kind: string;
+    name: string;
+    identity: boolean;
+    predicate: TypeGuardPredicate<T>;
+  };
+}
+
+export function irreducible<T>(name: string, predicate: Predicate<any>): Irreducible<T>;
+
+//
+// basic types
+//
+
+export var Any: Irreducible<any>;
+export var Nil: Irreducible<void | null>;
+export var String: Irreducible<string>;
+export var Number: Irreducible<number>;
+export var Integer: Irreducible<number>;
+export var Boolean: Irreducible<boolean>;
+export var Array: Irreducible<Array<any>>;
+export var Object: Irreducible<Object>; // FIXME restrict to POJOs
+export var Function: Irreducible<Function>;
+export var Error: Irreducible<Error>;
+export var RegExp: Irreducible<RegExp>;
+export var Date: Irreducible<Date>;
+
+interface ApplyCommand { $apply: Function; }
+interface PushCommand { $push: Array<any>; }
+interface RemoveCommand { $remove: Array<string>; }
+interface SetCommand { $set: any; }
+interface SpliceCommand { $splice: Array<Array<any>>; }
+interface SwapCommand { $swap: { from: number; to: number; }; }
+interface UnshiftCommand { $unshift: Array<any>; }
+interface MergeCommand { $merge: Object; }
+type Command = ApplyCommand | PushCommand | RemoveCommand | SetCommand | SpliceCommand | SwapCommand | UnshiftCommand | MergeCommand;
+type UpdatePatch = Command | { [key: string]: UpdatePatch };
+type Update<T> = (instance: T, spec: UpdatePatch) => T;
+
+type Constructor<T> = Type<T> | Function;
+
+//
+// refinement
+//
+
+interface Refinement<T> extends Type<T> {
+  meta: {
+    kind: string;
+    name: string;
+    identity: boolean;
+    type: Constructor<T>;
+    predicate: TypeGuardPredicate<T>;
+  };
+  update: Update<T>;
+}
+
+export function refinement<T>(type: Constructor<T>, predicate: Predicate<T>, name?: string): Refinement<T>;
+
+//
+// struct
+//
+
+type StructProps = { [key: string]: Constructor<any> };
+type StructMixin = StructProps | Struct<any> | Interface<any>;
+
+interface Struct<T> extends Type<T> {
+  new(value: T): T;
+  meta: {
+    kind: string;
+    name: string;
+    identity: boolean;
+    props: StructProps;
+    strict: boolean;
+    defaultProps: object;
+  };
+  update: Update<T>;
+  extend<E extends T>(mixins: StructMixin | Array<StructMixin>, name?: string | StructOptions): Struct<E>;
+}
+
+type StructOptions = {
+  name?: string,
+  strict?: boolean,
+  defaultProps?: object
+};
+
+export function struct<T>(props: StructProps, name?: string | StructOptions): Struct<T>;
+
+//
+// interface
+//
+
+interface Interface<T> extends Type<T> {
+  meta: {
+    kind: string;
+    name: string;
+    identity: boolean;
+    props: StructProps;
+    strict: boolean;
+  };
+  update: Update<T>;
+  extend<E extends T>(mixins: StructMixin | Array<StructMixin>, name?: string | StructOptions): Struct<E>;
+}
+
+export function interface<T>(props: StructProps, name?: string | StructOptions): Interface<T>;
+
+//
+// list
+//
+
+interface List<T> extends Type<Array<T>> {
+  meta: {
+    kind: string;
+    name: string;
+    identity: boolean;
+    type: Constructor<T>;
+  };
+  update: Update<Array<T>>;
+}
+
+export function list<T>(type: Constructor<T>, name?: string): List<T>;
+
+//
+// dict combinator
+//
+
+interface Dict<T> extends Type<{ [key: string]: T; }> {
+  meta: {
+    kind: string;
+    name: string;
+    identity: boolean;
+    domain: Constructor<string>;
+    codomain: T;
+  };
+  update: Update<{ [key: string]: T; }>;
+}
+
+export function dict<T>(domain: Constructor<string>, codomain: Constructor<T>, name?: string): Dict<T>;
+
+//
+// enums combinator
+//
+
+interface Enums extends Type<string> {
+  meta: {
+    kind: string;
+    name: string;
+    identity: boolean;
+    map: Object;
+  };
+}
+
+interface EnumsFunction extends Function {
+  (map: Object, name?: string): Enums;
+  of(enums: string, name?: string): Enums;
+  of(enums: Array<string>, name?: string): Enums;
+}
+
+export var enums: EnumsFunction;
+
+//
+// maybe combinator
+//
+
+interface Maybe<T> extends Type<void | T> {
+  meta: {
+    kind: string;
+    name: string;
+    identity: boolean;
+    type: Constructor<T>;
+  };
+  update: Update<void | T>;
+}
+
+export function maybe<T>(type: Constructor<T>, name?: string): Maybe<T>;
+
+//
+// tuple combinator
+//
+
+interface Tuple<T> extends Type<T> {
+  meta: {
+    kind: string;
+    name: string;
+    identity: boolean;
+    types: Array<Constructor<any>>;
+  };
+  update: Update<T>;
+}
+
+export function tuple<T>(types: Array<Constructor<any>>, name?: string): Tuple<T>;
+
+//
+// union combinator
+//
+
+interface Union<T> extends Type<T> {
+  meta: {
+    kind: string;
+    name: string;
+    identity: boolean;
+    types: Array<Constructor<T>>;
+  };
+  update: Update<T>;
+  dispatch(x: any): Constructor<T>;
+}
+
+export function union<T>(types: Array<Constructor<T>>, name?: string): Union<T>;
+
+//
+// intersection combinator
+//
+
+interface Intersection<T> extends Type<T> {
+  meta: {
+    kind: string;
+    name: string;
+    identity: boolean;
+    types: Array<Constructor<any>>;
+  };
+  update: Update<T>;
+}
+
+export function intersection<T>(types: Array<Constructor<any>>, name?: string): Intersection<T>;
+
+//
+// declare combinator
+//
+
+interface Declare<T> extends Type<T> {
+  update: Update<T>;
+  define(type: Type<any>): void;
+}
+
+export function declare<T>(name?: string): Declare<T>;
+
+//
+// other exports
+//
+
+export function is<T>(x: any, type: Constructor<T>): boolean;
+type LazyMessage = () => string;
+export function assert(guard: boolean, message?: string | LazyMessage): void;
+export function fail(message: string): void;
+export function isType<T>(x: Constructor<T>): boolean;
+export function getTypeName<T>(x: Constructor<T>): string;
+export function mixin<T, S>(target: T, source: S, overwrite?: boolean): T & S;
+type Function1 = (x: any) => any;
+type Clause = Constructor<any> | Function1;
+export function match(x: any, ...clauses: Array<Clause>): any; // FIXME
+export var update: Update<Object>;