@types/nunjucks

constructor(loader?: ILoaderAny | ILoaderAny[], opts?: ConfigureOptions);

options: { autoescape: boolean };

addExtension: (name: string, ext: Extension) => Environment;

addFilter: (
    name: string,
    func: (...args: any[]) => any,
    async?: boolean
) => Environment;

addGlobal: (name: string, value: any) => Environment;

express: (app: object) => void;

getExtension: (name: string) => Extension;

getFilter: (name: string) => (...args: any[]) => any;

getGlobal: (name: string) => any;

getTemplate: {
    (name: string, eagerCompile?: boolean): Template;
    (
        name: string,
        eagerCompile?: boolean,
        callback?: Callback<Error, Template>
    ): void;
};

hasExtension: (name: string) => boolean;

on: (
    event: 'load',
    fn: (
        name: string,
        source: { src: string; path: string; noCache: boolean },
        loader: Loader
    ) => void
) => void;

removeExtension: (name: string) => void;

render: {
    (name: string, context?: object): string;
    (name: string, context?: object, callback?: TemplateCallback<string>): void;
};

renderString: {
    (name: string, context: object): string;
    (name: string, context: object, callback?: TemplateCallback<string>): void;
};

constructor(searchPaths?: string | string[], opts?: LoaderOptions);

getSource: (name: string) => LoaderSource;

emit: (name: string, ...args: any[]) => void;

static extend: <LoaderClass extends typeof Loader>(
    this: LoaderClass,
    toExtend: ILoaderAny
) => LoaderClass;

isRelative: (filename: string) => boolean;

on: (name: string, func: (...args: any[]) => any) => void;

resolve: (from: string, to: string) => string;

constructor(searchPaths?: string | string[], opts?: LoaderOptions);

getSource: (name: string) => LoaderSource;

constructor(compiledTemplates?: any[]);

getSource: (name: string) => LoaderSource;

constructor(
    src: string,
    env?: Environment,
    path?: string,
    eagerCompile?: boolean
);

render: {
    (context?: object): string;
    (context?: object, callback?: TemplateCallback<string>): void;
};

constructor(baseUrl?: string, opts?: WebLoaderOptions);

async: boolean;

getSource: (
    name: string,
    callback: Callback<Error, LoaderSource>
) => LoaderSource;

autoescape?: boolean | undefined;

dev?: boolean | undefined;

express?: object | undefined;

lstripBlocks?: boolean | undefined;

noCache?: boolean | undefined;

tags?:
    | {
          blockStart?: string | undefined;
          blockEnd?: string | undefined;
          variableStart?: string | undefined;
          variableEnd?: string | undefined;
          commentStart?: string | undefined;
          commentEnd?: string | undefined;
      }
    | undefined;

throwOnUndefined?: boolean | undefined;

trimBlocks?: boolean | undefined;

watch?: boolean | undefined;

web?:
    | {
          useCache?: boolean | undefined;
          async?: boolean | undefined;
      }
    | undefined;

tags: string[];

parse: (parser: any, nodes: any, lexer: any) => any;

async?: false | undefined;

getSource: (name: string) => LoaderSource;

async: true;

getSource: (name: string, callback: Callback<Error, LoaderSource>) => void;

noCache?: boolean;

watch?: boolean;

noCache: boolean;

path: string;

src: string;

asFunction?: boolean | undefined;

env?: Environment | undefined;

exclude?: string[] | undefined;

force?: boolean | undefined;

include?: string[] | undefined;

name?: string | undefined;

wrapper: (
    templates: { name: string; template: string },
    opts: PrecompileOptions
) => string;

async?: boolean;

useCache?: boolean;