import { t as NodeCG } from "./nodecg.js";
import { r as LoggerInterface } from "./logger-interface.js";
import { ErrorObject } from "ajv";
import { EventEmitter } from "events";

//#region src/shared/typed-emitter.d.ts
interface Builtins {
  newListener(event: string, listener: EventReceiver<unknown>): void;
}
type EventMap = Record<string, any>;
type EventKey<T extends EventMap> = string & keyof T;
type EventReceiver<T> = (params: T) => void;
declare class TypedEmitter<T extends EventMap> {
  readonly _emitter: EventEmitter<[never]>;
  addListener<K extends EventKey<T & Builtins>>(eventName: K, fn: (T & Builtins)[K]): void;
  on<K extends EventKey<T & Builtins>>(eventName: K, fn: (T & Builtins)[K]): void;
  off<K extends EventKey<T & Builtins>>(eventName: K, fn: (T & Builtins)[K]): void;
  removeListener<K extends EventKey<T & Builtins>>(eventName: K, fn: (T & Builtins)[K]): void;
  emit<K extends EventKey<T & Builtins>>(eventName: K, ...params: Parameters<(T & Builtins)[K]>): void;
  once<K extends EventKey<T & Builtins>>(eventName: K, fn: (T & Builtins)[K]): void;
  setMaxListeners(max: number): void;
  listenerCount(eventName: string): number;
  listeners<K extends EventKey<T & Builtins>>(eventName: K): (T & Builtins)[K][];
}
//#endregion
//#region src/shared/replicants.shared.d.ts
type ReplicantValue<P extends NodeCG.Platform, V, O, S extends boolean = false> = P extends "server" ? S extends true ? V : O extends {
  defaultValue: infer D extends V;
} ? D : V | undefined : (O extends {
  defaultValue: infer D extends V;
} ? D : V) | undefined;
interface Events<P extends NodeCG.Platform, V, O, S extends boolean> {
  change: (newVal: ReplicantValue<P, V, O, S>, oldVal: ReplicantValue<P, V, O, S> | undefined, operations: NodeCG.Replicant.Operation<ReplicantValue<P, V, O, S>>[]) => void;
  declared: (data: {
    value: ReplicantValue<P, V, O, S>;
    revision: number;
  } | {
    value: ReplicantValue<P, V, O, S>;
    revision: number;
    schemaSum: string;
    schema: Record<string, any>;
  }) => void;
  declarationRejected: (rejectReason: string) => void;
  operations: (params: {
    name: string;
    namespace: string;
    operations: NodeCG.Replicant.Operation<ReplicantValue<P, V, O, S>>[];
    revision: number;
  }) => void;
  operationsRejected: (rejectReason: string) => void;
  fullUpdate: (data: ReplicantValue<P, V, O, S>) => void;
}
/**
 * If you're wondering why some things are prefixed with "_",
 * but not marked as protected or private, this is because our Proxy
 * trap handlers need to access these parts of the Replicant internals,
 * but don't have access to private or protected members.
 *
 * So, we code this like its 2010 and just use "_" on some public members.
 */
declare abstract class AbstractReplicant<P extends NodeCG.Platform, V, O extends NodeCG.Replicant.Options<V> = NodeCG.Replicant.Options<V>, S extends boolean = false> extends TypedEmitter<Events<P, V, O, S>> {
  name: string;
  namespace: string;
  opts: O;
  revision: number;
  log: LoggerInterface;
  schema?: Record<string, any>;
  schemaSum?: string;
  status: "undeclared" | "declared" | "declaring";
  validationErrors?: null | ErrorObject[];
  protected _value: ReplicantValue<P, V, O, S> | undefined;
  protected _oldValue: ReplicantValue<P, V, O, S> | undefined;
  protected _operationQueue: NodeCG.Replicant.Operation<ReplicantValue<P, V, O, S>>[];
  protected _pendingOperationFlush: boolean;
  constructor(name: string, namespace: string, opts?: O);
  abstract get value(): ReplicantValue<P, V, O, S>;
  abstract set value(newValue: ReplicantValue<P, V, O, S>);
  /**
   * If the operation is an array mutator method, call it on the target array with the operation arguments.
   * Else, handle it with objectPath.
   */
  _applyOperation(operation: NodeCG.Replicant.Operation<V>): boolean;
  /**
   * Used to validate the new value of a replicant.
   *
   * This is a stub that will be replaced if a Schema is available.
   */
  validate: Validator;
  /**
   * Adds an operation to the operation queue, to be flushed at the end of the current tick.
   * @private
   */
  abstract _addOperation(operation: NodeCG.Replicant.Operation<V>): void;
  /**
   * Emits all queued operations via Socket.IO & empties this._operationQueue.
   * @private
   */
  abstract _flushOperations(): void;
  /**
   * Generates a JSON Schema validator function from the `schema` property of the provided replicant.
   * @param replicant {object} - The Replicant to perform the operation on.
   * @returns {function} - The generated validator function.
   */
  protected _generateValidator(): Validator;
}
interface ValidatorOptions {
  throwOnInvalid?: boolean;
}
type Validator = (newValue: any, opts?: ValidatorOptions) => boolean;
declare const ARRAY_MUTATOR_METHODS: string[];
declare function ignoreProxy(replicant: AbstractReplicant<any, any, NodeCG.Replicant.Options<any>, any>): void;
declare function resumeProxy(replicant: AbstractReplicant<any, any, NodeCG.Replicant.Options<any>, any>): void;
declare function isIgnoringProxy(replicant: AbstractReplicant<any, any, NodeCG.Replicant.Options<any>, any>): boolean;
/**
 * Recursively Proxies an Array or Object. Does nothing to primitive values.
 * @param replicant {object} - The Replicant in which to do the work.
 * @param value {*} - The value to recursively Proxy.
 * @param path {string} - The objectPath to this value.
 * @returns {*} - The recursively Proxied value (or just `value` unchanged, if `value` is a primitive)
 * @private
 */
declare function proxyRecursive<T>(replicant: AbstractReplicant<any, any, NodeCG.Replicant.Options<any>, any>, value: T, path: string): T;
//#endregion
export { ValidatorOptions as a, proxyRecursive as c, EventKey as d, EventMap as f, Validator as i, resumeProxy as l, AbstractReplicant as n, ignoreProxy as o, TypedEmitter as p, ReplicantValue as r, isIgnoringProxy as s, ARRAY_MUTATOR_METHODS as t, Builtins as u };
//# sourceMappingURL=replicants.shared.d.ts.map