eslint-plugin-functional

const _default: any;

const configs: Readonly<{
    all: FlatConfig.Config;
    lite: FlatConfig.Config;
    recommended: FlatConfig.Config;
    strict: FlatConfig.Config;
    off: FlatConfig.Config;
    disableTypeChecked: FlatConfig.Config;
    externalVanillaRecommended: FlatConfig.Config;
    externalTypeScriptRecommended: FlatConfig.Config;
    currying: FlatConfig.Config;
    noExceptions: FlatConfig.Config;
    noMutations: FlatConfig.Config;
    noOtherParadigms: FlatConfig.Config;
    noStatements: FlatConfig.Config;
    stylistic: FlatConfig.Config;
}>;

const errorMessages: {
    readonly restParam: 'Unexpected rest parameter. Use a regular parameter of type array instead.';
    readonly arguments: 'Unexpected use of `arguments`. Use regular function arguments instead.';
    readonly paramCountAtLeastOne: 'Functions must have at least one parameter.';
    readonly paramCountExactlyOne: 'Functions must have exactly one parameter.';
};

const errorMessages$1: {
    readonly generic: 'Modifying an existing object/array is not allowed.';
    readonly object: 'Modifying properties of existing object not allowed.';
    readonly array: 'Modifying an array is not allowed.';
    readonly map: 'Modifying a map is not allowed.';
    readonly set: 'Modifying a set is not allowed.';
};

const errorMessages$10: { readonly generic: 'Function must return a value.' };

const errorMessages$11: {
    readonly generic: 'Unexpected this, use functions not classes.';
};

const errorMessages$12: {
    readonly generic: 'Unexpected throw, throwing exceptions is not functional.';
};

const errorMessages$13: {
    readonly catch: 'Unexpected try-catch, this pattern is not functional.';
    readonly finally: 'Unexpected try-finally, this pattern is not functional.';
};

const errorMessages$14: {
    readonly parameter: 'Parameter should have an immutability of at least "{{ expected }}" (actual: "{{ actual }}").';
    readonly returnType: 'Return type should have an immutability of at least "{{ expected }}" (actual: "{{ actual }}").';
    readonly variable: 'Variable should have an immutability of at least "{{ expected }}" (actual: "{{ actual }}").';
    readonly propertyImmutability: 'Property should have an immutability of at least "{{ expected }}" (actual: "{{ actual }}").';
    readonly propertyModifier: 'Property should have a readonly modifier.';
    readonly propertyModifierSuggestion: 'Add readonly modifier.';
    readonly userDefined: '{{ message }}';
};

const errorMessages$15: {
    readonly generic: 'Use a property signature instead of a method signature';
};

const errorMessages$16: {
    readonly array: 'Only readonly arrays allowed.';
    readonly implicit: 'Implicitly a mutable array. Only readonly arrays allowed.';
    readonly property: 'A readonly modifier is required.';
    readonly tuple: 'Only readonly tuples allowed.';
    readonly type: 'Only readonly types allowed.';
};

const errorMessages$17: {
    readonly generic: 'Potentially unnecessary function wrapper.';
    readonly genericSuggestion: 'Remove unnecessary function wrapper.';
};

const errorMessages$18: {
    readonly generic: "Readonly type using 'readonly' keyword is forbidden. Use 'Readonly<T>' instead.";
    readonly keyword: "Readonly type using 'Readonly<T>' is forbidden. Use 'readonly' keyword instead.";
};

const errorMessages$19: {
    readonly Less: 'This type is declare to have an immutability less than "{{ expected }}" (actual: "{{ actual }}").';
    readonly AtLeast: 'This type is declare to have an immutability of at least "{{ expected }}" (actual: "{{ actual }}").';
    readonly Exactly: 'This type is declare to have an immutability of exactly "{{ expected }}" (actual: "{{ actual }}").';
    readonly AtMost: 'This type is declare to have an immutability of at most "{{ expected }}" (actual: "{{ actual }}").';
    readonly More: 'This type is declare to have an immutability more than "{{ expected }}" (actual: "{{ actual }}").';
    readonly userDefined: '{{ message }}';
};

