@hyperlane-xyz/utils/dist/eslint-rules/index.d.ts

General utilities and types for the Hyperlane network

import yamlParser from 'yaml-eslint-parser';
export declare const importRestrictionsPlugin: {
    name: string;
    rules: {
        'no-restricted-imports-from-exports': import("eslint").Rule.RuleModule;
    };
};
export declare const sortYamlArraysPlugin: {
    name: string;
    rules: {
        'sort-yaml-arrays': {
            meta: {
                type: string;
                docs: {
                    description: string;
                    category: string;
                    recommended: boolean;
                    url: null;
                };
                fixable: string;
                schema: {
                    type: string;
                    properties: {
                        arrays: {
                            type: string;
                            items: {
                                type: string;
                                properties: {
                                    path: {
                                        type: string;
                                    };
                                    sortKey: {
                                        type: string;
                                    };
                                };
                                required: string[];
                            };
                        };
                    };
                    additionalProperties: boolean;
                }[];
            };
            create(context: import("eslint").Rule.RuleContext): {
                Program(node: import("eslint").Rule.Node): void;
            };
        };
    };
};
export declare const yamlEslintConfig: ({
    plugins: {
        readonly yml: import("eslint").ESLint.Plugin;
    };
    files?: undefined;
    languageOptions?: undefined;
    rules?: undefined;
} | {
    files: string[];
    languageOptions: {
        parser: typeof import("yaml-eslint-parser");
    };
    rules: {
        "no-irregular-whitespace": "off";
        "no-unused-vars": "off";
        "spaced-comment": "off";
    };
    plugins?: undefined;
} | {
    rules: {
        "yml/block-mapping-question-indicator-newline": "error";
        "yml/block-mapping": "error";
        "yml/block-sequence-hyphen-indicator-newline": "error";
        "yml/block-sequence": "error";
        "yml/flow-mapping-curly-newline": "error";
        "yml/flow-mapping-curly-spacing": "error";
        "yml/flow-sequence-bracket-newline": "error";
        "yml/flow-sequence-bracket-spacing": "error";
        "yml/indent": "error";
        "yml/key-spacing": "error";
        "yml/no-empty-document": "error";
        "yml/no-empty-key": "error";
        "yml/no-empty-mapping-value": "error";
        "yml/no-empty-sequence-entry": "error";
        "yml/no-irregular-whitespace": "error";
        "yml/no-tab-indent": "error";
        "yml/plain-scalar": "error";
        "yml/quotes": "error";
        "yml/spaced-comment": "error";
        "yml/vue-custom-block/no-parsing-error": "error";
    };
} | {
    languageOptions: {
        parser: typeof yamlParser;
    };
    plugins: {
        hyperlane: {
            name: string;
            rules: {
                'sort-yaml-arrays': {
                    meta: {
                        type: string;
                        docs: {
                            description: string;
                            category: string;
                            recommended: boolean;
                            url: null;
                        };
                        fixable: string;
                        schema: {
                            type: string;
                            properties: {
                                arrays: {
                                    type: string;
                                    items: {
                                        type: string;
                                        properties: {
                                            path: {
                                                type: string;
                                            };
                                            sortKey: {
                                                type: string;
                                            };
                                        };
                                        required: string[];
                                    };
                                };
                            };
                            additionalProperties: boolean;
                        }[];
                    };
                    create(context: import("eslint").Rule.RuleContext): {
                        Program(node: import("eslint").Rule.Node): void;
                    };
                };
            };
        };
    };
    rules: {
        'yml/sort-keys': string[];
        'yml/flow-mapping-curly-spacing': string[];
        'yml/sort-sequence-values': (string | {
            pathPattern: string;
            order: {
                type: string;
                caseSensitive: boolean;
                natural: boolean;
            };
            minValues: number;
        })[];
        'hyperlane/sort-yaml-arrays': (string | {
            arrays: {
                path: string;
                sortKey: string;
            }[];
        })[];
    };
})[];
//# sourceMappingURL=index.d.ts.map