import { Options } from 'cssnano';
import { CustomAtRules, TransformOptions } from 'lightningcss';
import { Node, AcceptedPlugin, PluginCreator } from 'postcss';
import { Config } from 'postcss-load-config';
import { Environment } from '@visulima/packem-share/types';
import { StringOptions as StringOptions$1 } from 'sass';
import { StringOptions } from 'sass-embedded';
import { RenderOptions } from 'stylus';
import { RollupLogger } from '@visulima/packem-share/utils';
import { PluginContext, CustomPluginOptions } from 'rollup';
import { RawSourceMap } from 'source-map-js';
type LESSLoaderOptions = Less.Options;
type ImportResolve = (url: string, basedir: string, extensions: string[], atRule: Node) => Promise<string> | string;
interface ImportOptions {
  alias: Record<string, string>;
  debug?: boolean;
  extensions: string[];
  filter?: (id: string) => boolean;
  load: (filename: string, importOptions: ImportOptions) => Promise<string> | string;
  plugins: AcceptedPlugin[];
  resolve: ImportResolve;
  skipDuplicates?: boolean;
  warnOnEmpty?: boolean;
}
interface ModulesOptions {
  exportGlobals?: boolean;
  failOnWrongOrder?: boolean;
  generateScopedName?: string | ((name: string, file: string, css: string) => string);
  include?: AutoModules;
  mode?: "global" | "local" | "pure";
}
interface UrlFile {
  from: string;
  source: Uint8Array;
  urlQuery?: string;
}
type UrlResolve = (inputUrl: string, baseDirectories: string[]) => Promise<UrlFile>;
interface UrlOptions {
  alias?: Record<string, string>;
  assetDir?: string | ((original: string, resolved: string, file: string) => string);
  hash?: boolean | string;
  inline?: boolean;
  publicPath?: string | ((original: string, resolved: string, file: string) => string);
  resolve?: UrlResolve;
}
type SassLoaderContext = {
  environment: Environment;
  resourcePath: string;
  rootContext: string;
};
type SassLoaderOptions = (Omit<StringOptions<"sync">, "charset" | "indentedSyntax"> | Omit<StringOptions$1<"sync">, "charset" | "indentedSyntax">) & {
  additionalData: string | ((content: string | Buffer, loaderContext: SassLoaderContext) => Promise<string>) | ((content: string | Buffer, loaderContext: SassLoaderContext) => string);
  implementation?: "sass-embedded" | "sass";
  warnRuleAsWarning?: boolean;
};
type StylusLoaderContext = {
  environment: Environment;
  resourcePath: string;
  rootContext: string;
};
type StylusPlugin = string | ((renderer: unknown) => void);
type StylusDefinition = [string, unknown] | [string, unknown, boolean];
type StylusLoaderOptions = RenderOptions & {
  additionalData?: string | ((content: string, loaderContext: StylusLoaderContext) => Promise<string> | string);
  define?: Record<string, unknown> | StylusDefinition[];
  disableCache?: boolean;
  hoistAtrules?: boolean;
  implementation?: string | ((code: string, options?: unknown) => unknown);
  import?: string[];
  include?: string[];
  includeCSS?: boolean;
  lineNumbers?: boolean;
  use?: StylusPlugin[];
};
interface Extracted {
  css: string;
  id: string;
  map?: string;
}
interface Loader<T = Record<string, unknown>> {
  alwaysProcess?: boolean;
  name: string;
  process: (this: LoaderContext<T>, payload: Payload) => Payload | Promise<Payload>;
  test?: RegExp | ((file: string) => boolean);
}
interface LoaderContext<T = Record<string, unknown>> {
  readonly alias?: Record<string, string>;
  readonly assets: Map<string, Uint8Array>;
  readonly autoModules: InternalStyleOptions["autoModules"];
  readonly browserTargets: string[];
  readonly cwd?: string;
  readonly debug?: boolean;
  readonly deps: Set<string>;
  readonly dts: InternalStyleOptions["dts"];
  readonly emit: InternalStyleOptions["emit"];
  readonly environment: Environment;
  readonly extensions: InternalStyleOptions["extensions"];
  readonly extract: InternalStyleOptions["extract"];
  readonly id: string;
  readonly inject: InternalStyleOptions["inject"];
  readonly inline: InternalStyleOptions["inline"];
  readonly logger: RollupLogger;
  readonly namedExports: InternalStyleOptions["namedExports"];
  readonly options: T;
  readonly plugin: PluginContext;
  readonly sourceDir?: string;
  readonly sourceMap: false | (SourceMapOptions & {
    inline: boolean;
  });
  readonly useSourcemap: boolean;
}
interface Payload {
  code: string;
  dts?: string;
  extracted?: Extracted;
  map?: string;
  meta?: CustomPluginOptions;
}
interface SourceMapOptions {
  content?: boolean;
  transform?: (map: RawSourceMap, name?: string) => void;
}
type MinifierContext = {
  readonly browserTargets: string[];
  readonly logger: RollupLogger;
};
interface Minifier<Options = Record<string, any>> {
  handler: (this: MinifierContext, data: ExtractedData, sourceMap: LoaderContext["sourceMap"], options: Options) => Promise<ExtractedData>;
  name: string;
}
type AutoModules = RegExp | boolean | ((id: string) => boolean);
interface ExtractedData {
  css: string;
  map?: string;
  name: string;
}
interface InjectOptions {
  attributes?: Record<string, string>;
  container?: string;
  method?: string;
  package?: string;
  prepend?: boolean;
  singleTag?: boolean;
  treeshakeable?: boolean;
}
interface InternalStyleOptions extends StyleOptions {
  emit: boolean;
  extensions: NonNullable<StyleOptions["extensions"]>;
  extract: boolean | string;
  inject: InjectOptions | boolean | ((varname: string, id: string, output: string[]) => string);
  inline: boolean;
}
type LightningCSSOptions = Omit<TransformOptions<CustomAtRules>, "code" | "cssModules" | "filename" | "minify" | "targets"> & {
  modules?: TransformOptions<CustomAtRules>["cssModules"] & {
    include?: AutoModules;
  };
};
interface PostCSSConfigLoaderOptions {
  ctx?: Record<string, unknown>;
  path?: string;
}
interface PostCSSOptions {
  config?: PostCSSConfigLoaderOptions | false;
  import?: Partial<ImportOptions> | false;
  modules?: ModulesOptions | boolean;
  parser?: NonNullable<Config["parser"]> | string;
  plugins?: (AcceptedPlugin | string | [PluginCreator<unknown> | string, Record<string, unknown>] | [PluginCreator<unknown> | string] | null | undefined)[] | Record<string, unknown>;
  stringifier?: NonNullable<Config["stringifier"]> | string;
  syntax?: NonNullable<Config["syntax"]> | string;
  to?: NonNullable<Config["to"]>;
  url?: Partial<UrlOptions> | false;
}
interface StyleOptions {
  alias?: Record<string, string>;
  autoModules?: AutoModules;
  cssnano?: Options;
  dts?: boolean;
  exclude?: ReadonlyArray<RegExp | string> | RegExp | string;
  extensions?: string[];
  include?: ReadonlyArray<RegExp | string> | RegExp | string;
  less?: LESSLoaderOptions;
  lightningcss?: LightningCSSOptions;
  loaders?: Loader[];
  minifier?: Minifier;
  mode?: "emit" | "extract" | "inject" | "inline" | ["extract", string] | ["inject", InjectOptions | ((varname: string, id: string) => string)];
  namedExports?: boolean | ((name: string) => string);
  onExtract?: (data: ExtractedData) => boolean;
  onImport?: (code: string, id: string) => void;
  postcss?: PostCSSOptions;
  sass?: SassLoaderOptions;
  sourceMap?: boolean | "inline" | [boolean | "inline", SourceMapOptions] | [boolean | "inline"];
  stylus?: StylusLoaderOptions;
}
export { AutoModules as A, ExtractedData as E, InternalStyleOptions as I, LESSLoaderOptions as L, Minifier as M, PostCSSConfigLoaderOptions as P, SassLoaderOptions as S, Loader as a, LightningCSSOptions as b, SassLoaderContext as c, StylusLoaderOptions as d, StylusDefinition as e, StylusLoaderContext as f, StylusPlugin as g, StyleOptions as h, InjectOptions as i, PostCSSOptions as j, Extracted as k, LoaderContext as l };