const errorMessages$2: {
    readonly abstract: 'Unexpected abstract class.';
    readonly extends: 'Unexpected inheritance, use composition instead.';
};

const errorMessages$3: {
    readonly generic: 'Unexpected class, use functions not classes.';
};

const errorMessages$4: {
    readonly incompleteBranch: 'Incomplete branch, every branch in a conditional statement must contain a return statement.';
    readonly incompleteIf: 'Incomplete if, it must have an else statement and every branch must contain a return statement.';
    readonly incompleteSwitch: 'Incomplete switch, it must be exhaustive or have an default case and every case must contain a return statement.';
    readonly unexpectedIf: 'Unexpected if, use a conditional expression (ternary operator) instead.';
    readonly unexpectedSwitch: 'Unexpected switch, use a conditional expression (ternary operator) instead.';
};

const errorMessages$5: {
    readonly generic: 'Using expressions to cause side-effects not allowed.';
};

const errorMessages$6: { readonly generic: 'Unexpected let, use const instead.' };

const errorMessages$7: {
    readonly generic: 'Unexpected loop, use map or reduce instead.';
};

const errorMessages$8: {
    readonly generic: 'Only the same kind of members allowed in types.';
};

const errorMessages$9: {
    readonly generic: 'Unexpected rejection, resolve an error instead.';
};

const fullName: string;

const fullName$1: string;

const fullName$10: string;

const fullName$11: string;

const fullName$12: string;

const fullName$13: string;

const fullName$14: string;

const fullName$15: string;

const fullName$16: string;

const fullName$17: string;

const fullName$18: string;

const fullName$19: string;

const fullName$2: string;

const fullName$3: string;

const fullName$4: string;

const fullName$5: string;

const fullName$6: string;

const fullName$7: string;

const fullName$8: string;

const fullName$9: string;

const meta: { readonly name: 'eslint-plugin-functional'; readonly version: string };

const name: string;

const name$1: string;

const name$10: string;

const name$11: string;

const name$12: string;

const name$13: string;

const name$14: string;

const name$15: string;

const name$16: string;

const name$17: string;

const name$18: string;

const name$19: string;

const name$2: string;

const name$3: string;

const name$4: string;

const name$5: string;

const name$6: string;

const name$7: string;

const name$8: string;

const name$9: string;

const rule: any;

const rule$1: any;

const rule$10: any;

const rule$11: any;

const rule$12: any;

const rule$13: any;

const rule$14: any;

const rule$15: any;

const rule$16: any;

const rule$17: any;

const rule$18: any;

const rule$19: any;

const rule$2: any;

const rule$3: any;

const rule$4: any;

const rule$5: any;

const rule$6: any;

const rule$7: any;

const rule$8: any;

const rule$9: any;

const ruleNameScope: string;

const rules: Readonly<{
    'functional-parameters': typeof rule;
    'immutable-data': typeof rule$1;
    'no-classes': typeof rule$3;
    'no-class-inheritance': typeof rule$2;
    'no-conditional-statements': typeof rule$4;
    'no-expression-statements': typeof rule$5;
    'no-let': typeof rule$6;
    'no-loop-statements': typeof rule$7;
    'no-mixed-types': typeof rule$8;
    'no-promise-reject': typeof rule$9;
    'no-return-void': typeof rule$10;
    'no-this-expressions': typeof rule$11;
    'no-throw-statements': typeof rule$12;
    'no-try-statements': typeof rule$13;
    'prefer-immutable-types': typeof rule$14;
    'prefer-property-signatures': typeof rule$15;
    'prefer-readonly-type': typeof rule$16;
    'prefer-tacit': typeof rule$17;
    'readonly-type': typeof rule$18;
    'type-declaration-immutability': typeof typeDeclarationImmutability.rule;
}>;