import * as postcss from 'postcss';
import type { AtRuleRaws } from 'postcss/lib/at-rule';
import { ArgumentList, ArgumentListProps } from '../argument-list';
import { ParameterList, ParameterListProps } from '../parameter-list';
import { RawWithValue } from '../raw-with-value';
import * as sassInternal from '../sass-internal';
import { ChildNode, ContainerProps, NewNode, Statement, StatementWithChildren } from '.';
import { _AtRule } from './at-rule-internal';
/**
 * The set of raws supported by {@link IncludeRule}.
 *
 * @category Statement
 */
export interface IncludeRuleRaws extends Omit<AtRuleRaws, 'params'> {
    /**
     * The mixin's namespace.
     *
     * This may be different than {@link IncludeRule.namespace} if the name
     * contains escape codes.
     */
    namespace?: RawWithValue<string>;
    /**
     * The mixin's name.
     *
     * This may be different than {@link IncludeRule.includeName} if the name
     * contains escape codes or underscores.
     */
    includeName?: RawWithValue<string>;
    /**
     * Whether to include an empty argument list. If the argument list isn't
     * empty, this is ignored.
     */
    showArguments?: boolean;
    /**
     * The whitespace between the argument list and the `using` identifier.
     *
     * This is ignored if {@link IncludeRule.usingParameters} isn't defined.
     */
    afterArguments?: string;
    /**
     * The whitespace between the `using` identifier and the using parameters.
     *
     * This is ignored if {@link IncludeRule.usingParameters} isn't defined.
     */
    afterUsing?: string;
}
/**
 * The initializer properties for {@link IncludeRule}.
 *
 * @category Statement
 */
export type IncludeRuleProps = ContainerProps & {
    raws?: IncludeRuleRaws;
    includeName: string;
    arguments?: ArgumentList | ArgumentListProps;
    using?: ParameterList | ParameterListProps;
};
/**
 * An `@include` rule. Extends [`postcss.AtRule`].
 *
 * [`postcss.AtRule`]: https://postcss.org/api/#atrule
 *
 * @category Statement
 */
export declare class IncludeRule extends _AtRule<Partial<IncludeRuleProps>> implements Statement {
    readonly sassType: "include-rule";
    parent: StatementWithChildren | undefined;
    raws: IncludeRuleRaws;
    nodes: ChildNode[] | undefined;
    /**
     * The mixin's namespace.
     *
     * This is the parsed value, with escapes resolved to the characters they
     * represent.
     */
    namespace: string | undefined;
    /**
     * The name of the mixin being included.
     *
     * This is the parsed and normalized value, with underscores converted to
     * hyphens and escapes resolved to the characters they represent.
     */
    includeName: string;
    /** The arguments to pass to the mixin. */
    get arguments(): ArgumentList;
    set arguments(args: ArgumentList | ArgumentListProps | undefined);
    private _arguments;
    /** The parameters that the `@content` block takes. */
    get using(): ParameterList | undefined;
    set using(parameters: ParameterList | ParameterListProps | undefined);
    private _using?;
    get name(): string;
    set name(value: string);
    get params(): string;
    set params(value: string | number | undefined);
    constructor(defaults: IncludeRuleProps);
    /** @hidden */
    constructor(_: undefined, inner: sassInternal.IncludeRule);
    clone(overrides?: Partial<IncludeRuleProps>): this;
    toJSON(): object;
    /** @hidden */
    toJSON(_: string, inputs: Map<postcss.Input, number>): object;
    /** @hidden */
    toString(stringifier?: postcss.Stringifier | postcss.Syntax): string;
    /** @hidden */
    get nonStatementChildren(): ReadonlyArray<ArgumentList | ParameterList>;
    /** @hidden */
    normalize(node: NewNode, sample?: postcss.Node): ChildNode[];
}