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.';
};

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.';
};

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 }}").';
};

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;
}>;

type CoreOptions = IgnoreIdentifierPatternOption &
    IgnorePrefixSelectorOption & {
        allowRestParameter: boolean;
        allowArgumentsKeyword: boolean;
        enforceParameterCount:
            | ParameterCountOptions
            | false
            | {
                  count: ParameterCountOptions;
                  ignoreLambdaExpression: boolean;
                  ignoreIIFE: boolean;
                  ignoreGettersAndSetters: boolean;
              };
    };

type Docs = {
    /**
     * Used for creating category configs and splitting the README rules list into sub-lists.
     */
    category:
        | 'Currying'
        | 'No Exceptions'
        | 'No Mutations'
        | 'No Other Paradigms'
        | 'No Statements'
        | 'Stylistic';
    recommended: 'recommended' | 'strict' | false;
    recommendedSeverity: 'error' | 'warn';
    requiresTypeChecking: boolean;
    url?: never;
};

type EslintPluginFunctional = FlatConfig.Plugin & {
    meta: typeof meta;
    rules: typeof rules;
    configs: typeof configs;
};

type FixerConfig = {
    pattern: RegExp;
    replace: string;
};

type FixerConfigRaw = {
    pattern: string;
    replace: string;
};

type FixerConfigRawMap = Partial<
    Record<
        'ReadonlyShallow' | 'ReadonlyDeep' | 'Immutable',
        FixerConfigRaw | FixerConfigRaw[] | undefined
    >
>;

type IgnoreAccessorPatternOption = Readonly<{
    ignoreAccessorPattern?: ReadonlyArray<string> | string;
}>;

type IgnoreClassesOption = Readonly<{
    ignoreClasses: boolean | 'fieldsOnly';
}>;

type IgnoreCodePatternOption = Readonly<{
    ignoreCodePattern?: ReadonlyArray<string> | string;
}>;

type IgnoreIdentifierPatternOption = Readonly<{
    ignoreIdentifierPattern?: ReadonlyArray<string> | string;
}>;

type IgnorePrefixSelectorOption = Readonly<{
    ignorePrefixSelector?: ReadonlyArray<string> | string;
}>;

type ImmutabilityRule = {
    identifiers: RegExp[];
    immutability: Immutability;
    comparator: RuleEnforcementComparator;
    fixers: FixerConfig[] | false;
    suggestions: SuggestionsConfig | false;
};

type NamedCreateRuleCustomMeta<T extends string> = NamedCreateRuleMeta<T, Docs>;

type Option = IgnoreClassesOption & {
    enforcement: RawEnforcement;
    ignoreInferredTypes: boolean;
    ignoreNamePattern?: string[] | string;
    ignoreTypePattern?: string[] | string;
};

type Options = [IgnoreIdentifierPatternOption & IgnoreCodePatternOption];

type ParameterCountOptions = 'atLeastOne' | 'exactlyOne';

type RawEnforcement =
    | Exclude<Immutability | keyof typeof Immutability, 'Unknown' | 'Mutable'>
    | 'None'
    | false
    | undefined;

type RawOptions = [RawOverridableOptions<CoreOptions>];

type RawOverridableOptions<CoreOptions> = CoreOptions & {
    overrides?: Array<{
        specifiers?: RawTypeSpecifier | RawTypeSpecifier[];
        options?: CoreOptions;
        inherit?: boolean;
        disable?: boolean;
    }>;
};

type RawTypeSpecifier = {
    name?: string | string[];
    pattern?: string | string[];
    ignoreName?: string | string[];
    ignorePattern?: string | string[];
} & TypeDeclarationSpecifier;

type Rule<
    MessageIds extends string,
    Options extends ReadonlyArray<unknown>
> = RuleModule<MessageIds, Options, Docs> & {
    meta: NamedCreateRuleCustomMeta<MessageIds>;
};

type SuggestionConfigRawMap = Partial<
    Record<
        'ReadonlyShallow' | 'ReadonlyDeep' | 'Immutable',
        SuggestionsConfigRaw[] | undefined
    >
>;

type SuggestionsConfig = FixerConfig[];

type SuggestionsConfigRaw = Array<
    FixerConfigRaw & {
        message?: string;
    }
>;