From 276f9108ab1dac3b7fc6670b1061f8cf7809785a Mon Sep 17 00:00:00 2001
From: Florian Dold <florian.dold@gmail.com>
Date: Wed, 16 Dec 2015 10:45:16 +0100
Subject: missing files

---
 extension/decl/handlebars/handlebars-1.0.0.d.ts | 184 +++++++++++++++++++
 extension/decl/handlebars/handlebars.d.ts       | 227 ++++++++++++++++++++++++
 2 files changed, 411 insertions(+)
 create mode 100644 extension/decl/handlebars/handlebars-1.0.0.d.ts
 create mode 100644 extension/decl/handlebars/handlebars.d.ts

(limited to 'extension/decl')

diff --git a/extension/decl/handlebars/handlebars-1.0.0.d.ts b/extension/decl/handlebars/handlebars-1.0.0.d.ts
new file mode 100644
index 000000000..c118760c5
--- /dev/null
+++ b/extension/decl/handlebars/handlebars-1.0.0.d.ts
@@ -0,0 +1,184 @@
+// Type definitions for Handlebars 1.0
+// Project: http://handlebarsjs.com/
+// Definitions by: Boris Yankov <https://github.com/borisyankov/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+
+// Use either HandlebarsStatic or HandlebarsRuntimeStatic
+declare var Handlebars: HandlebarsStatic;
+//declare var Handlebars: HandlebarsRuntimeStatic;
+
+/**
+* Implement this interface on your MVW/MVVM/MVC views such as Backbone.View
+**/
+interface HandlebarsTemplatable {
+    template: HandlebarsTemplateDelegate;
+}
+
+interface HandlebarsTemplateDelegate {
+    (context: any, options?: any): string;
+}
+
+interface HandlebarsCommon {
+    registerHelper(name: string, fn: Function, inverse?: boolean): void;
+    registerPartial(name: string, str: any): void;
+    K(): void;
+    createFrame(object: any): any;
+
+    Exception(message: string): void;
+    SafeString: typeof hbs.SafeString;
+    Utils: typeof hbs.Utils;
+
+    logger: Logger;
+    log(level: number, obj: any): void;
+}
+
+interface HandlebarsStatic extends HandlebarsCommon {
+    parse(input: string): hbs.AST.ProgramNode;
+    compile(input: any, options?: any): HandlebarsTemplateDelegate;
+}
+
+interface HandlebarsTemplates {
+    [index: string]: HandlebarsTemplateDelegate;
+}
+
+interface HandlebarsRuntimeStatic extends HandlebarsCommon {
+    // Handlebars.templates is the default template namespace in precompiler.
+    templates: HandlebarsTemplates;
+}
+
+declare module hbs {
+    class SafeString {
+        constructor(str: string);
+        static toString(): string;
+    }
+
+    module Utils {
+        function escapeExpression(str: string): string;
+    }
+}
+
+interface Logger {
+    DEBUG: number;
+    INFO: number;
+    WARN: number;
+    ERROR: number;
+    level: number;
+
+    methodMap: { [level: number]: string };
+
+    log(level: number, obj: string): void;
+}
+
+declare module hbs {
+    module AST {
+        interface IStripInfo {
+            left?: boolean;
+            right?: boolean;
+            inlineStandalone?: boolean;
+        }
+
+        class NodeBase {
+            firstColumn: number;
+            firstLine: number;
+            lastColumn: number;
+            lastLine: number;
+            type: string;
+        }
+
+        class ProgramNode extends NodeBase {
+            statements: NodeBase[];
+        }
+
+        class IdNode extends NodeBase {
+            original: string;
+            parts: string[];
+            string: string;
+            depth: number;
+            idName: string;
+            isSimple: boolean;
+            stringModeValue: string;
+        }
+
+        class HashNode extends NodeBase {
+            pairs: {0: string;
+                    1: NodeBase}[];
+        }
+
+        class SexprNode extends NodeBase {
+            hash: HashNode;
+            id: NodeBase;
+            params: NodeBase[];
+            isHelper: boolean;
+            eligibleHelper: boolean;
+        }
+
+        class MustacheNode extends NodeBase {
+            strip: IStripInfo;
+            escaped: boolean;
+            sexpr: SexprNode;
+
+        }
+
+        class BlockNode extends NodeBase {
+            mustache: MustacheNode;
+            program: ProgramNode;
+            inverse: ProgramNode;
+            strip: IStripInfo;
+            isInverse: boolean;
+        }
+
+        class PartialNameNode extends NodeBase {
+            name: string;
+        }
+
+        class PartialNode extends NodeBase {
+            partialName: PartialNameNode;
+            context: NodeBase;
+            hash: HashNode;
+            strip: IStripInfo;
+        }
+
+        class RawBlockNode extends NodeBase {
+            mustache: MustacheNode;
+            program: ProgramNode;
+        }
+
+        class ContentNode extends NodeBase {
+            original: string;
+            string: string;
+        }
+
+        class DataNode extends NodeBase {
+            id: IdNode;
+            stringModeValue: string;
+            idName: string;
+        }
+
+        class StringNode extends NodeBase {
+            original: string;
+            string: string;
+            stringModeValue: string;
+        }
+
+        class NumberNode extends NodeBase {
+            original: string;
+            number: string;
+            stringModeValue: number;
+        }
+
+        class BooleanNode extends NodeBase {
+            bool: string;
+            stringModeValue: boolean;
+        }
+
+        class CommentNode extends NodeBase {
+            comment: string;
+            strip: IStripInfo;
+        }
+    }
+}
+
+declare module "handlebars" {
+    export = Handlebars;
+}
diff --git a/extension/decl/handlebars/handlebars.d.ts b/extension/decl/handlebars/handlebars.d.ts
new file mode 100644
index 000000000..54dc7e9ae
--- /dev/null
+++ b/extension/decl/handlebars/handlebars.d.ts
@@ -0,0 +1,227 @@
+// Type definitions for Handlebars v3.0.3
+// Project: http://handlebarsjs.com/
+// Definitions by: Boris Yankov <https://github.com/borisyankov/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+
+declare module Handlebars {
+    export function registerHelper(name: string, fn: Function, inverse?: boolean): void;
+    export function registerPartial(name: string, str: any): void;
+    export function unregisterHelper(name: string): void;
+    export function unregisterPartial(name: string): void;
+    export function K(): void;
+    export function createFrame(object: any): any;
+    export function Exception(message: string): void;
+    export function log(level: number, obj: any): void;
+    export function parse(input: string): hbs.AST.Program;
+    export function compile(input: any, options?: any): HandlebarsTemplateDelegate;
+
+    export var SafeString: typeof hbs.SafeString;
+    export var Utils: typeof hbs.Utils;
+    export var logger: Logger;
+    export var templates: HandlebarsTemplates;
+    export var helpers: any;
+
+    export module AST {
+        export var helpers: hbs.AST.helpers;
+    }
+
+    interface ICompiler {
+        accept(node: hbs.AST.Node): void;
+        Program(program: hbs.AST.Program): void;
+        BlockStatement(block: hbs.AST.BlockStatement): void;
+        PartialStatement(partial: hbs.AST.PartialStatement): void;
+        MustacheStatement(mustache: hbs.AST.MustacheStatement): void;
+        ContentStatement(content: hbs.AST.ContentStatement): void;
+        CommentStatement(comment?: hbs.AST.CommentStatement): void;
+        SubExpression(sexpr: hbs.AST.SubExpression): void;
+        PathExpression(path: hbs.AST.PathExpression): void;
+        StringLiteral(str: hbs.AST.StringLiteral): void;
+        NumberLiteral(num: hbs.AST.NumberLiteral): void;
+        BooleanLiteral(bool: hbs.AST.BooleanLiteral): void;
+        UndefinedLiteral(): void;
+        NullLiteral(): void;
+        Hash(hash: hbs.AST.Hash): void;
+    }
+
+    export class Visitor implements ICompiler {
+        accept(node: hbs.AST.Node): void;
+        acceptKey(node: hbs.AST.Node, name: string): void;
+        acceptArray(arr: hbs.AST.Expression[]): void;
+        Program(program: hbs.AST.Program): void;
+        BlockStatement(block: hbs.AST.BlockStatement): void;
+        PartialStatement(partial: hbs.AST.PartialStatement): void;
+        MustacheStatement(mustache: hbs.AST.MustacheStatement): void;
+        ContentStatement(content: hbs.AST.ContentStatement): void;
+        CommentStatement(comment?: hbs.AST.CommentStatement): void;
+        SubExpression(sexpr: hbs.AST.SubExpression): void;
+        PathExpression(path: hbs.AST.PathExpression): void;
+        StringLiteral(str: hbs.AST.StringLiteral): void;
+        NumberLiteral(num: hbs.AST.NumberLiteral): void;
+        BooleanLiteral(bool: hbs.AST.BooleanLiteral): void;
+        UndefinedLiteral(): void;
+        NullLiteral(): void;
+        Hash(hash: hbs.AST.Hash): void;
+    }
+}
+
+/**
+* Implement this interface on your MVW/MVVM/MVC views such as Backbone.View
+**/
+interface HandlebarsTemplatable {
+    template: HandlebarsTemplateDelegate;
+}
+
+interface HandlebarsTemplateDelegate {
+    (context: any, options?: any): string;
+}
+
+interface HandlebarsTemplates {
+    [index: string]: HandlebarsTemplateDelegate;
+}
+
+declare module hbs {
+    class SafeString {
+        constructor(str: string);
+        static toString(): string;
+    }
+
+    module Utils {
+        function escapeExpression(str: string): string;
+    }
+}
+
+interface Logger {
+    DEBUG: number;
+    INFO: number;
+    WARN: number;
+    ERROR: number;
+    level: number;
+
+    methodMap: { [level: number]: string };
+
+    log(level: number, obj: string): void;
+}
+
+declare module hbs {
+    module AST {
+        interface Node {
+            type: string;
+            loc: SourceLocation;
+        }
+
+        interface SourceLocation {
+            source: string;
+            start: Position;
+            end: Position;
+        }
+
+        interface Position {
+            line: number;
+            column: number;
+        }
+
+        interface Program extends Node {
+            body: Statement[];
+            blockParams: string[];
+        }
+
+        interface Statement extends Node {}
+
+        interface MustacheStatement extends Statement {
+            path: PathExpression | Literal;
+            params: Expression[];
+            hash: Hash;
+            escaped: boolean;
+            strip: StripFlags;
+        }
+
+        interface BlockStatement extends Statement {
+            path: PathExpression;
+            params: Expression[];
+            hash: Hash;
+            program: Program;
+            inverse: Program;
+            openStrip: StripFlags;
+            inverseStrip: StripFlags;
+            closeStrip: StripFlags;
+        }
+
+        interface PartialStatement extends Statement {
+            name: PathExpression | SubExpression;
+            params: Expression[];
+            hash: Hash;
+            indent: string;
+            strip: StripFlags;
+        }
+
+        interface ContentStatement extends Statement {
+            value: string;
+            original: StripFlags;
+        }
+
+        interface CommentStatement extends Statement {
+            value: string;
+            strip: StripFlags;
+        }
+
+        interface Expression extends Node {}
+
+        interface SubExpression extends Expression {
+            path: PathExpression;
+            params: Expression[];
+            hash: Hash;
+        }
+
+        interface PathExpression extends Expression {
+            data: boolean;
+            depth: number;
+            parts: string[];
+            original: string;
+        }
+
+        interface Literal extends Expression {}
+        interface StringLiteral extends Literal {
+            value: string;
+            original: string;
+        }
+
+        interface BooleanLiteral extends Literal {
+            value: boolean;
+            original: boolean;
+        }
+
+        interface NumberLiteral extends Literal {
+            value: number;
+            original: number;
+        }
+
+        interface UndefinedLiteral extends Literal {}
+
+        interface NullLiteral extends Literal {}
+
+        interface Hash extends Node {
+            pairs: HashPair[];
+        }
+
+        interface HashPair extends Node {
+            key: string;
+            value: Expression;
+        }
+
+        interface StripFlags {
+            open: boolean;
+            close: boolean;
+        }
+
+        interface helpers {
+            helperExpression(node: Node): boolean;
+            scopeId(path: PathExpression): boolean;
+            simpleId(path: PathExpression): boolean;
+        }
+    }
+}
+
+declare module "handlebars" {
+    export = Handlebars;
+}
-- 
cgit v1.2.3