//#region ../rrweb/types/dist/index.d.ts
//#region src/index.d.ts
declare enum EventType {
  DomContentLoaded = 0,
  Load = 1,
  FullSnapshot = 2,
  IncrementalSnapshot = 3,
  Meta = 4,
  Custom = 5,
  Plugin = 6
}
type domContentLoadedEvent = {
  type: EventType.DomContentLoaded;
  data: unknown;
};
type loadedEvent = {
  type: EventType.Load;
  data: unknown;
};
type fullSnapshotEvent = {
  type: EventType.FullSnapshot;
  data: {
    node: serializedNodeWithId;
    initialOffset: {
      top: number;
      left: number;
    };
  };
};
type incrementalSnapshotEvent = {
  type: EventType.IncrementalSnapshot;
  data: incrementalData;
};
type metaEvent = {
  type: EventType.Meta;
  data: {
    href: string;
    width: number;
    height: number;
  };
};
type customEvent<T = unknown> = {
  type: EventType.Custom;
  data: {
    tag: string;
    payload: T;
  };
};
type pluginEvent<T = unknown> = {
  type: EventType.Plugin;
  data: {
    plugin: string;
    payload: T;
  };
};
declare enum IncrementalSource {
  Mutation = 0,
  MouseMove = 1,
  MouseInteraction = 2,
  Scroll = 3,
  ViewportResize = 4,
  Input = 5,
  TouchMove = 6,
  MediaInteraction = 7,
  StyleSheetRule = 8,
  CanvasMutation = 9,
  Font = 10,
  Log = 11,
  Drag = 12,
  StyleDeclaration = 13,
  Selection = 14,
  AdoptedStyleSheet = 15,
  CustomElement = 16
}
type mutationData = {
  source: IncrementalSource.Mutation;
} & mutationCallbackParam;
type mousemoveData = {
  source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag;
  positions: mousePosition[];
};
type mouseInteractionData = {
  source: IncrementalSource.MouseInteraction;
} & mouseInteractionParam;
type scrollData = {
  source: IncrementalSource.Scroll;
} & scrollPosition;
type viewportResizeData = {
  source: IncrementalSource.ViewportResize;
} & viewportResizeDimension;
type inputData = {
  source: IncrementalSource.Input;
  id: number;
} & inputValue;
type mediaInteractionData = {
  source: IncrementalSource.MediaInteraction;
} & mediaInteractionParam;
type styleSheetRuleData = {
  source: IncrementalSource.StyleSheetRule;
} & styleSheetRuleParam;
type styleDeclarationData = {
  source: IncrementalSource.StyleDeclaration;
} & styleDeclarationParam;
type canvasMutationData = {
  source: IncrementalSource.CanvasMutation;
} & canvasMutationParam;
type fontData = {
  source: IncrementalSource.Font;
} & fontParam;
type selectionData = {
  source: IncrementalSource.Selection;
} & selectionParam;
type adoptedStyleSheetData = {
  source: IncrementalSource.AdoptedStyleSheet;
} & adoptedStyleSheetParam;
type customElementData = {
  source: IncrementalSource.CustomElement;
} & customElementParam;
type incrementalData = mutationData | mousemoveData | mouseInteractionData | scrollData | viewportResizeData | inputData | mediaInteractionData | styleSheetRuleData | canvasMutationData | fontData | selectionData | styleDeclarationData | adoptedStyleSheetData | customElementData;
type eventWithoutTime = domContentLoadedEvent | loadedEvent | fullSnapshotEvent | incrementalSnapshotEvent | metaEvent | customEvent | pluginEvent;
type eventWithTime = eventWithoutTime & {
  timestamp: number;
  delay?: number;
};
interface ICrossOriginIframeMirror {
  getId(iframe: HTMLIFrameElement, remoteId: number, parentToRemoteMap?: Map<number, number>, remoteToParentMap?: Map<number, number>): number;
  getIds(iframe: HTMLIFrameElement, remoteId: number[]): number[];
  getRemoteId(iframe: HTMLIFrameElement, parentId: number, map?: Map<number, number>): number;
  getRemoteIds(iframe: HTMLIFrameElement, parentId: number[]): number[];
  reset(iframe?: HTMLIFrameElement): void;
}
type RecordPlugin<TOptions = unknown> = {
  name: string;
  observer?: (cb: (...args: Array<unknown>) => void, win: IWindow, options: TOptions) => listenerHandler;
  eventProcessor?: <TExtend>(event: eventWithTime) => eventWithTime & TExtend;
  getMirror?: (mirrors: {
    nodeMirror: IMirror<Node>;
    crossOriginIframeMirror: ICrossOriginIframeMirror;
    crossOriginIframeStyleMirror: ICrossOriginIframeMirror;
  }) => void;
  options: TOptions;
};
type textMutation = {
  id: number;
  value: string | null;
};
type styleOMValue = {
  [key: string]: styleValueWithPriority | string | false;
};
type styleValueWithPriority = [string, string];
type attributeMutation = {
  id: number;
  attributes: {
    [key: string]: string | styleOMValue | null;
  };
};
type removedNodeMutation = {
  parentId: number;
  id: number;
  isShadow?: boolean;
};
type addedNodeMutation = {
  parentId: number;
  previousId?: number | null;
  nextId: number | null;
  node: serializedNodeWithId;
};
type mutationCallbackParam = {
  texts: textMutation[];
  attributes: attributeMutation[];
  removes: removedNodeMutation[];
  adds: addedNodeMutation[];
  isAttachIframe?: true;
};
type mousePosition = {
  x: number;
  y: number;
  id: number;
  timeOffset: number;
};
declare enum MouseInteractions {
  MouseUp = 0,
  MouseDown = 1,
  Click = 2,
  ContextMenu = 3,
  DblClick = 4,
  Focus = 5,
  Blur = 6,
  TouchStart = 7,
  TouchMove_Departed = 8,
  TouchEnd = 9,
  TouchCancel = 10
}
declare enum PointerTypes {
  Mouse = 0,
  Pen = 1,
  Touch = 2
}
declare enum CanvasContext {
  "2D" = 0,
  WebGL = 1,
  WebGL2 = 2
}
type mouseInteractionParam = {
  type: MouseInteractions;
  id: number;
  x?: number;
  y?: number;
  pointerType?: PointerTypes;
};
type scrollPosition = {
  id: number;
  x: number;
  y: number;
};
type styleSheetAddRule = {
  rule: string;
  index?: number | number[];
};
type styleSheetDeleteRule = {
  index: number | number[];
};
type styleSheetRuleParam = {
  id?: number;
  styleId?: number;
  removes?: styleSheetDeleteRule[];
  adds?: styleSheetAddRule[];
  replace?: string;
  replaceSync?: string;
};
type adoptedStyleSheetParam = {
  id: number;
  styles?: {
    styleId: number;
    rules: styleSheetAddRule[];
  }[];
  styleIds: number[];
};
type styleDeclarationParam = {
  id?: number;
  styleId?: number;
  index: number[];
  set?: {
    property: string;
    value: string | null;
    priority: string | undefined;
  };
  remove?: {
    property: string;
  };
};
type canvasMutationCommand = {
  property: string;
  args: Array<unknown>;
  setter?: true;
};
type canvasMutationParam = {
  id: number;
  type: CanvasContext;
  commands: canvasMutationCommand[];
  displayWidth?: number;
  displayHeight?: number;
} | ({
  id: number;
  type: CanvasContext;
  displayWidth?: number;
  displayHeight?: number;
} & canvasMutationCommand);
type fontParam = {
  family: string;
  fontSource: string;
  buffer: boolean;
  descriptors?: FontFaceDescriptors;
};
type viewportResizeDimension = {
  width: number;
  height: number;
};
type inputValue = {
  text: string;
  isChecked: boolean;
  userTriggered?: boolean;
};
declare enum MediaInteractions {
  Play = 0,
  Pause = 1,
  Seeked = 2,
  VolumeChange = 3,
  RateChange = 4
}
type mediaInteractionParam = {
  type: MediaInteractions;
  id: number;
  currentTime?: number;
  volume?: number;
  muted?: boolean;
  loop?: boolean;
  playbackRate?: number;
};
type SelectionRange = {
  start: number;
  startOffset: number;
  end: number;
  endOffset: number;
};
type selectionParam = {
  ranges: Array<SelectionRange>;
};
type customElementParam = {
  define?: {
    name: string;
  };
};
type listenerHandler = () => void;
declare global {
  interface Window {
    FontFace: typeof FontFace;
  }
}
type IWindow = Window & typeof globalThis;
declare enum NodeType {
  Document = 0,
  DocumentType = 1,
  Element = 2,
  Text = 3,
  CDATA = 4,
  Comment = 5
}
type documentNode = {
  type: NodeType.Document;
  childNodes: serializedNodeWithId[];
  compatMode?: string;
};
type documentTypeNode = {
  type: NodeType.DocumentType;
  name: string;
  publicId: string;
  systemId: string;
};
type cssTextKeyAttr = {
  _cssText?: string;
};
type attributes = cssTextKeyAttr & {
  [key: string]: string | number | true | null;
};
type elementNode = {
  type: NodeType.Element;
  tagName: string;
  attributes: attributes;
  childNodes: serializedNodeWithId[];
  isSVG?: true;
  needBlock?: boolean;
  isCustom?: true;
};
type textNode = {
  type: NodeType.Text;
  textContent: string;
  /**
   * @deprecated styles are now always snapshotted against parent <style> element
   * style mutations can still happen via an added textNode, but they don't need this attribute for correct replay
   */
  isStyle?: true;
};
type cdataNode = {
  type: NodeType.CDATA;
  textContent: "";
};
type commentNode = {
  type: NodeType.Comment;
  textContent: string;
};
type serializedNode = (documentNode | documentTypeNode | elementNode | textNode | cdataNode | commentNode) & {
  rootId?: number;
  isShadowHost?: boolean;
  isShadow?: boolean;
};
type serializedNodeWithId = serializedNode & {
  id: number;
};
interface IMirror<TNode> {
  getId(n: TNode | undefined | null): number;
  getNode(id: number): TNode | null;
  getIds(): number[];
  getMeta(n: TNode): serializedNodeWithId | null;
  removeNodeFromMap(n: TNode): void;
  has(id: number): boolean;
  hasNode(node: TNode): boolean;
  add(n: TNode, meta: serializedNodeWithId): void;
  replace(id: number, n: TNode): void;
  reset(): void;
}
//#endregion
//#region ../rrweb/plugins/rrweb-plugin-console-record/dist/index.d.ts
//#region src/index.d.ts
type StringifyOptions = {
  stringLengthLimit?: number;
  /**
   * limit of number of keys in an object
   * if an object contains more keys than this limit, we would call its toString function directly
   */
  numOfKeysLimit: number;
  /**
   * limit number of depth in an object
   * if an object is too deep, toString process may cause browser OOM
   */
  depthOfLimit: number;
};
type LogRecordOptions = {
  level?: LogLevel[];
  lengthThreshold?: number;
  stringifyOptions?: StringifyOptions;
  logger?: Logger | "console";
};
type LogData = {
  level: LogLevel;
  trace: string[];
  payload: string[];
};
type Logger = {
  assert?: typeof console.assert;
  clear?: typeof console.clear;
  count?: typeof console.count;
  countReset?: typeof console.countReset;
  debug?: typeof console.debug;
  dir?: typeof console.dir;
  dirxml?: typeof console.dirxml;
  error?: typeof console.error;
  group?: typeof console.group;
  groupCollapsed?: typeof console.groupCollapsed;
  groupEnd?: () => void;
  info?: typeof console.info;
  log?: typeof console.log;
  table?: typeof console.table;
  time?: typeof console.time;
  timeEnd?: typeof console.timeEnd;
  timeLog?: typeof console.timeLog;
  trace?: typeof console.trace;
  warn?: typeof console.warn;
};
type LogLevel = keyof Logger;
declare const PLUGIN_NAME = "rrweb/console@1";
declare const getRecordConsolePlugin: (options?: LogRecordOptions) => RecordPlugin;
//#endregion
export { LogData, LogLevel, Logger, PLUGIN_NAME, StringifyOptions, getRecordConsolePlugin };