import { TSESLint } from "@typescript-eslint/utils";
import { ESLint, Rule } from "eslint";
//#region src/index.d.ts
declare const allRules: {
  'ban-observables': TSESLint.RuleModule<"forbidden", readonly [Record<string, string | boolean>], {
    description: "Disallow banned observable creators.";
  }, TSESLint.RuleListener>;
  'ban-operators': TSESLint.RuleModule<"forbidden", readonly [Record<string, string | boolean>], {
    description: "Disallow banned operators.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  finnish: TSESLint.RuleModule<"shouldBeFinnish" | "shouldBeFinnishProperty" | "shouldNotBeFinnish", readonly [{
    functions?: boolean;
    methods?: boolean;
    names?: Record<string, boolean>;
    parameters?: boolean;
    properties?: boolean;
    objects?: boolean;
    strict?: boolean;
    types?: Record<string, boolean>;
    variables?: boolean;
  }], {
    description: "Enforce Finnish notation.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  just: TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Require the use of `just` instead of `of`.";
  }, TSESLint.RuleListener>;
  'no-async-subscribe': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow passing `async` functions to `subscribe`.";
    recommended: "recommended";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-connectable': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow operators that return connectable observables.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-create': TSESLint.RuleModule<"forbidden" | "forbiddenSubject", readonly [], {
    description: "Disallow the static `Observable.create` and `Subject.create` functions.";
    recommended: "recommended";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-cyclic-action': TSESLint.RuleModule<"forbidden", readonly [{
    observable?: string;
  }], {
    description: "Disallow cyclic actions in effects and epics.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-explicit-generics': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow unnecessary explicit generic type arguments.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-exposed-subjects': TSESLint.RuleModule<"forbidden" | "forbiddenAllowProtected", readonly [{
    allowProtected?: boolean;
  }], {
    description: "Disallow public and protected subjects.";
    recommended: "strict";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-finnish': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow Finnish notation.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-floating-observables': TSESLint.RuleModule<"forbidden" | "forbiddenNoVoid", readonly [{
    ignoreVoid?: boolean;
  }], {
    description: "Require Observables to be handled appropriately.";
    recommended: "strict";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-ignored-default-value': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow using `firstValueFrom`, `lastValueFrom`, `first`, and `last` without specifying a default value.";
    recommended: "strict";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-ignored-error': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow calling `subscribe` without specifying an error handler.";
    recommended: "strict";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-ignored-notifier': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow observables not composed from the `repeatWhen` or `retryWhen` notifier.";
    recommended: "recommended";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-ignored-replay-buffer': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow using `ReplaySubject`, `publishReplay` or `shareReplay` without specifying the buffer size.";
    recommended: "recommended";
  }, TSESLint.RuleListener>;
  'no-ignored-subscribe': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow calling `subscribe` without specifying arguments.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-ignored-subscription': TSESLint.RuleModule<"forbidden", readonly [{
    completers?: string[];
    postCompleters?: string[];
  }], {
    description: "Disallow ignoring the subscription returned by `subscribe`.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-ignored-takewhile-value': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow ignoring the value within `takeWhile`.";
    recommended: "recommended";
  }, TSESLint.RuleListener>;
  'no-implicit-any-catch': TSESLint.RuleModule<"explicitAny" | "implicitAny" | "narrowed" | "narrowedAllowError" | "suggestExplicitUnknown" | "suggestExplicitAny" | "suggestExplicitError", readonly [{
    allowExplicitAny?: boolean;
    allowExplicitError?: boolean;
  }], {
    description: "Disallow implicit `any` error parameters in `catchError`, `subscribe`, and `tap`.";
    recommended: {
      recommended: true;
      strict: [{
        allowExplicitAny: boolean;
      }];
    };
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-index': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow importing index modules.";
    recommended: "recommended";
  }, TSESLint.RuleListener>;
  'no-internal': TSESLint.RuleModule<"forbidden" | "suggest", readonly [], {
    description: "Disallow importing internal modules.";
    recommended: "recommended";
  }, TSESLint.RuleListener>;
  'no-misused-observables': TSESLint.RuleModule<"forbiddenVoidReturnArgument" | "forbiddenVoidReturnAttribute" | "forbiddenVoidReturnInheritedMethod" | "forbiddenVoidReturnProperty" | "forbiddenVoidReturnReturnValue" | "forbiddenVoidReturnVariable" | "forbiddenSpread", readonly [{
    checksVoidReturn?: boolean | {
      arguments?: boolean;
      attributes?: boolean;
      inheritedMethods?: boolean;
      properties?: boolean;
      returns?: boolean;
      variables?: boolean;
    };
    checksSpreads?: boolean;
  }], {
    description: "Disallow Observables in places not designed to handle them.";
    recommended: "strict";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-nested-subscribe': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow calling `subscribe` within a `subscribe` callback.";
    recommended: "recommended";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-redundant-notify': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow sending redundant notifications from completed or errored observables.";
    recommended: "recommended";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-sharereplay': TSESLint.RuleModule<"forbidden" | "forbiddenWithoutConfig", readonly [{
    allowConfig?: boolean;
  }], {
    description: "Disallow unsafe `shareReplay` usage.";
    recommended: "recommended";
  }, TSESLint.RuleListener>;
  'no-sharereplay-before-takeuntil': TSESLint.RuleModule<"forbidden", readonly [{
    takeUntilAlias?: string[];
  }], {
    description: "Disallow using `shareReplay({ refCount: false })` before `takeUntil`.";
    recommended: "strict";
  }, TSESLint.RuleListener>;
  'no-subclass': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow subclassing RxJS classes.";
    recommended: "strict";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-subject-unsubscribe': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow calling the `unsubscribe` method of subjects.";
    recommended: "recommended";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-subject-value': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow accessing the `value` property of a `BehaviorSubject` instance.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-subscribe-handlers': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow passing handlers to `subscribe`.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-subscribe-in-pipe': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow calling of `subscribe` within any RxJS operator inside a `pipe`.";
    recommended: "recommended";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-topromise': TSESLint.RuleModule<"forbidden" | "suggestLastValueFromWithDefault" | "suggestLastValueFrom" | "suggestFirstValueFrom", readonly [], {
    description: "Disallow use of the `toPromise` method.";
    recommended: "recommended";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-unbound-methods': TSESLint.RuleModule<"forbidden", readonly [{
    allowTypes?: string[];
  }], {
    description: "Disallow passing unbound methods.";
    recommended: "recommended";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-unnecessary-collection': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow unnecessary usage of collection arguments with single values.";
    recommended: "strict";
    requiresTypeChecking: false;
  }, TSESLint.RuleListener>;
  'no-unsafe-catch': TSESLint.RuleModule<"forbidden", readonly [{
    observable?: string;
  }], {
    description: "Disallow unsafe `catchError` usage in effects and epics.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-unsafe-first': TSESLint.RuleModule<"forbidden", readonly [{
    observable?: string;
  }], {
    description: "Disallow unsafe `first`/`take` usage in effects and epics.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-unsafe-subject-next': TSESLint.RuleModule<"forbidden", readonly [], {
    description: "Disallow unsafe optional `next` calls.";
    recommended: "recommended";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-unsafe-switchmap': TSESLint.RuleModule<"forbidden", readonly [{
    allow?: string | string[];
    disallow?: string | string[];
    observable?: string;
  }], {
    description: "Disallow unsafe `switchMap` usage in effects and epics.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'no-unsafe-takeuntil': TSESLint.RuleModule<"forbidden", readonly [{
    alias?: string[];
    allow?: string[];
  }], {
    description: "Disallow applying operators after `takeUntil`.";
    recommended: "recommended";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'prefer-observer': TSESLint.RuleModule<"forbidden" | "suggest", readonly [{
    allowNext?: boolean;
  }], {
    description: "Disallow passing separate handlers to `subscribe` and `tap`.";
    recommended: "recommended";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'prefer-root-operators': TSESLint.RuleModule<"forbidden" | "suggest" | "forbiddenWithoutFix", readonly [], {
    description: "Disallow importing operators from `rxjs/operators`.";
    recommended: "recommended";
  }, TSESLint.RuleListener>;
  'suffix-subjects': TSESLint.RuleModule<"forbidden" | "forbiddenProperty", readonly [{
    parameters?: boolean;
    properties?: boolean;
    objects?: boolean;
    suffix?: string;
    types?: Record<string, boolean>;
    variables?: boolean;
  }], {
    description: "Enforce the use of a suffix in subject identifiers.";
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
  'throw-error': TSESLint.RuleModule<"forbidden" | "suggestErrorConstructor", readonly [{
    allowThrowingAny?: boolean;
    allowThrowingUnknown?: boolean;
  }], {
    description: "Enforce passing only `Error` values to `throwError` or `Subject.error`.";
    recommended: {
      recommended: true;
      strict: [{
        allowThrowingAny: boolean;
        allowThrowingUnknown: boolean;
      }];
    };
    requiresTypeChecking: true;
  }, TSESLint.RuleListener>;
};
declare const rxjsX: {
  configs: {
    recommended: {
      name: "rxjs-x/recommended";
      plugins: {
        'rxjs-x': ESLint.Plugin;
      };
      rules: {
        'rxjs-x/no-async-subscribe': "error";
        'rxjs-x/no-create': "error";
        'rxjs-x/no-ignored-notifier': "error";
        'rxjs-x/no-ignored-replay-buffer': "error";
        'rxjs-x/no-ignored-takewhile-value': "error";
        'rxjs-x/no-implicit-any-catch': "error";
        'rxjs-x/no-index': "error";
        'rxjs-x/no-internal': "error";
        'rxjs-x/no-nested-subscribe': "error";
        'rxjs-x/no-redundant-notify': "error";
        'rxjs-x/no-sharereplay': "error";
        'rxjs-x/no-subject-unsubscribe': "error";
        'rxjs-x/no-subscribe-in-pipe': "error";
        'rxjs-x/no-topromise': "error";
        'rxjs-x/no-unbound-methods': "error";
        'rxjs-x/no-unsafe-subject-next': "error";
        'rxjs-x/no-unsafe-takeuntil': "error";
        'rxjs-x/prefer-observer': "error";
        'rxjs-x/prefer-root-operators': "error";
        'rxjs-x/throw-error': "error";
      };
    };
    strict: {
      name: "rxjs-x/strict";
      plugins: {
        'rxjs-x': ESLint.Plugin;
      };
      rules: {
        'rxjs-x/no-async-subscribe': "error";
        'rxjs-x/no-create': "error";
        'rxjs-x/no-exposed-subjects': "error";
        'rxjs-x/no-floating-observables': "error";
        'rxjs-x/no-ignored-default-value': "error";
        'rxjs-x/no-ignored-error': "error";
        'rxjs-x/no-ignored-notifier': "error";
        'rxjs-x/no-ignored-replay-buffer': "error";
        'rxjs-x/no-ignored-takewhile-value': "error";
        'rxjs-x/no-implicit-any-catch': ["error", {
          allowExplicitAny: false;
        }];
        'rxjs-x/no-index': "error";
        'rxjs-x/no-internal': "error";
        'rxjs-x/no-misused-observables': "error";
        'rxjs-x/no-nested-subscribe': "error";
        'rxjs-x/no-redundant-notify': "error";
        'rxjs-x/no-sharereplay-before-takeuntil': "error";
        'rxjs-x/no-sharereplay': "error";
        'rxjs-x/no-subclass': "error";
        'rxjs-x/no-subject-unsubscribe': "error";
        'rxjs-x/no-subscribe-in-pipe': "error";
        'rxjs-x/no-topromise': "error";
        'rxjs-x/no-unbound-methods': "error";
        'rxjs-x/no-unnecessary-collection': "error";
        'rxjs-x/no-unsafe-subject-next': "error";
        'rxjs-x/no-unsafe-takeuntil': "error";
        'rxjs-x/prefer-observer': "error";
        'rxjs-x/prefer-root-operators': "error";
        'rxjs-x/throw-error': ["error", {
          allowThrowingAny: false;
          allowThrowingUnknown: false;
        }];
      };
    };
  };
  meta: {
    name: string;
    version: string;
    namespace: string;
  };
  /** Compatibility with `defineConfig` until https://github.com/typescript-eslint/typescript-eslint/issues/11543 is addressed. */
  rules: { [K in keyof typeof allRules]: (typeof allRules)[K] & Rule.RuleModule; };
};
//#endregion
export { rxjsX as default };