postcss 6.0.22 → 7.0.2

package/lib/postcss.d.ts

@@ -7,1295 +7,1295 @@ import * as mozilla from 'source-map';
 declare function postcss(plugins?: postcss.AcceptedPlugin[]): postcss.Processor;
 declare function postcss(...plugins: postcss.AcceptedPlugin[]): postcss.Processor;
 declare namespace postcss {
-    type AcceptedPlugin = Plugin<any> | Transformer | {
-        postcss: TransformCallback | Processor;
-    } | Processor;
-    /**
-     * Creates a PostCSS plugin with a standard API.
-     * @param name Plugin name. Same as in name property in package.json. It will
-     * be saved in plugin.postcssPlugin property.
-     * @param initializer Will receive plugin options and should return functions
-     * to modify nodes in input CSS.
-     */
-    function plugin<T>(name: string, initializer: PluginInitializer<T>): Plugin<T>;
-    interface Plugin<T> extends Transformer {
-        (opts?: T): Transformer;
-        postcss: Transformer;
-        process: (css: string | {
-            toString(): string;
-        } | Result, opts?: any) => LazyResult;
-    }
-    interface Transformer extends TransformCallback {
-        postcssPlugin?: string;
-        postcssVersion?: string;
-    }
-    interface TransformCallback {
-        /**
-         * @returns Asynchronous plugins should return a promise.
-         */
-        (root: Root, result?: Result): void | Function | any;
-    }
-    interface PluginInitializer<T> {
-        (pluginOptions?: T): Transformer;
-    }
+  type AcceptedPlugin = Plugin<any> | Transformer | {
+    postcss: TransformCallback | Processor;
+  } | Processor;
+  /**
+   * Creates a PostCSS plugin with a standard API.
+   * @param name Plugin name. Same as in name property in package.json. It will
+   * be saved in plugin.postcssPlugin property.
+   * @param initializer Will receive plugin options and should return functions
+   * to modify nodes in input CSS.
+   */
+  function plugin<T>(name: string, initializer: PluginInitializer<T>): Plugin<T>;
+  interface Plugin<T> extends Transformer {
+    (opts?: T): Transformer;
+    postcss: Transformer;
+    process: (css: string | {
+      toString(): string;
+    } | Result, opts?: any) => LazyResult;
+  }
+  interface Transformer extends TransformCallback {
+    postcssPlugin?: string;
+    postcssVersion?: string;
+  }
+  interface TransformCallback {
     /**
-     * Contains helpers for working with vendor prefixes.
+     * @returns Asynchronous plugins should return a promise.
      */
-    export namespace vendor {
-        /**
-         * @returns The vendor prefix extracted from the input string.
-         */
-        function prefix(prop: string): string;
-        /**
-         * @returns The input string stripped of its vendor prefix.
-         */
-        function unprefixed(prop: string): string;
-    }
-    export class Stringifier {
-        builder: Stringifier.Builder;
-        constructor(builder?: Stringifier.Builder);
-        stringify(node: Node, semicolon?: boolean): void;
-        root(node: any): void;
-        comment(node: any): void;
-        decl(node: any, semicolon: any): void;
-        rule(node: any): void;
-        atrule(node: any, semicolon: any): void;
-        body(node: any): void;
-        block(node: any, start: any): void;
-        raw(node: Node, own: string, detect?: string): any;
-        rawSemicolon(root: any): any;
-        rawEmptyBody(root: any): any;
-        rawIndent(root: any): any;
-        rawBeforeComment(root: any, node: any): any;
-        rawBeforeDecl(root: any, node: any): any;
-        rawBeforeRule(root: any): any;
-        rawBeforeClose(root: any): any;
-        rawBeforeOpen(root: any): any;
-        rawColon(root: any): any;
-        beforeAfter(node: any, detect: any): any;
-        rawValue(node: any, prop: any): any;
-    }
-    export namespace Stringifier {
-        interface Builder {
-            (str: string, node?: Node, str2?: string): void;
-        }
+    (root: Root, result?: Result): void | Function | any;
+  }
+  interface PluginInitializer<T> {
+    (pluginOptions?: T): Transformer;
+  }
+  /**
+   * Contains helpers for working with vendor prefixes.
+   */
+  export namespace vendor {
+    /**
+     * @returns The vendor prefix extracted from the input string.
+     */
+    function prefix(prop: string): string;
+    /**
+     * @returns The input string stripped of its vendor prefix.
+     */
+    function unprefixed(prop: string): string;
+  }
+  export class Stringifier {
+    builder: Stringifier.Builder;
+    constructor(builder?: Stringifier.Builder);
+    stringify(node: Node, semicolon?: boolean): void;
+    root(node: any): void;
+    comment(node: any): void;
+    decl(node: any, semicolon: any): void;
+    rule(node: any): void;
+    atrule(node: any, semicolon: any): void;
+    body(node: any): void;
+    block(node: any, start: any): void;
+    raw(node: Node, own: string, detect?: string): any;
+    rawSemicolon(root: any): any;
+    rawEmptyBody(root: any): any;
+    rawIndent(root: any): any;
+    rawBeforeComment(root: any, node: any): any;
+    rawBeforeDecl(root: any, node: any): any;
+    rawBeforeRule(root: any): any;
+    rawBeforeClose(root: any): any;
+    rawBeforeOpen(root: any): any;
+    rawColon(root: any): any;
+    beforeAfter(node: any, detect: any): any;
+    rawValue(node: any, prop: any): any;
+  }
+  export namespace Stringifier {
+    interface Builder {
+      (str: string, node?: Node, str2?: string): void;
     }
+  }
+  /**
+   * Default function to convert a node tree into a CSS string.
+   */
+  function stringify(node: Node, builder: Stringifier.Builder): void;
+  /**
+   * Parses source CSS.
+   * @param css The CSS to parse.
+   * @param options
+   * @returns {} A new Root node, which contains the source CSS nodes.
+   */
+  function parse(css: string | {
+    toString(): string;
+  } | LazyResult | Result, options?: {
+    from?: string;
+    map?: postcss.SourceMapOptions;
+  }): Root;
+  /**
+   * Contains helpers for safely splitting lists of CSS values, preserving
+   * parentheses and quotes.
+   */
+  export namespace list {
     /**
-     * Default function to convert a node tree into a CSS string.
+     * Safely splits space-separated values (such as those for background,
+     * border-radius and other shorthand properties).
      */
-    function stringify(node: Node, builder: Stringifier.Builder): void;
+    function space(str: string): string[];
     /**
-     * Parses source CSS.
-     * @param css The CSS to parse.
-     * @param options
-     * @returns {} A new Root node, which contains the source CSS nodes.
+     * Safely splits comma-separated values (such as those for transition-* and
+     * background  properties).
      */
-    function parse(css: string | {
-        toString(): string;
-    } | LazyResult | Result, options?: {
-        from?: string;
-        map?: postcss.SourceMapOptions;
-    }): Root;
+    function comma(str: string): string[];
+  }
+  /**
+   * Creates a new Comment node.
+   * @param defaults Properties for the new Comment node.
+   * @returns The new node.
+   */
+  function comment(defaults?: CommentNewProps): Comment;
+  /**
+   * Creates a new AtRule node.
+   * @param defaults Properties for the new AtRule node.
+   * @returns The new node.
+   */
+  function atRule(defaults?: AtRuleNewProps): AtRule;
+  /**
+   * Creates a new Declaration node.
+   * @param defaults Properties for the new Declaration node.
+   * @returns The new node.
+   */
+  function decl(defaults?: DeclarationNewProps): Declaration;
+  /**
+   * Creates a new Rule node.
+   * @param defaults Properties for the new Rule node.
+   * @returns The new node.
+   */
+  function rule(defaults?: RuleNewProps): Rule;
+  /**
+   * Creates a new Root node.
+   * @param defaults Properties for the new Root node.
+   * @returns The new node.
+   */
+  function root(defaults?: object): Root;
+  interface SourceMapOptions {
     /**
-     * Contains helpers for safely splitting lists of CSS values, preserving
-     * parentheses and quotes.
+     * Indicates that the source map should be embedded in the output CSS as a
+     * Base64-encoded comment. By default, it is true. But if all previous maps
+     * are external, not inline, PostCSS will not embed the map even if you do
+     * not set this option.
+     *
+     * If you have an inline source map, the result.map property will be empty,
+     * as the source map will be contained within the text of result.css.
      */
-    export namespace list {
-        /**
-         * Safely splits space-separated values (such as those for background,
-         * border-radius and other shorthand properties).
-         */
-        function space(str: string): string[];
-        /**
-         * Safely splits comma-separated values (such as those for transition-* and
-         * background  properties).
-         */
-        function comma(str: string): string[];
-    }
+    inline?: boolean;
     /**
-     * Creates a new Comment node.
-     * @param defaults Properties for the new Comment node.
-     * @returns The new node.
+     * Source map content from a previous processing step (e.g., Sass compilation).
+     * PostCSS will try to read the previous source map automatically (based on comments
+     * within the source CSS), but you can use this option to identify it manually.
+     * If desired, you can omit the previous map with prev: false.
      */
-    function comment(defaults?: CommentNewProps): Comment;
+    prev?: any;
     /**
-     * Creates a new AtRule node.
-     * @param defaults Properties for the new AtRule node.
-     * @returns The new node.
+     * Indicates that PostCSS should set the origin content (e.g., Sass source)
+     * of the source map. By default, it is true. But if all previous maps do not
+     * contain sources content, PostCSS will also leave it out even if you do not set
+     * this option.
      */
-    function atRule(defaults?: AtRuleNewProps): AtRule;
+    sourcesContent?: boolean;
     /**
-     * Creates a new Declaration node.
-     * @param defaults Properties for the new Declaration node.
-     * @returns The new node.
+     * Indicates that PostCSS should add annotation comments to the CSS. By default,
+     * PostCSS will always add a comment with a path to the source map. PostCSS will
+     * not add annotations to CSS files that do not contain any comments.
+     *
+     * By default, PostCSS presumes that you want to save the source map as
+     * opts.to + '.map' and will use this path in the annotation comment. A different
+     * path can be set by providing a string value for annotation.
+     *
+     * If you have set inline: true, annotation cannot be disabled.
      */
-    function decl(defaults?: DeclarationNewProps): Declaration;
+    annotation?: boolean | string;
     /**
-     * Creates a new Rule node.
-     * @param defaults Properties for the new Rule node.
-     * @returns The new node.
+     * If true, PostCSS will try to correct any syntax errors that it finds in the CSS.
+     * This is useful for legacy code filled with hacks. Another use-case is interactive
+     * tools with live input — for example, the Autoprefixer demo.
      */
-    function rule(defaults?: RuleNewProps): Rule;
+    safe?: boolean;
+  }
+  /**
+   * A Processor instance contains plugins to process CSS. Create one
+   * Processor  instance, initialize its plugins, and then use that instance
+   * on numerous CSS files.
+   */
+  interface Processor {
     /**
-     * Creates a new Root node.
-     * @param defaults Properties for the new Root node.
-     * @returns The new node.
+     * Adds a plugin to be used as a CSS processor. Plugins can also be
+     * added by passing them as arguments when creating a postcss instance.
      */
-    function root(defaults?: object): Root;
-    interface SourceMapOptions {
-        /**
-         * Indicates that the source map should be embedded in the output CSS as a
-         * Base64-encoded comment. By default, it is true. But if all previous maps
-         * are external, not inline, PostCSS will not embed the map even if you do
-         * not set this option.
-         *
-         * If you have an inline source map, the result.map property will be empty,
-         * as the source map will be contained within the text of result.css.
-         */
-        inline?: boolean;
-        /**
-         * Source map content from a previous processing step (e.g., Sass compilation).
-         * PostCSS will try to read the previous source map automatically (based on comments
-         * within the source CSS), but you can use this option to identify it manually.
-         * If desired, you can omit the previous map with prev: false.
-         */
-        prev?: any;
-        /**
-         * Indicates that PostCSS should set the origin content (e.g., Sass source)
-         * of the source map. By default, it is true. But if all previous maps do not
-         * contain sources content, PostCSS will also leave it out even if you do not set
-         * this option.
-         */
-        sourcesContent?: boolean;
-        /**
-         * Indicates that PostCSS should add annotation comments to the CSS. By default,
-         * PostCSS will always add a comment with a path to the source map. PostCSS will
-         * not add annotations to CSS files that do not contain any comments.
-         *
-         * By default, PostCSS presumes that you want to save the source map as
-         * opts.to + '.map' and will use this path in the annotation comment. A different
-         * path can be set by providing a string value for annotation.
-         *
-         * If you have set inline: true, annotation cannot be disabled.
-         */
-        annotation?: boolean | string;
-        /**
-         * If true, PostCSS will try to correct any syntax errors that it finds in the CSS.
-         * This is useful for legacy code filled with hacks. Another use-case is interactive
-         * tools with live input — for example, the Autoprefixer demo.
-         */
-        safe?: boolean;
-    }
+    use(plugin: AcceptedPlugin): Processor;
     /**
-     * A Processor instance contains plugins to process CSS. Create one
-     * Processor  instance, initialize its plugins, and then use that instance
-     * on numerous CSS files.
+     * Parses source CSS. Because some plugins can be asynchronous it doesn't
+     * make any transformations. Transformations will be applied in LazyResult's
+     * methods.
+     * @param css Input CSS or any object with toString() method, like a file
+     * stream. If a Result instance is passed the processor will take the
+     * existing Root parser from it.
      */
-    interface Processor {
-        /**
-         * Adds a plugin to be used as a CSS processor. Plugins can also be
-         * added by passing them as arguments when creating a postcss instance.
-         */
-        use(plugin: AcceptedPlugin): Processor;
-        /**
-         * Parses source CSS. Because some plugins can be asynchronous it doesn't
-         * make any transformations. Transformations will be applied in LazyResult's
-         * methods.
-         * @param css Input CSS or any object with toString() method, like a file
-         * stream. If a Result instance is passed the processor will take the
-         * existing Root parser from it.
-         */
-        process(css: string | {
-            toString(): string;
-        } | Result, options?: ProcessOptions): LazyResult;
-        /**
-         * Contains plugins added to this processor.
-         */
-        plugins: Plugin<any>[];
-        /**
-         * Contains the current version of PostCSS (e.g., "4.0.5").
-         */
-        version: string;
-    }
-    interface ProcessOptions extends Syntax {
-        /**
-         * The path of the CSS source file. You should always set from, because it is
-         * used in source map generation and syntax error messages.
-         */
-        from?: string;
-        /**
-         * The path where you'll put the output CSS file. You should always set it
-         * to generate correct source maps.
-         */
-        to?: string;
-        syntax?: Syntax;
-        /**
-         * Enable Safe Mode, in which PostCSS will try to fix CSS syntax errors.
-         */
-        safe?: boolean;
-        map?: postcss.SourceMapOptions;
-        /**
-         * Function to generate AST by string.
-         */
-        parser?: Parse | Syntax;
-        /**
-         * Class to generate string by AST.
-         */
-        stringifier?: Stringify | Syntax;
-    }
-    interface Syntax {
-        /**
-         * Function to generate AST by string.
-         */
-        parse?: Parse;
-        /**
-         * Class to generate string by AST.
-         */
-        stringify?: Stringify;
-    }
-    interface Parse {
-        (css?: string, opts?: postcss.SourceMapOptions): Root;
-    }
-    interface Stringify {
-        (node?: postcss.Node, builder?: any): postcss.Result | void;
-    }
+    process(css: string | {
+      toString(): string;
+    } | Result, options?: ProcessOptions): LazyResult;
     /**
-     * A promise proxy for the result of PostCSS transformations.
+     * Contains plugins added to this processor.
      */
-    interface LazyResult {
-        /**
-         * Processes input CSS through synchronous and asynchronous plugins.
-         * @param onRejected Called if any plugin throws an error.
-         */
-        then(onFulfilled: (result: Result) => void, onRejected?: (error: Error) => void): Function | any;
-        /**
-         * Processes input CSS through synchronous and asynchronous plugins.
-         * @param onRejected Called if any plugin throws an error.
-         */
-        catch(onRejected: (error: Error) => void): Function | any;
-        /**
-         * Alias for css property.
-         */
-        toString(): string;
-        /**
-         * Processes input CSS through synchronous plugins and converts Root to
-         * CSS string. This property will only work with synchronous plugins. If
-         * the processor contains any asynchronous plugins it will throw an error.
-         * In this case, you should use LazyResult#then() instead.
-         * @returns Result#css.
-         */
-        css: string;
-        /**
-         * Alias for css property to use when syntaxes generate non-CSS output.
-         */
-        content: string;
-        /**
-         * Processes input CSS through synchronous plugins. This property will
-         * work only with synchronous plugins. If processor contains any
-         * asynchronous plugins it will throw an error. You should use
-         * LazyResult#then() instead.
-         */
-        map: ResultMap;
-        /**
-         * Processes input CSS through synchronous plugins. This property will work
-         * only with synchronous plugins. If processor contains any asynchronous
-         * plugins it will throw an error. You should use LazyResult#then() instead.
-         */
-        root: Root;
-        /**
-         * Processes input CSS through synchronous plugins and calls Result#warnings().
-         * This property will only work with synchronous plugins. If the processor
-         * contains any asynchronous plugins it will throw an error. In this case,
-         * you should use LazyResult#then() instead.
-         */
-        warnings(): ResultMessage[];
-        /**
-         * Processes input CSS through synchronous plugins. This property will work
-         * only with synchronous plugins. If processor contains any asynchronous
-         * plugins it will throw an error. You should use LazyResult#then() instead.
-         */
-        messages: ResultMessage[];
-        /**
-         * @returns A processor used for CSS transformations.
-         */
-        processor: Processor;
-        /**
-         * @returns Options from the Processor#process(css, opts) call that produced
-         * this Result instance.
-         */
-        opts: ResultOptions;
-    }
+    plugins: Plugin<any>[];
     /**
-     * Provides the result of the PostCSS transformations.
+     * Contains the current version of PostCSS (e.g., "4.0.5").
      */
-    interface Result {
-        /**
-         * Alias for css property.
-         */
-        toString(): string;
-        /**
-         * Creates an instance of Warning and adds it to messages.
-         * @param message Used in the text property of the message object.
-         * @param options Properties for Message object.
-         */
-        warn(message: string, options?: WarningOptions): void;
-        /**
-         * @returns Warnings from plugins, filtered from messages.
-         */
-        warnings(): ResultMessage[];
-        /**
-         * A CSS string representing this Result's Root instance.
-         */
-        css: string;
-        /**
-         * Alias for css property to use with syntaxes that generate non-CSS output.
-         */
-        content: string;
-        /**
-         * An instance of the SourceMapGenerator class from the source-map library,
-         * representing changes to the Result's Root instance.
-         * This property will have a value only if the user does not want an inline
-         * source map. By default, PostCSS generates inline source maps, written
-         * directly into the processed CSS. The map property will be empty by default.
-         * An external source map will be generated — and assigned to map — only if
-         * the user has set the map.inline option to false, or if PostCSS was passed
-         * an external input source map.
-         */
-        map: ResultMap;
-        /**
-         * Contains the Root node after all transformations.
-         */
-        root?: Root;
-        /**
-         * Contains messages from plugins (e.g., warnings or custom messages).
-         * Add a warning using Result#warn() and get all warnings
-         * using the Result#warnings() method.
-         */
-        messages: ResultMessage[];
-        /**
-         * The Processor instance used for this transformation.
-         */
-        processor?: Processor;
-        /**
-         * Options from the Processor#process(css, opts) or Root#toResult(opts) call
-         * that produced this Result instance.
-         */
-        opts?: ResultOptions;
-    }
-    interface ResultOptions extends ProcessOptions {
-        /**
-         * The CSS node that was the source of the warning.
-         */
-        node?: postcss.Node;
-        /**
-         * Name of plugin that created this warning. Result#warn() will fill it
-         * automatically with plugin.postcssPlugin value.
-         */
-        plugin?: string;
-    }
-    interface ResultMap {
-        /**
-         * Add a single mapping from original source line and column to the generated
-         * source's line and column for this source map being created. The mapping
-         * object should have the following properties:
-         * @param mapping
-         * @returns {}
-         */
-        addMapping(mapping: mozilla.Mapping): void;
-        /**
-         * Set the source content for an original source file.
-         * @param sourceFile The URL of the original source file.
-         * @param sourceContent The content of the source file.
-         */
-        setSourceContent(sourceFile: string, sourceContent: string): void;
-        /**
-         * Applies a SourceMap for a source file to the SourceMap. Each mapping to
-         * the supplied source file is rewritten using the supplied SourceMap.
-         * Note: The resolution for the resulting mappings is the minimium of this
-         * map and the supplied map.
-         * @param sourceMapConsumer The SourceMap to be applied.
-         * @param sourceFile The filename of the source file. If omitted, sourceMapConsumer
-         * file will be used, if it exists. Otherwise an error will be thrown.
-         * @param sourceMapPath The dirname of the path to the SourceMap to be applied.
-         * If relative, it is relative to the SourceMap. This parameter is needed when
-         * the two SourceMaps aren't in the same directory, and the SourceMap to be
-         * applied contains relative source paths. If so, those relative source paths
-         * need to be rewritten relative to the SourceMap.
-         * If omitted, it is assumed that both SourceMaps are in the same directory;
-         * thus, not needing any rewriting (Supplying '.' has the same effect).
-         */
-        applySourceMap(
-            sourceMapConsumer: mozilla.SourceMapConsumer,
-            sourceFile?: string,
-            sourceMapPath?: string
-        ): void;
-        /**
-         * Renders the source map being generated to JSON.
-         */
-        toJSON: () => mozilla.RawSourceMap;
-        /**
-         * Renders the source map being generated to a string.
-         */
-        toString: () => string;
-    }
-    interface ResultMessage {
-        type: string;
-        text?: string;
-        plugin?: string;
-        browsers?: string[];
-    }
+    version: string;
+  }
+  interface ProcessOptions extends Syntax {
     /**
-     * Represents a plugin warning. It can be created using Result#warn().
+     * The path of the CSS source file. You should always set from, because it is
+     * used in source map generation and syntax error messages.
      */
-    interface Warning {
-        /**
-         * @returns Error position, message.
-         */
-        toString(): string;
-        /**
-         * Contains the warning message.
-         */
-        text: string;
-        /**
-         * Contains the name of the plugin that created this warning. When you
-         * call Result#warn(), it will fill this property automatically.
-         */
-        plugin: string;
-        /**
-         * The CSS node that caused the warning.
-         */
-        node: Node;
-        /**
-         * The line in the input file with this warning's source.
-         */
-        line: number;
-        /**
-         * Column in the input file with this warning's source.
-         */
-        column: number;
-    }
-    interface WarningOptions extends ResultOptions {
-        /**
-         * A word inside a node's string that should be highlighted as source
-         * of warning.
-         */
-        word?: string;
-        /**
-         * The index inside a node's string that should be highlighted as
-         * source of warning.
-         */
-        index?: number;
-    }
+    from?: string;
     /**
-     * The CSS parser throws this error for broken CSS.
+     * The path where you'll put the output CSS file. You should always set it
+     * to generate correct source maps.
      */
-    interface CssSyntaxError extends InputOrigin {
-        name: string;
-        /**
-         * @returns Error position, message and source code of broken part.
-         */
-        toString(): string;
-        /**
-         * @param color Whether arrow should be colored red by terminal color codes.
-         * By default, PostCSS will use process.stdout.isTTY and
-         * process.env.NODE_DISABLE_COLORS.
-         * @returns A few lines of CSS source that caused the error. If CSS has
-         * input source map without sourceContent this method will return an empty
-         * string.
-         */
-        showSourceCode(color?: boolean): string;
-        /**
-         * Contains full error text in the GNU error format.
-         */
-        message: string;
-        /**
-         * Contains only the error description.
-         */
-        reason: string;
-        /**
-         * Contains the PostCSS plugin name if the error didn't come from the
-         * CSS parser.
-         */
-        plugin?: string;
-        input?: InputOrigin;
-    }
-    interface InputOrigin {
-        /**
-         * If parser's from option is set, contains the absolute path to the
-         * broken file. PostCSS will use the input source map to detect the
-         * original error location. If you wrote a Sass file, then compiled it
-         * to CSS and parsed it with PostCSS, PostCSS will show the original
-         * position in the Sass file. If you need the position in the PostCSS
-         * input (e.g., to debug the previous compiler), use error.input.file.
-         */
-        file?: string;
-        /**
-         * Contains the source line of the error. PostCSS will use the input
-         * source map to detect the original error location. If you wrote a Sass
-         * file, then compiled it to CSS and parsed it with PostCSS, PostCSS
-         * will show the original position in the Sass file. If you need the
-         * position in the PostCSS input (e.g., to debug the previous
-         * compiler), use error.input.line.
-         */
-        line?: number;
-        /**
-         * Contains the source column of the error. PostCSS will use input
-         * source map to detect the original error location. If you wrote a
-         * Sass file, then compiled it to CSS and parsed it with PostCSS,
-         * PostCSS will show the original position in the Sass file. If you
-         * need the position in the PostCSS input (e.g., to debug the
-         * previous compiler), use error.input.column.
-         */
-        column?: number;
-        /**
-         * Contains the source code of the broken file. PostCSS will use the
-         * input source map to detect the original error location. If you wrote
-         * a Sass file, then compiled it to CSS and parsed it with PostCSS,
-         * PostCSS will show the original position in the Sass file. If you need
-         * the position in the PostCSS input (e.g., to debug the previous
-         * compiler), use error.input.source.
-         */
-        source?: string;
-    }
-    export class PreviousMap {
-        private inline;
-        annotation: string;
-        root: string;
-        private consumerCache;
-        text: string;
-        file: string;
-        constructor(css: any, opts: any);
-        consumer(): mozilla.SourceMapConsumer;
-        withContent(): boolean;
-        startWith(string: string, start: string): boolean;
-        loadAnnotation(css: string): void;
-        decodeInline(text: string): string;
-        loadMap(
-            file: any,
-            prev: string | Function | mozilla.SourceMapConsumer | mozilla.SourceMapGenerator | mozilla.RawSourceMap
-        ): string;
-        isMap(map: any): boolean;
-    }
+    to?: string;
+    syntax?: Syntax;
     /**
-     * Represents the source CSS.
+     * Enable Safe Mode, in which PostCSS will try to fix CSS syntax errors.
      */
-    interface Input {
-        /**
-         * The absolute path to the CSS source file defined with the "from" option.
-         */
-        file: string;
-        /**
-         * The unique ID of the CSS source. Used if "from" option is not provided
-         * (because PostCSS does not know the file path).
-         */
-        id: string;
-        /**
-         * The CSS source identifier. Contains input.file if the user set the
-         * "from" option, or input.id if they did not.
-         */
-        from: string;
-        /**
-         * Represents the input source map passed from a compilation step before
-         * PostCSS (e.g., from the Sass compiler).
-         */
-        map: PreviousMap;
-        /**
-         * Reads the input source map.
-         * @returns A symbol position in the input source (e.g., in a Sass file
-         * that was compiled to CSS before being passed to PostCSS):
-         */
-        origin(line: number, column: number): InputOrigin;
-    }
-    type ChildNode = AtRule | Rule | Declaration | Comment;
-    type Node = Root | ChildNode;
-    interface NodeBase {
-        /**
-         * Returns the input source of the node. The property is used in source
-         * map generation. If you create a node manually
-         * (e.g., with postcss.decl() ), that node will not have a source
-         * property and will be absent from the source map. For this reason, the
-         * plugin developer should consider cloning nodes to create new ones
-         * (in which case the new node's source will reference the original,
-         * cloned node) or setting the source property manually.
-         */
-        source: NodeSource;
-        /**
-         * Contains information to generate byte-to-byte equal node string as it
-         * was in origin input.
-         */
-        raws: NodeRaws;
-        /**
-         * @returns A CSS string representing the node.
-         */
-        toString(): string;
-        /**
-         * This method produces very useful error messages. If present, an input
-         * source map will be used to get the original position of the source, even
-         * from a previous compilation step (e.g., from Sass compilation).
-         * @returns The original position of the node in the source, showing line
-         * and column numbers and also a small excerpt to facilitate debugging.
-         */
-        error(
-            /**
-             * Error description.
-             */
-            message: string, options?: NodeErrorOptions): CssSyntaxError;
-        /**
-         * Creates an instance of Warning and adds it to messages. This method is
-         * provided as a convenience wrapper for Result#warn.
-         * Note that `opts.node` is automatically passed to Result#warn for you.
-         * @param result The result that will receive the warning.
-         * @param text Warning message. It will be used in the `text` property of
-         * the message object.
-         * @param opts Properties to assign to the message object.
-         */
-        warn(result: Result, text: string, opts?: WarningOptions): void;
-        /**
-         * @returns The next child of the node's parent; or, returns undefined if
-         * the current node is the last child.
-         */
-        next(): ChildNode | void;
-        /**
-         * @returns The previous child of the node's parent; or, returns undefined
-         * if the current node is the first child.
-         */
-        prev(): ChildNode | void;
-		/**
-		 * Insert new node before current node to current node’s parent.
-		 *
-		 * Just an alias for `node.parent.insertBefore(node, newNode)`.
-		 *
-		 * @returns this node for method chaining.
-		 *
-		 * @example
-		 * decl.before('content: ""');
-		 */
-        before(newNode: Node | object | string | Node[]): this;
-		/**
-		 * Insert new node after current node to current node’s parent.
-		 *
-		 * Just an alias for `node.parent.insertAfter(node, newNode)`.
-		 *
-		 * @returns this node for method chaining.
-		 *
-		 * @example
-		 * decl.after('color: black');
-		 */
-        after(newNode: Node | object | string | Node[]): this;
-        /**
-         * @returns The Root instance of the node's tree.
-         */
-        root(): Root;
-        /**
-         * Removes the node from its parent and cleans the parent property in the
-         * node and its children.
-         * @returns This node for chaining.
-         */
-        remove(): this;
-        /**
-         * Inserts node(s) before the current node and removes the current node.
-         * @returns This node for chaining.
-         */
-        replaceWith(...nodes: (Node | object)[]): this;
-        /**
-         * @param overrides New properties to override in the clone.
-         * @returns A clone of this node. The node and its (cloned) children will
-         * have a clean parent and code style properties.
-         */
-        clone(overrides?: object): this;
-        /**
-         * Shortcut to clone the node and insert the resulting cloned node before
-         * the current node.
-         * @param overrides New Properties to override in the clone.
-         * @returns The cloned node.
-         */
-        cloneBefore(overrides?: object): this;
-        /**
-         * Shortcut to clone the node and insert the resulting cloned node after
-         * the current node.
-         * @param overrides New Properties to override in the clone.
-         * @returns The cloned node.
-         */
-        cloneAfter(overrides?: object): this;
-        /**
-         * @param prop Name or code style property.
-         * @param defaultType Name of default value. It can be easily missed if the
-         * value is the same as prop.
-         * @returns A code style property value. If the node is missing the code
-         * style property (because the node was manually built or cloned), PostCSS
-         * will try to autodetect the code style property by looking at other nodes
-         * in the tree.
-         */
-        raw(prop: string, defaultType?: string): any;
-    }
-    interface NodeNewProps {
-        source?: NodeSource;
-        raws?: NodeRaws;
-    }
-    interface NodeRaws {
-        /**
-         * The space symbols before the node. It also stores `*` and `_`
-         * symbols before the declaration (IE hack).
-         */
-        before?: string;
-        /**
-         * The space symbols after the last child of the node to the end of
-         * the node.
-         */
-        after?: string;
-        /**
-         * The symbols between the property and value for declarations,
-         * selector and "{" for rules, last parameter and "{" for at-rules.
-         */
-        between?: string;
-        /**
-         * True if last child has (optional) semicolon.
-         */
-        semicolon?: boolean;
-        /**
-         * The space between the at-rule's name and parameters.
-         */
-        afterName?: string;
-        /**
-         * The space symbols between "/*" and comment's text.
-         */
-        left?: string;
-        /**
-         * The space symbols between comment's text and "*\/".
-         */
-        right?: string;
-        /**
-         * The content of important statement, if it is not just "!important".
-         */
-        important?: string;
-    }
-    interface NodeSource {
-        input: Input;
-        /**
-         * The starting position of the node's source.
-         */
-        start?: {
-            column: number;
-            line: number;
-        };
-        /**
-         * The ending position of the node's source.
-         */
-        end?: {
-            column: number;
-            line: number;
-        };
-    }
-    interface NodeErrorOptions {
-        /**
-         * Plugin name that created this error. PostCSS will set it automatically.
-         */
-        plugin?: string;
-        /**
-         * A word inside a node's string, that should be highlighted as source
-         * of error.
-         */
-        word?: string;
-        /**
-         * An index inside a node's string that should be highlighted as source
-         * of error.
-         */
-        index?: number;
-    }
-    interface JsonNode {
-        /**
-         * Returns a string representing the node's type. Possible values are
-         * root, atrule, rule, decl or comment.
-         */
-        type?: string;
-        /**
-         * Returns the node's parent node.
-         */
-        parent?: JsonContainer;
-        /**
-         * Returns the input source of the node. The property is used in source
-         * map generation. If you create a node manually (e.g., with
-         * postcss.decl() ), that node will not have a  source  property and
-         * will be absent from the source map. For this reason, the plugin
-         * developer should consider cloning nodes to create new ones (in which
-         * case the new node's source will reference the original, cloned node)
-         * or setting the source property manually.
-         */
-        source?: NodeSource;
-        /**
-         * Contains information to generate byte-to-byte equal node string as it
-         * was in origin input.
-         */
-        raws?: NodeRaws;
-    }
-    type Container = Root | AtRule | Rule;
+    safe?: boolean;
+    map?: postcss.SourceMapOptions;
     /**
-     * Containers can store any content. If you write a rule inside a rule,
-     * PostCSS will parse it.
+     * Function to generate AST by string.
      */
-    interface ContainerBase extends NodeBase {
-        /**
-         * Contains the container's children.
-         */
-        nodes?: ChildNode[];
-        /**
-         * @returns The container's first child.
-         */
-        first?: ChildNode;
-        /**
-         * @returns The container's last child.
-         */
-        last?: ChildNode;
-        /**
-         * @param overrides New properties to override in the clone.
-         * @returns A clone of this node. The node and its (cloned) children will
-         * have a clean parent and code style properties.
-         */
-        clone(overrides?: object): this;
-        /**
-         * @param child Child of the current container.
-         * @returns The child's index within the container's "nodes" array.
-         */
-        index(child: ChildNode | number): number;
-        /**
-         * Determines whether all child nodes satisfy the specified test.
-         * @param callback A function that accepts up to three arguments. The
-         * every method calls the callback function for each node until the
-         * callback returns false, or until the end of the array.
-         * @returns True if the callback returns true for all of the container's
-         * children.
-         */
-        every(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => any, thisArg?: any): boolean;
-        /**
-         * Determines whether the specified callback returns true for any child node.
-         * @param callback A function that accepts up to three arguments. The some
-         * method calls the callback for each node until the callback returns true,
-         * or until the end of the array.
-         * @param thisArg An object to which the this keyword can refer in the
-         * callback function. If thisArg is omitted, undefined is used as the
-         * this value.
-         * @returns True if callback returns true for (at least) one of the
-         * container's children.
-         */
-        some(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean, thisArg?: any): boolean;
-        /**
-         * Iterates through the container's immediate children, calling the
-         * callback function for each child. If you need to recursively iterate
-         * through all the container's descendant nodes, use container.walk().
-         * Unlike the for {} -cycle or Array#forEach() this iterator is safe if
-         * you are mutating the array of child nodes during iteration.
-         * @param callback Iterator. Returning false will break iteration. Safe
-         * if you are mutating the array of child nodes during iteration. PostCSS
-         * will adjust the current index to match the mutations.
-         * @returns False if the callback returns false during iteration.
-         */
-        each(callback: (node: ChildNode, index: number) => any): boolean | void;
-        /**
-         * Traverses the container's descendant nodes, calling `callback` for each
-         * node. Like container.each(), this method is safe to use if you are
-         * mutating arrays during iteration. If you only need to iterate through
-         * the container's immediate children, use container.each().
-         * @param callback Iterator.
-         */
-        walk(callback: (node: ChildNode, index: number) => any): boolean | void;
-        /**
-         * Traverses the container's descendant nodes, calling `callback` for each
-         * declaration. Like container.each(), this method is safe to use if you
-         * are mutating arrays during iteration.
-         * @param propFilter Filters declarations by property name. Only those
-         * declarations whose property matches propFilter will be iterated over.
-         * @param callback Called for each declaration node within the container.
-         */
-        walkDecls(propFilter: string | RegExp, callback?: (decl: Declaration, index: number) => any): boolean | void;
-        walkDecls(callback: (decl: Declaration, index: number) => any): boolean | void;
-        /**
-         * Traverses the container's descendant nodes, calling `callback` for each
-         * at-rule. Like container.each(), this method is safe to use if you are
-         * mutating arrays during iteration.
-         * @param nameFilter Filters at-rules by name. If provided, iteration
-         * will only happen over at-rules that have matching names.
-         * @param callback Iterator called for each at-rule node within the
-         * container.
-         */
-        walkAtRules(nameFilter: string | RegExp, callback: (atRule: AtRule, index: number) => any): boolean | void;
-        walkAtRules(callback: (atRule: AtRule, index: number) => any): boolean | void;
-        /**
-         * Traverses the container's descendant nodes, calling `callback` for each
-         * rule. Like container.each(), this method is safe to use if you are
-         * mutating arrays during iteration.
-         * @param selectorFilter Filters rules by selector. If provided,
-         * iteration will only happen over rules that have matching names.
-         * @param callback Iterator called for each rule node within the
-         * container.
-         */
-        walkRules(selectorFilter: string | RegExp, callback: (atRule: Rule, index: number) => any): boolean | void;
-        walkRules(callback: (atRule: Rule, index: number) => any): boolean | void;
-        walkRules(selectorFilter: any, callback?: (atRule: Rule, index: number) => any): boolean | void;
-        /**
-         * Traverses the container's descendant nodes, calling `callback` for each
-         * comment. Like container.each(), this method is safe to use if you are
-         * mutating arrays during iteration.
-         * @param callback Iterator called for each comment node within the container.
-         */
-        walkComments(callback: (comment: Comment, indexed: number) => any): void | boolean;
-        /**
-         * Passes all declaration values within the container that match pattern
-         * through the callback, replacing those values with the returned result of
-         * callback. This method is useful if you are using a custom unit or
-         * function and need to iterate through all values.
-         * @param pattern Pattern that we need to replace.
-         * @param options Options to speed up the search.
-         * @param callbackOrReplaceValue String to replace pattern or callback
-         * that will return a new value. The callback will receive the same
-         * arguments as those passed to a function parameter of String#replace.
-         */
-        replaceValues(pattern: string | RegExp, options: {
-            /**
-             * Property names. The method will only search for values that match
-             * regexp  within declarations of listed properties.
-             */
-            props?: string[];
-            /**
-             * Used to narrow down values and speed up the regexp search. Searching
-             * every single value with a regexp can be slow. If you pass a fast
-             * string, PostCSS will first check whether the value contains the fast
-             * string; and only if it does will PostCSS check that value against
-             * regexp. For example, instead of just checking for /\d+rem/ on all
-             * values, set fast: 'rem' to first check whether a value has the rem
-             * unit, and only if it does perform the regexp check.
-             */
-            fast?: string;
-        }, callbackOrReplaceValue: string | {
-            (substring: string, ...args: any[]): string;
-        }): this;
-        replaceValues(pattern: string | RegExp, callbackOrReplaceValue: string | {
-            (substring: string, ...args: any[]): string;
-        }): this;
-        /**
-         * Inserts new nodes to the beginning of the container.
-         * Because each node class is identifiable by unique properties, use the
-         * following shortcuts to create nodes in insert methods:
-         *     root.prepend({ name: '@charset', params: '"UTF-8"' }); // at-rule
-         *     root.prepend({ selector: 'a' });                       // rule
-         *     rule.prepend({ prop: 'color', value: 'black' });       // declaration
-         *     rule.prepend({ text: 'Comment' })                      // comment
-         * A string containing the CSS of the new element can also be used. This
-         * approach is slower than the above shortcuts.
-         *     root.prepend('a {}');
-         *     root.first.prepend('color: black; z-index: 1');
-         * @param nodes New nodes.
-         * @returns This container for chaining.
-         */
-        prepend(...nodes: (Node | object | string)[]): this;
-        /**
-         * Inserts new nodes to the end of the container.
-         * Because each node class is identifiable by unique properties, use the
-         * following shortcuts to create nodes in insert methods:
-         *     root.append({ name: '@charset', params: '"UTF-8"' }); // at-rule
-         *     root.append({ selector: 'a' });                       // rule
-         *     rule.append({ prop: 'color', value: 'black' });       // declaration
-         *     rule.append({ text: 'Comment' })                      // comment
-         * A string containing the CSS of the new element can also be used. This
-         * approach is slower than the above shortcuts.
-         *     root.append('a {}');
-         *     root.first.append('color: black; z-index: 1');
-         * @param nodes New nodes.
-         * @returns This container for chaining.
-         */
-        append(...nodes: (Node | object | string)[]): this;
-        /**
-         * Insert newNode before oldNode within the container.
-         * @param oldNode Child or child's index.
-         * @returns This container for chaining.
-         */
-        insertBefore(oldNode: ChildNode | number, newNode: ChildNode | object | string): this;
-        /**
-         * Insert newNode after oldNode within the container.
-         * @param oldNode Child or child's index.
-         * @returns This container for chaining.
-         */
-        insertAfter(oldNode: ChildNode | number, newNode: ChildNode | object | string): this;
-        /**
-         * Removes the container from its parent and cleans the parent property in the
-         * container and its children.
-         * @returns This container for chaining.
-         */
-        remove(): this;
-        /**
-         * Removes child from the container and cleans the parent properties
-         * from the node and its children.
-         * @param child Child or child's index.
-         * @returns This container for chaining.
-         */
-        removeChild(child: ChildNode | number): this;
-        /**
-         * Removes all children from the container and cleans their parent
-         * properties.
-         * @returns This container for chaining.
-         */
-        removeAll(): this;
-    }
-    interface ContainerNewProps extends NodeNewProps {
-        /**
-         * Contains the container's children.
-         */
-        nodes?: ChildNode[];
-        raws?: ContainerRaws;
-    }
-    interface ContainerRaws extends NodeRaws {
-        indent?: string;
-    }
-    interface JsonContainer extends JsonNode {
-        /**
-         * Contains the container's children.
-         */
-        nodes?: ChildNode[];
-        /**
-         * @returns The container's first child.
-         */
-        first?: ChildNode;
-        /**
-         * @returns The container's last child.
-         */
-        last?: ChildNode;
-    }
+    parser?: Parse | Syntax;
+    /**
+     * Class to generate string by AST.
+     */
+    stringifier?: Stringify | Syntax;
+  }
+  interface Syntax {
+    /**
+     * Function to generate AST by string.
+     */
+    parse?: Parse;
+    /**
+     * Class to generate string by AST.
+     */
+    stringify?: Stringify;
+  }
+  interface Parse {
+    (css?: string, opts?: postcss.SourceMapOptions): Root;
+  }
+  interface Stringify {
+    (node?: postcss.Node, builder?: any): postcss.Result | void;
+  }
+  /**
+   * A promise proxy for the result of PostCSS transformations.
+   */
+  interface LazyResult {
+    /**
+     * Processes input CSS through synchronous and asynchronous plugins.
+     * @param onRejected Called if any plugin throws an error.
+     */
+    then(onFulfilled: (result: Result) => void, onRejected?: (error: Error) => void): Function | any;
+    /**
+     * Processes input CSS through synchronous and asynchronous plugins.
+     * @param onRejected Called if any plugin throws an error.
+     */
+    catch(onRejected: (error: Error) => void): Function | any;
+    /**
+     * Alias for css property.
+     */
+    toString(): string;
+    /**
+     * Processes input CSS through synchronous plugins and converts Root to
+     * CSS string. This property will only work with synchronous plugins. If
+     * the processor contains any asynchronous plugins it will throw an error.
+     * In this case, you should use LazyResult#then() instead.
+     * @returns Result#css.
+     */
+    css: string;
+    /**
+     * Alias for css property to use when syntaxes generate non-CSS output.
+     */
+    content: string;
+    /**
+     * Processes input CSS through synchronous plugins. This property will
+     * work only with synchronous plugins. If processor contains any
+     * asynchronous plugins it will throw an error. You should use
+     * LazyResult#then() instead.
+     */
+    map: ResultMap;
+    /**
+     * Processes input CSS through synchronous plugins. This property will work
+     * only with synchronous plugins. If processor contains any asynchronous
+     * plugins it will throw an error. You should use LazyResult#then() instead.
+     */
+    root: Root;
+    /**
+     * Processes input CSS through synchronous plugins and calls Result#warnings().
+     * This property will only work with synchronous plugins. If the processor
+     * contains any asynchronous plugins it will throw an error. In this case,
+     * you should use LazyResult#then() instead.
+     */
+    warnings(): ResultMessage[];
+    /**
+     * Processes input CSS through synchronous plugins. This property will work
+     * only with synchronous plugins. If processor contains any asynchronous
+     * plugins it will throw an error. You should use LazyResult#then() instead.
+     */
+    messages: ResultMessage[];
+    /**
+     * @returns A processor used for CSS transformations.
+     */
+    processor: Processor;
+    /**
+     * @returns Options from the Processor#process(css, opts) call that produced
+     * this Result instance.
+     */
+    opts: ResultOptions;
+  }
+  /**
+   * Provides the result of the PostCSS transformations.
+   */
+  interface Result {
+    /**
+     * Alias for css property.
+     */
+    toString(): string;
+    /**
+     * Creates an instance of Warning and adds it to messages.
+     * @param message Used in the text property of the message object.
+     * @param options Properties for Message object.
+     */
+    warn(message: string, options?: WarningOptions): void;
+    /**
+     * @returns Warnings from plugins, filtered from messages.
+     */
+    warnings(): ResultMessage[];
+    /**
+     * A CSS string representing this Result's Root instance.
+     */
+    css: string;
+    /**
+     * Alias for css property to use with syntaxes that generate non-CSS output.
+     */
+    content: string;
+    /**
+     * An instance of the SourceMapGenerator class from the source-map library,
+     * representing changes to the Result's Root instance.
+     * This property will have a value only if the user does not want an inline
+     * source map. By default, PostCSS generates inline source maps, written
+     * directly into the processed CSS. The map property will be empty by default.
+     * An external source map will be generated — and assigned to map — only if
+     * the user has set the map.inline option to false, or if PostCSS was passed
+     * an external input source map.
+     */
+    map: ResultMap;
+    /**
+     * Contains the Root node after all transformations.
+     */
+    root?: Root;
+    /**
+     * Contains messages from plugins (e.g., warnings or custom messages).
+     * Add a warning using Result#warn() and get all warnings
+     * using the Result#warnings() method.
+     */
+    messages: ResultMessage[];
+    /**
+     * The Processor instance used for this transformation.
+     */
+    processor?: Processor;
+    /**
+     * Options from the Processor#process(css, opts) or Root#toResult(opts) call
+     * that produced this Result instance.
+     */
+    opts?: ResultOptions;
+  }
+  interface ResultOptions extends ProcessOptions {
+    /**
+     * The CSS node that was the source of the warning.
+     */
+    node?: postcss.Node;
+    /**
+     * Name of plugin that created this warning. Result#warn() will fill it
+     * automatically with plugin.postcssPlugin value.
+     */
+    plugin?: string;
+  }
+  interface ResultMap {
+    /**
+     * Add a single mapping from original source line and column to the generated
+     * source's line and column for this source map being created. The mapping
+     * object should have the following properties:
+     * @param mapping
+     * @returns {}
+     */
+    addMapping(mapping: mozilla.Mapping): void;
+    /**
+     * Set the source content for an original source file.
+     * @param sourceFile The URL of the original source file.
+     * @param sourceContent The content of the source file.
+     */
+    setSourceContent(sourceFile: string, sourceContent: string): void;
+    /**
+     * Applies a SourceMap for a source file to the SourceMap. Each mapping to
+     * the supplied source file is rewritten using the supplied SourceMap.
+     * Note: The resolution for the resulting mappings is the minimium of this
+     * map and the supplied map.
+     * @param sourceMapConsumer The SourceMap to be applied.
+     * @param sourceFile The filename of the source file. If omitted, sourceMapConsumer
+     * file will be used, if it exists. Otherwise an error will be thrown.
+     * @param sourceMapPath The dirname of the path to the SourceMap to be applied.
+     * If relative, it is relative to the SourceMap. This parameter is needed when
+     * the two SourceMaps aren't in the same directory, and the SourceMap to be
+     * applied contains relative source paths. If so, those relative source paths
+     * need to be rewritten relative to the SourceMap.
+     * If omitted, it is assumed that both SourceMaps are in the same directory;
+     * thus, not needing any rewriting (Supplying '.' has the same effect).
+     */
+    applySourceMap(
+        sourceMapConsumer: mozilla.SourceMapConsumer,
+        sourceFile?: string,
+        sourceMapPath?: string
+    ): void;
+    /**
+     * Renders the source map being generated to JSON.
+     */
+    toJSON: () => mozilla.RawSourceMap;
+    /**
+     * Renders the source map being generated to a string.
+     */
+    toString: () => string;
+  }
+  interface ResultMessage {
+    type: string;
+    text?: string;
+    plugin?: string;
+    browsers?: string[];
+  }
+  /**
+   * Represents a plugin warning. It can be created using Result#warn().
+   */
+  interface Warning {
+    /**
+     * @returns Error position, message.
+     */
+    toString(): string;
+    /**
+     * Contains the warning message.
+     */
+    text: string;
+    /**
+     * Contains the name of the plugin that created this warning. When you
+     * call Result#warn(), it will fill this property automatically.
+     */
+    plugin: string;
+    /**
+     * The CSS node that caused the warning.
+     */
+    node: Node;
+    /**
+     * The line in the input file with this warning's source.
+     */
+    line: number;
+    /**
+     * Column in the input file with this warning's source.
+     */
+    column: number;
+  }
+  interface WarningOptions extends ResultOptions {
+    /**
+     * A word inside a node's string that should be highlighted as source
+     * of warning.
+     */
+    word?: string;
+    /**
+     * The index inside a node's string that should be highlighted as
+     * source of warning.
+     */
+    index?: number;
+  }
+  /**
+   * The CSS parser throws this error for broken CSS.
+   */
+  interface CssSyntaxError extends InputOrigin {
+    name: string;
+    /**
+     * @returns Error position, message and source code of broken part.
+     */
+    toString(): string;
+    /**
+     * @param color Whether arrow should be colored red by terminal color codes.
+     * By default, PostCSS will use process.stdout.isTTY and
+     * process.env.NODE_DISABLE_COLORS.
+     * @returns A few lines of CSS source that caused the error. If CSS has
+     * input source map without sourceContent this method will return an empty
+     * string.
+     */
+    showSourceCode(color?: boolean): string;
+    /**
+     * Contains full error text in the GNU error format.
+     */
+    message: string;
+    /**
+     * Contains only the error description.
+     */
+    reason: string;
+    /**
+     * Contains the PostCSS plugin name if the error didn't come from the
+     * CSS parser.
+     */
+    plugin?: string;
+    input?: InputOrigin;
+  }
+  interface InputOrigin {
+    /**
+     * If parser's from option is set, contains the absolute path to the
+     * broken file. PostCSS will use the input source map to detect the
+     * original error location. If you wrote a Sass file, then compiled it
+     * to CSS and parsed it with PostCSS, PostCSS will show the original
+     * position in the Sass file. If you need the position in the PostCSS
+     * input (e.g., to debug the previous compiler), use error.input.file.
+     */
+    file?: string;
+    /**
+     * Contains the source line of the error. PostCSS will use the input
+     * source map to detect the original error location. If you wrote a Sass
+     * file, then compiled it to CSS and parsed it with PostCSS, PostCSS
+     * will show the original position in the Sass file. If you need the
+     * position in the PostCSS input (e.g., to debug the previous
+     * compiler), use error.input.line.
+     */
+    line?: number;
+    /**
+     * Contains the source column of the error. PostCSS will use input
+     * source map to detect the original error location. If you wrote a
+     * Sass file, then compiled it to CSS and parsed it with PostCSS,
+     * PostCSS will show the original position in the Sass file. If you
+     * need the position in the PostCSS input (e.g., to debug the
+     * previous compiler), use error.input.column.
+     */
+    column?: number;
+    /**
+     * Contains the source code of the broken file. PostCSS will use the
+     * input source map to detect the original error location. If you wrote
+     * a Sass file, then compiled it to CSS and parsed it with PostCSS,
+     * PostCSS will show the original position in the Sass file. If you need
+     * the position in the PostCSS input (e.g., to debug the previous
+     * compiler), use error.input.source.
+     */
+    source?: string;
+  }
+  export class PreviousMap {
+    private inline;
+    annotation: string;
+    root: string;
+    private consumerCache;
+    text: string;
+    file: string;
+    constructor(css: any, opts: any);
+    consumer(): mozilla.SourceMapConsumer;
+    withContent(): boolean;
+    startWith(string: string, start: string): boolean;
+    loadAnnotation(css: string): void;
+    decodeInline(text: string): string;
+    loadMap(
+      file: any,
+      prev: string | Function | mozilla.SourceMapConsumer | mozilla.SourceMapGenerator | mozilla.RawSourceMap
+    ): string;
+    isMap(map: any): boolean;
+  }
+  /**
+   * Represents the source CSS.
+   */
+  interface Input {
+    /**
+     * The absolute path to the CSS source file defined with the "from" option.
+     */
+    file: string;
+    /**
+     * The unique ID of the CSS source. Used if "from" option is not provided
+     * (because PostCSS does not know the file path).
+     */
+    id: string;
+    /**
+     * The CSS source identifier. Contains input.file if the user set the
+     * "from" option, or input.id if they did not.
+     */
+    from: string;
+    /**
+     * Represents the input source map passed from a compilation step before
+     * PostCSS (e.g., from the Sass compiler).
+     */
+    map: PreviousMap;
+    /**
+     * Reads the input source map.
+     * @returns A symbol position in the input source (e.g., in a Sass file
+     * that was compiled to CSS before being passed to PostCSS):
+     */
+    origin(line: number, column: number): InputOrigin;
+  }
+  type ChildNode = AtRule | Rule | Declaration | Comment;
+  type Node = Root | ChildNode;
+  interface NodeBase {
+    /**
+     * Returns the input source of the node. The property is used in source
+     * map generation. If you create a node manually
+     * (e.g., with postcss.decl() ), that node will not have a source
+     * property and will be absent from the source map. For this reason, the
+     * plugin developer should consider cloning nodes to create new ones
+     * (in which case the new node's source will reference the original,
+     * cloned node) or setting the source property manually.
+     */
+    source: NodeSource;
+    /**
+     * Contains information to generate byte-to-byte equal node string as it
+     * was in origin input.
+     */
+    raws: NodeRaws;
+    /**
+     * @returns A CSS string representing the node.
+     */
+    toString(): string;
+    /**
+     * This method produces very useful error messages. If present, an input
+     * source map will be used to get the original position of the source, even
+     * from a previous compilation step (e.g., from Sass compilation).
+     * @returns The original position of the node in the source, showing line
+     * and column numbers and also a small excerpt to facilitate debugging.
+     */
+    error(
+      /**
+       * Error description.
+       */
+      message: string, options?: NodeErrorOptions): CssSyntaxError;
+    /**
+     * Creates an instance of Warning and adds it to messages. This method is
+     * provided as a convenience wrapper for Result#warn.
+     * Note that `opts.node` is automatically passed to Result#warn for you.
+     * @param result The result that will receive the warning.
+     * @param text Warning message. It will be used in the `text` property of
+     * the message object.
+     * @param opts Properties to assign to the message object.
+     */
+    warn(result: Result, text: string, opts?: WarningOptions): void;
+    /**
+     * @returns The next child of the node's parent; or, returns undefined if
+     * the current node is the last child.
+     */
+    next(): ChildNode | void;
+    /**
+     * @returns The previous child of the node's parent; or, returns undefined
+     * if the current node is the first child.
+     */
+    prev(): ChildNode | void;
+  	/**
+  	 * Insert new node before current node to current node’s parent.
+  	 *
+  	 * Just an alias for `node.parent.insertBefore(node, newNode)`.
+  	 *
+  	 * @returns this node for method chaining.
+  	 *
+  	 * @example
+  	 * decl.before('content: ""');
+  	 */
+    before(newNode: Node | object | string | Node[]): this;
+		/**
+		 * Insert new node after current node to current node’s parent.
+		 *
+		 * Just an alias for `node.parent.insertAfter(node, newNode)`.
+		 *
+		 * @returns this node for method chaining.
+		 *
+		 * @example
+		 * decl.after('color: black');
+		 */
+    after(newNode: Node | object | string | Node[]): this;
+    /**
+     * @returns The Root instance of the node's tree.
+     */
+    root(): Root;
+    /**
+     * Removes the node from its parent and cleans the parent property in the
+     * node and its children.
+     * @returns This node for chaining.
+     */
+    remove(): this;
+    /**
+     * Inserts node(s) before the current node and removes the current node.
+     * @returns This node for chaining.
+     */
+    replaceWith(...nodes: (Node | object)[]): this;
+    /**
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
+     */
+    clone(overrides?: object): this;
+    /**
+     * Shortcut to clone the node and insert the resulting cloned node before
+     * the current node.
+     * @param overrides New Properties to override in the clone.
+     * @returns The cloned node.
+     */
+    cloneBefore(overrides?: object): this;
+    /**
+     * Shortcut to clone the node and insert the resulting cloned node after
+     * the current node.
+     * @param overrides New Properties to override in the clone.
+     * @returns The cloned node.
+     */
+    cloneAfter(overrides?: object): this;
+    /**
+     * @param prop Name or code style property.
+     * @param defaultType Name of default value. It can be easily missed if the
+     * value is the same as prop.
+     * @returns A code style property value. If the node is missing the code
+     * style property (because the node was manually built or cloned), PostCSS
+     * will try to autodetect the code style property by looking at other nodes
+     * in the tree.
+     */
+    raw(prop: string, defaultType?: string): any;
+  }
+  interface NodeNewProps {
+    source?: NodeSource;
+    raws?: NodeRaws;
+  }
+  interface NodeRaws {
+    /**
+     * The space symbols before the node. It also stores `*` and `_`
+     * symbols before the declaration (IE hack).
+     */
+    before?: string;
+    /**
+     * The space symbols after the last child of the node to the end of
+     * the node.
+     */
+    after?: string;
+    /**
+     * The symbols between the property and value for declarations,
+     * selector and "{" for rules, last parameter and "{" for at-rules.
+     */
+    between?: string;
+    /**
+     * True if last child has (optional) semicolon.
+     */
+    semicolon?: boolean;
+    /**
+     * The space between the at-rule's name and parameters.
+     */
+    afterName?: string;
+    /**
+     * The space symbols between "/*" and comment's text.
+     */
+    left?: string;
+    /**
+     * The space symbols between comment's text and "*\/".
+     */
+    right?: string;
+    /**
+     * The content of important statement, if it is not just "!important".
+     */
+    important?: string;
+  }
+  interface NodeSource {
+    input: Input;
+    /**
+     * The starting position of the node's source.
+     */
+    start?: {
+      column: number;
+      line: number;
+    };
+    /**
+     * The ending position of the node's source.
+     */
+    end?: {
+      column: number;
+      line: number;
+    };
+  }
+  interface NodeErrorOptions {
+    /**
+     * Plugin name that created this error. PostCSS will set it automatically.
+     */
+    plugin?: string;
+    /**
+     * A word inside a node's string, that should be highlighted as source
+     * of error.
+     */
+    word?: string;
+    /**
+     * An index inside a node's string that should be highlighted as source
+     * of error.
+     */
+    index?: number;
+  }
+  interface JsonNode {
+    /**
+     * Returns a string representing the node's type. Possible values are
+     * root, atrule, rule, decl or comment.
+     */
+    type?: string;
+    /**
+     * Returns the node's parent node.
+     */
+    parent?: JsonContainer;
+    /**
+     * Returns the input source of the node. The property is used in source
+     * map generation. If you create a node manually (e.g., with
+     * postcss.decl() ), that node will not have a  source  property and
+     * will be absent from the source map. For this reason, the plugin
+     * developer should consider cloning nodes to create new ones (in which
+     * case the new node's source will reference the original, cloned node)
+     * or setting the source property manually.
+     */
+    source?: NodeSource;
+    /**
+     * Contains information to generate byte-to-byte equal node string as it
+     * was in origin input.
+     */
+    raws?: NodeRaws;
+  }
+  type Container = Root | AtRule | Rule;
+  /**
+   * Containers can store any content. If you write a rule inside a rule,
+   * PostCSS will parse it.
+   */
+  interface ContainerBase extends NodeBase {
+    /**
+     * Contains the container's children.
+     */
+    nodes?: ChildNode[];
+    /**
+     * @returns The container's first child.
+     */
+    first?: ChildNode;
+    /**
+     * @returns The container's last child.
+     */
+    last?: ChildNode;
+    /**
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
+     */
+    clone(overrides?: object): this;
+    /**
+     * @param child Child of the current container.
+     * @returns The child's index within the container's "nodes" array.
+     */
+    index(child: ChildNode | number): number;
+    /**
+     * Determines whether all child nodes satisfy the specified test.
+     * @param callback A function that accepts up to three arguments. The
+     * every method calls the callback function for each node until the
+     * callback returns false, or until the end of the array.
+     * @returns True if the callback returns true for all of the container's
+     * children.
+     */
+    every(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => any, thisArg?: any): boolean;
+    /**
+     * Determines whether the specified callback returns true for any child node.
+     * @param callback A function that accepts up to three arguments. The some
+     * method calls the callback for each node until the callback returns true,
+     * or until the end of the array.
+     * @param thisArg An object to which the this keyword can refer in the
+     * callback function. If thisArg is omitted, undefined is used as the
+     * this value.
+     * @returns True if callback returns true for (at least) one of the
+     * container's children.
+     */
+    some(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean, thisArg?: any): boolean;
+    /**
+     * Iterates through the container's immediate children, calling the
+     * callback function for each child. If you need to recursively iterate
+     * through all the container's descendant nodes, use container.walk().
+     * Unlike the for {} -cycle or Array#forEach() this iterator is safe if
+     * you are mutating the array of child nodes during iteration.
+     * @param callback Iterator. Returning false will break iteration. Safe
+     * if you are mutating the array of child nodes during iteration. PostCSS
+     * will adjust the current index to match the mutations.
+     * @returns False if the callback returns false during iteration.
+     */
+    each(callback: (node: ChildNode, index: number) => any): boolean | void;
+    /**
+     * Traverses the container's descendant nodes, calling `callback` for each
+     * node. Like container.each(), this method is safe to use if you are
+     * mutating arrays during iteration. If you only need to iterate through
+     * the container's immediate children, use container.each().
+     * @param callback Iterator.
+     */
+    walk(callback: (node: ChildNode, index: number) => any): boolean | void;
+    /**
+     * Traverses the container's descendant nodes, calling `callback` for each
+     * declaration. Like container.each(), this method is safe to use if you
+     * are mutating arrays during iteration.
+     * @param propFilter Filters declarations by property name. Only those
+     * declarations whose property matches propFilter will be iterated over.
+     * @param callback Called for each declaration node within the container.
+     */
+    walkDecls(propFilter: string | RegExp, callback?: (decl: Declaration, index: number) => any): boolean | void;
+    walkDecls(callback: (decl: Declaration, index: number) => any): boolean | void;
+    /**
+     * Traverses the container's descendant nodes, calling `callback` for each
+     * at-rule. Like container.each(), this method is safe to use if you are
+     * mutating arrays during iteration.
+     * @param nameFilter Filters at-rules by name. If provided, iteration
+     * will only happen over at-rules that have matching names.
+     * @param callback Iterator called for each at-rule node within the
+     * container.
+     */
+    walkAtRules(nameFilter: string | RegExp, callback: (atRule: AtRule, index: number) => any): boolean | void;
+    walkAtRules(callback: (atRule: AtRule, index: number) => any): boolean | void;
+    /**
+     * Traverses the container's descendant nodes, calling `callback` for each
+     * rule. Like container.each(), this method is safe to use if you are
+     * mutating arrays during iteration.
+     * @param selectorFilter Filters rules by selector. If provided,
+     * iteration will only happen over rules that have matching names.
+     * @param callback Iterator called for each rule node within the
+     * container.
+     */
+    walkRules(selectorFilter: string | RegExp, callback: (atRule: Rule, index: number) => any): boolean | void;
+    walkRules(callback: (atRule: Rule, index: number) => any): boolean | void;
+    walkRules(selectorFilter: any, callback?: (atRule: Rule, index: number) => any): boolean | void;
+    /**
+     * Traverses the container's descendant nodes, calling `callback` for each
+     * comment. Like container.each(), this method is safe to use if you are
+     * mutating arrays during iteration.
+     * @param callback Iterator called for each comment node within the container.
+     */
+    walkComments(callback: (comment: Comment, indexed: number) => any): void | boolean;
+    /**
+     * Passes all declaration values within the container that match pattern
+     * through the callback, replacing those values with the returned result of
+     * callback. This method is useful if you are using a custom unit or
+     * function and need to iterate through all values.
+     * @param pattern Pattern that we need to replace.
+     * @param options Options to speed up the search.
+     * @param callbackOrReplaceValue String to replace pattern or callback
+     * that will return a new value. The callback will receive the same
+     * arguments as those passed to a function parameter of String#replace.
+     */
+    replaceValues(pattern: string | RegExp, options: {
+        /**
+         * Property names. The method will only search for values that match
+         * regexp  within declarations of listed properties.
+         */
+        props?: string[];
+        /**
+         * Used to narrow down values and speed up the regexp search. Searching
+         * every single value with a regexp can be slow. If you pass a fast
+         * string, PostCSS will first check whether the value contains the fast
+         * string; and only if it does will PostCSS check that value against
+         * regexp. For example, instead of just checking for /\d+rem/ on all
+         * values, set fast: 'rem' to first check whether a value has the rem
+         * unit, and only if it does perform the regexp check.
+         */
+        fast?: string;
+    }, callbackOrReplaceValue: string | {
+      (substring: string, ...args: any[]): string;
+    }): this;
+    replaceValues(pattern: string | RegExp, callbackOrReplaceValue: string | {
+      (substring: string, ...args: any[]): string;
+    }): this;
+    /**
+     * Inserts new nodes to the beginning of the container.
+     * Because each node class is identifiable by unique properties, use the
+     * following shortcuts to create nodes in insert methods:
+     *     root.prepend({ name: '@charset', params: '"UTF-8"' }); // at-rule
+     *     root.prepend({ selector: 'a' });                       // rule
+     *     rule.prepend({ prop: 'color', value: 'black' });       // declaration
+     *     rule.prepend({ text: 'Comment' })                      // comment
+     * A string containing the CSS of the new element can also be used. This
+     * approach is slower than the above shortcuts.
+     *     root.prepend('a {}');
+     *     root.first.prepend('color: black; z-index: 1');
+     * @param nodes New nodes.
+     * @returns This container for chaining.
+     */
+    prepend(...nodes: (Node | object | string)[]): this;
+    /**
+     * Inserts new nodes to the end of the container.
+     * Because each node class is identifiable by unique properties, use the
+     * following shortcuts to create nodes in insert methods:
+     *     root.append({ name: '@charset', params: '"UTF-8"' }); // at-rule
+     *     root.append({ selector: 'a' });                       // rule
+     *     rule.append({ prop: 'color', value: 'black' });       // declaration
+     *     rule.append({ text: 'Comment' })                      // comment
+     * A string containing the CSS of the new element can also be used. This
+     * approach is slower than the above shortcuts.
+     *     root.append('a {}');
+     *     root.first.append('color: black; z-index: 1');
+     * @param nodes New nodes.
+     * @returns This container for chaining.
+     */
+    append(...nodes: (Node | object | string)[]): this;
+    /**
+     * Insert newNode before oldNode within the container.
+     * @param oldNode Child or child's index.
+     * @returns This container for chaining.
+     */
+    insertBefore(oldNode: ChildNode | number, newNode: ChildNode | object | string): this;
+    /**
+     * Insert newNode after oldNode within the container.
+     * @param oldNode Child or child's index.
+     * @returns This container for chaining.
+     */
+    insertAfter(oldNode: ChildNode | number, newNode: ChildNode | object | string): this;
+    /**
+     * Removes the container from its parent and cleans the parent property in the
+     * container and its children.
+     * @returns This container for chaining.
+     */
+    remove(): this;
+    /**
+     * Removes child from the container and cleans the parent properties
+     * from the node and its children.
+     * @param child Child or child's index.
+     * @returns This container for chaining.
+     */
+    removeChild(child: ChildNode | number): this;
+    /**
+     * Removes all children from the container and cleans their parent
+     * properties.
+     * @returns This container for chaining.
+     */
+    removeAll(): this;
+  }
+  interface ContainerNewProps extends NodeNewProps {
+    /**
+     * Contains the container's children.
+     */
+    nodes?: ChildNode[];
+    raws?: ContainerRaws;
+  }
+  interface ContainerRaws extends NodeRaws {
+    indent?: string;
+  }
+  interface JsonContainer extends JsonNode {
+    /**
+     * Contains the container's children.
+     */
+    nodes?: ChildNode[];
+    /**
+     * @returns The container's first child.
+     */
+    first?: ChildNode;
+    /**
+     * @returns The container's last child.
+     */
+    last?: ChildNode;
+  }
     /**
      * Represents a CSS file and contains all its parsed nodes.
      */
-    interface Root extends ContainerBase {
-        type: 'root';
-        /**
-         * Inherited from Container. Should always be undefined for a Root node.
-         */
-        parent: void;
-        /**
-         * @param overrides New properties to override in the clone.
-         * @returns A clone of this node. The node and its (cloned) children will
-         * have a clean parent and code style properties.
-         */
-        clone(overrides?: object): this;
-        /**
-         * @returns A Result instance representing the root's CSS.
-         */
-        toResult(options?: {
-            /**
-             * The path where you'll put the output CSS file. You should always
-             * set "to" to generate correct source maps.
-             */
-            to?: string;
-            map?: SourceMapOptions;
-        }): Result;
-        /**
-         * Removes child from the root node, and the parent properties of node and
-         * its children.
-         * @param child Child or child's index.
-         * @returns This root node for chaining.
-         */
-        removeChild(child: ChildNode | number): this;
-    }
-    interface RootNewProps extends ContainerNewProps {
-    }
-    interface JsonRoot extends JsonContainer {
-    }
+  interface Root extends ContainerBase {
+    type: 'root';
     /**
-     * Represents an at-rule. If it's followed in the CSS by a {} block, this
-     * node will have a nodes property representing its children.
+     * Inherited from Container. Should always be undefined for a Root node.
      */
-    interface AtRule extends ContainerBase {
-        type: 'atrule';
-        /**
-         * Returns the atrule's parent node.
-         */
-        parent: Container;
-        /**
-         * The identifier that immediately follows the @.
-         */
-        name: string;
-        /**
-         * These are the values that follow the at-rule's name, but precede any {}
-         * block. The spec refers to this area as the at-rule's "prelude".
-         */
-        params: string;
-        /**
-         * @param overrides New properties to override in the clone.
-         * @returns A clone of this node. The node and its (cloned) children will
-         * have a clean parent and code style properties.
-         */
-        clone(overrides?: object): this;
-    }
-    interface AtRuleNewProps extends ContainerNewProps {
-        /**
-         * The identifier that immediately follows the @.
-         */
-        name?: string;
-        /**
-         * These are the values that follow the at-rule's name, but precede any {}
-         * block. The spec refers to this area as the at-rule's "prelude".
-         */
-        params?: string | number;
-        raws?: AtRuleRaws;
-    }
-    interface AtRuleRaws extends NodeRaws {
-        params?: string;
-    }
-    interface JsonAtRule extends JsonContainer {
-        /**
-         * The identifier that immediately follows the @.
-         */
-        name?: string;
-        /**
-         * These are the values that follow the at-rule's name, but precede any {}
-         * block. The spec refers to this area as the at-rule's "prelude".
-         */
-        params?: string;
-    }
+    parent: void;
     /**
-     * Represents a CSS rule: a selector followed by a declaration block.
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
      */
-    interface Rule extends ContainerBase {
-        type: 'rule';
-        /**
-         * Returns the rule's parent node.
-         */
-        parent: Container;
-        /**
-         * The rule's full selector. If there are multiple comma-separated selectors,
-         * the entire group will be included.
-         */
-        selector: string;
-        /**
-         * An array containing the rule's individual selectors.
-         * Groups of selectors are split at commas.
-         */
-        selectors?: string[];
-        /**
-         * @param overrides New properties to override in the clone.
-         * @returns A clone of this node. The node and its (cloned) children will
-         * have a clean parent and code style properties.
-         */
-        clone(overrides?: object): this;
-    }
-    interface RuleNewProps extends ContainerNewProps {
-        /**
-         * The rule's full selector. If there are multiple comma-separated selectors,
-         * the entire group will be included.
-         */
-        selector?: string;
-        /**
-         * An array containing the rule's individual selectors. Groups of selectors
-         * are split at commas.
-         */
-        selectors?: string[];
-        raws?: RuleRaws;
-    }
-    interface RuleRaws extends ContainerRaws {
-        /**
-        * The rule's full selector. If there are multiple comma-separated selectors,
-        * the entire group will be included.
-        */
-        selector?: string;
-    }
-    interface JsonRule extends JsonContainer {
-        /**
-         * The rule's full selector. If there are multiple comma-separated selectors,
-         * the entire group will be included.
-         */
-        selector?: string;
-        /**
-         * An array containing the rule's individual selectors.
-         * Groups of selectors are split at commas.
-         */
-        selectors?: string[];
-    }
+    clone(overrides?: object): this;
     /**
-     * Represents a CSS declaration.
+     * @returns A Result instance representing the root's CSS.
      */
-    interface Declaration extends NodeBase {
-        type: 'decl';
-        /**
-         * Returns the declaration's parent node.
-         */
-        parent: Container;
-        /**
-         * The declaration's property name.
-         */
-        prop: string;
-        /**
-         * The declaration's value. This value will be cleaned of comments. If the
-         * source value contained comments, those comments will be available in the
-         * _value.raws property. If you have not changed the value, the result of
-         * decl.toString() will include the original raws value (comments and all).
-         */
-        value: string;
-        /**
-         * True if the declaration has an !important annotation.
-         */
-        important: boolean;
-        /**
-         * @param overrides New properties to override in the clone.
-         * @returns A clone of this node. The node and its (cloned) children will
-         * have a clean parent and code style properties.
-         */
-        clone(overrides?: object): this;
-    }
-    interface DeclarationNewProps {
-        /**
-         * The declaration's property name.
-         */
-        prop?: string;
-        /**
-         * The declaration's value. This value will be cleaned of comments. If the
-         * source value contained comments, those comments will be available in the
-         * _value.raws property. If you have not changed the value, the result of
-         * decl.toString() will include the original raws value (comments and all).
-         */
-        value?: string;
-        raws?: DeclarationRaws;
-    }
-    interface DeclarationRaws extends NodeRaws {
-        /**
-         * The declaration's value. This value will be cleaned of comments.
-         * If the source value contained comments, those comments will be
-         * available in the _value.raws property. If you have not changed the value, the result of
-         * decl.toString() will include the original raws value (comments and all).
-         */
-        value?: string;
-    }
-    interface JsonDeclaration extends JsonNode {
-        /**
-         * True if the declaration has an !important annotation.
-         */
-        important?: boolean;
-    }
+    toResult(options?: {
+      /**
+       * The path where you'll put the output CSS file. You should always
+       * set "to" to generate correct source maps.
+       */
+      to?: string;
+      map?: SourceMapOptions;
+    }): Result;
     /**
-     * Represents a comment between declarations or statements (rule and at-rules).
-     * Comments inside selectors, at-rule parameters, or declaration values will
-     * be stored in the Node#raws properties.
+     * Removes child from the root node, and the parent properties of node and
+     * its children.
+     * @param child Child or child's index.
+     * @returns This root node for chaining.
      */
-    interface Comment extends NodeBase {
-        type: 'comment';
-        /**
-         * Returns the comment's parent node.
-         */
-        parent: Container;
-        /**
-         * The comment's text.
-         */
-        text: string;
-        /**
-         * @param overrides New properties to override in the clone.
-         * @returns A clone of this node. The node and its (cloned) children will
-         * have a clean parent and code style properties.
-         */
-        clone(overrides?: object): this;
-    }
-    interface CommentNewProps {
-        /**
-         * The comment's text.
-         */
-        text?: string;
-    }
-    interface JsonComment extends JsonNode {
-    }
+    removeChild(child: ChildNode | number): this;
+  }
+  interface RootNewProps extends ContainerNewProps {
+  }
+  interface JsonRoot extends JsonContainer {
+  }
+  /**
+   * Represents an at-rule. If it's followed in the CSS by a {} block, this
+   * node will have a nodes property representing its children.
+   */
+  interface AtRule extends ContainerBase {
+    type: 'atrule';
+    /**
+     * Returns the atrule's parent node.
+     */
+    parent: Container;
+    /**
+     * The identifier that immediately follows the @.
+     */
+    name: string;
+    /**
+     * These are the values that follow the at-rule's name, but precede any {}
+     * block. The spec refers to this area as the at-rule's "prelude".
+     */
+    params: string;
+    /**
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
+     */
+    clone(overrides?: object): this;
+  }
+  interface AtRuleNewProps extends ContainerNewProps {
+    /**
+     * The identifier that immediately follows the @.
+     */
+    name?: string;
+    /**
+     * These are the values that follow the at-rule's name, but precede any {}
+     * block. The spec refers to this area as the at-rule's "prelude".
+     */
+    params?: string | number;
+    raws?: AtRuleRaws;
+  }
+  interface AtRuleRaws extends NodeRaws {
+    params?: string;
+  }
+  interface JsonAtRule extends JsonContainer {
+    /**
+     * The identifier that immediately follows the @.
+     */
+    name?: string;
+    /**
+     * These are the values that follow the at-rule's name, but precede any {}
+     * block. The spec refers to this area as the at-rule's "prelude".
+     */
+    params?: string;
+  }
+  /**
+   * Represents a CSS rule: a selector followed by a declaration block.
+   */
+  interface Rule extends ContainerBase {
+    type: 'rule';
+    /**
+     * Returns the rule's parent node.
+     */
+    parent: Container;
+    /**
+     * The rule's full selector. If there are multiple comma-separated selectors,
+     * the entire group will be included.
+     */
+    selector: string;
+    /**
+     * An array containing the rule's individual selectors.
+     * Groups of selectors are split at commas.
+     */
+    selectors?: string[];
+    /**
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
+     */
+    clone(overrides?: object): this;
+  }
+  interface RuleNewProps extends ContainerNewProps {
+    /**
+     * The rule's full selector. If there are multiple comma-separated selectors,
+     * the entire group will be included.
+     */
+    selector?: string;
+    /**
+     * An array containing the rule's individual selectors. Groups of selectors
+     * are split at commas.
+     */
+    selectors?: string[];
+    raws?: RuleRaws;
+  }
+  interface RuleRaws extends ContainerRaws {
+    /**
+    * The rule's full selector. If there are multiple comma-separated selectors,
+    * the entire group will be included.
+    */
+    selector?: string;
+  }
+  interface JsonRule extends JsonContainer {
+    /**
+     * The rule's full selector. If there are multiple comma-separated selectors,
+     * the entire group will be included.
+     */
+    selector?: string;
+    /**
+     * An array containing the rule's individual selectors.
+     * Groups of selectors are split at commas.
+     */
+    selectors?: string[];
+  }
+  /**
+   * Represents a CSS declaration.
+   */
+  interface Declaration extends NodeBase {
+    type: 'decl';
+    /**
+     * Returns the declaration's parent node.
+     */
+    parent: Container;
+    /**
+     * The declaration's property name.
+     */
+    prop: string;
+    /**
+     * The declaration's value. This value will be cleaned of comments. If the
+     * source value contained comments, those comments will be available in the
+     * _value.raws property. If you have not changed the value, the result of
+     * decl.toString() will include the original raws value (comments and all).
+     */
+    value: string;
+    /**
+     * True if the declaration has an !important annotation.
+     */
+    important: boolean;
+    /**
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
+     */
+    clone(overrides?: object): this;
+  }
+  interface DeclarationNewProps {
+    /**
+     * The declaration's property name.
+     */
+    prop?: string;
+    /**
+     * The declaration's value. This value will be cleaned of comments. If the
+     * source value contained comments, those comments will be available in the
+     * _value.raws property. If you have not changed the value, the result of
+     * decl.toString() will include the original raws value (comments and all).
+     */
+    value?: string;
+    raws?: DeclarationRaws;
+  }
+  interface DeclarationRaws extends NodeRaws {
+    /**
+     * The declaration's value. This value will be cleaned of comments.
+     * If the source value contained comments, those comments will be
+     * available in the _value.raws property. If you have not changed the value, the result of
+     * decl.toString() will include the original raws value (comments and all).
+     */
+    value?: string;
+  }
+  interface JsonDeclaration extends JsonNode {
+    /**
+     * True if the declaration has an !important annotation.
+     */
+    important?: boolean;
+  }
+  /**
+   * Represents a comment between declarations or statements (rule and at-rules).
+   * Comments inside selectors, at-rule parameters, or declaration values will
+   * be stored in the Node#raws properties.
+   */
+  interface Comment extends NodeBase {
+    type: 'comment';
+    /**
+     * Returns the comment's parent node.
+     */
+    parent: Container;
+    /**
+     * The comment's text.
+     */
+    text: string;
+    /**
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
+     */
+    clone(overrides?: object): this;
+  }
+  interface CommentNewProps {
+    /**
+     * The comment's text.
+     */
+    text?: string;
+  }
+  interface JsonComment extends JsonNode {
+  }
 }
 export = postcss;