import { AllowedNames, Id, LEDDisplayInfo, hasProps, isComplexScreen, isHorizontalConnection, isLeftConnection, isSimpleScreen, isStandardScreen, isTopConnection, itAll, itFirstNotNull } from "./common.cjs";
import { getScreenLocation } from "./getScreenLocation.cjs";
import { ScanBoardConnectTypeEnum } from "@novastar/native/ScanBoardConnectType";
import { SimpleLEDDisplayInfo } from "@novastar/native/SimpleLEDDisplayInfo";
import { StandardLEDDisplayInfo } from "@novastar/native/StandardLEDDisplayInfo";
import { Duplex } from "stream";
import { API, Connection, ErrorType, Packet, Request, Session } from "@novastar/codec";
import { ScanBoardProperty } from "@novastar/native/ScanBoardProperty";
import { SenderModulationInfo, SenderModulationInfo as SenderModulationInfo$1 } from "@novastar/native/SenderModulationInfo";
import { SenderRedundancyInfo, SenderRedundancyInfo as SenderRedundancyInfo$1 } from "@novastar/native/SenderRedundancyInfo";
import { TestModeEnum } from "@novastar/native/TestMode";
import { AudioControlModeEnum, AudioControlModeEnum as AudioControlModeEnum$1 } from "@novastar/native/AudioControlMode";
import { DviSelectModeEnum, DviSelectModeEnum as DviSelectModeEnum$1 } from "@novastar/native/DviSelectMode";
import { HDEnableModeEnum, HDEnableModeEnum as HDEnableModeEnum$1 } from "@novastar/native/HDEnableMode";
import { VedioSelectModeEnum, VedioSelectModeEnum as VedioSelectModeEnum$1 } from "@novastar/native/VedioSelectMode";
import { ExtractType } from "typed-struct";
import { ZoomTypeEnum } from "@novastar/native/ZoomType";
import { GraphicsDVIPortInfo } from "@novastar/native/GraphicsDVIPortInfo";
//#region src/CustomTransform.d.ts
type PortCount = 1 | 2 | 4 | 6 | 8 | 10 | 16 | 20 | 24 | 32;
//#endregion
//#region src/DeviceInfo.d.ts
type DeviceInfo = {
  model: number;
  mac: string;
  maxPackageSize: number;
  name?: string;
  companyId: number;
  audioControl: AudioControlModeEnum$1;
  dviSelect: DviSelectModeEnum$1;
  hdEnable: HDEnableModeEnum$1;
  videoSelect: VedioSelectModeEnum$1;
  fieldRate: number;
  portCount: PortCount;
};
//#endregion
//#region src/HWStatus.d.ts
declare const HWStatus: import("typed-struct",{
  with: {
    "resolution-mode": "import"
  }
}).StructConstructor<{
  readonly tempInfoInScanCard: {
    IsValid: number;
    readonly Value: number;
  };
  readonly humidityInfoInScanCard: {
    IsValid: number;
    Value: number;
  };
  readonly voltageInfoInScanCard: {
    IsValid: number;
    readonly Value: number;
  };
  isConnectMonitorCard: boolean;
  readonly tempInfoInMonitorCard: {
    IsValid: number;
    readonly Value: number;
  };
  readonly humidityInfoInMonitorCard: {
    IsValid: number;
    Value: number;
  };
  readonly smokeWarnInfo: {
    IsValid: number;
    Value: number;
  };
  readonly fanSpeedInfoListMonitorCard: {
    IsValid: number;
    readonly Value: number;
  }[];
  readonly valtageInfoListMonitorCard: {
    IsValid: number;
    readonly Value: number;
  }[];
  readonly analogInputData: Buffer<ArrayBufferLike>;
  generalStatus: number;
  readonly moduleStatusLow: Buffer<ArrayBufferLike>;
  readonly moduleStatusHigh: Buffer<ArrayBufferLike>;
}, "HWStatus">;
type HWStatus = ExtractType<typeof HWStatus, false>;
//#endregion
//#region src/Session.d.ts
type SessionAPI = Id<API & Session>;
//#endregion
//#region src/ScreenConfigurator.d.ts
type ConsolidatedResult = null | boolean;
type BrightnessRGBV = {
  overall: number;
  red: number;
  green: number;
  blue: number;
  vRed: number;
};
type ReadFunction<T> = (SenderIndex: number, PortIndex: number, ScanIndex: number) => Promise<T>;
type WriteFunction<T> = (SenderIndex: number, PortIndex: number, ScanIndex: number, broadcast: boolean, value: T) => Promise<void>;
type ReadNames<T = number | Buffer> = AllowedNames<SessionAPI, ReadFunction<T>>;
type WriteNames<T = any> = AllowedNames<SessionAPI, WriteFunction<T>>;
type FilterHasTry<T> = { [Key in keyof T]: Key extends string ? (`try${Key}` extends keyof T ? Key : never) : never };
type ValueType<T> = T extends WriteFunction<infer V> ? V : never;
type ValueTypeFromName<N extends WriteNames> = ValueType<SessionAPI[N]>;
/**
 * Factory method for creating an asynchronous generator function to sequentially read data from
 * all receiving cards of the specified screen.
 * @template T Return type
 * @param screen Selected screen
 */
type ScreenReadAsyncGenerator<T> = (screen?: number) => AsyncGenerator<T | null>;
type ScreenWriter<T> = (value: T, screen?: number) => Promise<ConsolidatedResult>;
type Codec<I, O = I> = (value: I) => O;
/**
 *
 */
declare class ScreenConfigurator {
  #private;
  /**
   * Current session
   */
  readonly session: SessionAPI;
  /**
   * Find all connected devices in the current session/connection, read screen configurations.
   */
  reload: () => Promise<void>;
  /**
   * Save screen configurations to devices.
   */
  save: () => Promise<void>;
  ReadHWStatus: ScreenReadAsyncGenerator<ReturnType<HWStatus['toJSON']>>;
  ReadReceivingCardMCURemarks: ScreenReadAsyncGenerator<string>;
  ReadReceivingCardFPGARemarks: ScreenReadAsyncGenerator<string>;
  ReadChipType: ScreenReadAsyncGenerator<number>;
  ReadFirstChipType: (screen?: number) => Promise<number | null>;
  WriteBrightness: ScreenWriter<number>;
  ReadBrightness: ScreenReadAsyncGenerator<number>;
  ReadFirstBrightness: (screen?: number) => Promise<number | null>;
  WriteDisplayMode: ScreenWriter<TestModeEnum>;
  ReadDisplayMode: ScreenReadAsyncGenerator<number>;
  ReadFirstDisplayMode: (screen?: number) => Promise<number | null>;
  ReadGamma: ScreenReadAsyncGenerator<number>;
  ReadFirstGamma: (screen?: number) => Promise<number | null>;
  ReadRGBVBrightness: ScreenReadAsyncGenerator<BrightnessRGBV>;
  ReadFirstRGBVBrightness: (screen?: number) => Promise<BrightnessRGBV | null>;
  WriteGamma: ScreenWriter<number>;
  ReadFirstFuncCardLightSensor: (screen?: number) => Promise<number | null>;
  ReadFuncCardLightSensor: (...args: (number | undefined)[]) => Promise<number | null>;
  constructor(connection: Connection<Duplex>);
  constructor(session: SessionAPI);
  get devices(): ReadonlyArray<Readonly<DeviceInfo>>;
  get screens(): ReadonlyArray<Readonly<LEDDisplayInfo>>;
  get reduList(): ReadonlyArray<Readonly<Required<SenderRedundancyInfo$1>>>;
  get modulations(): ReadonlyArray<Readonly<Required<SenderModulationInfo$1>>>;
  reset(): void;
  /**
   * FormMain
   */
  GetScreenAllPort(screen: number, toRead?: boolean): {
    SenderIndex: number;
    PortIndex: number;
    ScanIndex: number;
    SlaveSenderIndex?: number;
    SlavePortIndex?: number;
  }[];
  WriteRGBVBrightness({
    overall,
    red,
    green,
    blue,
    vRed
  }: BrightnessRGBV, screen?: number): Promise<null | boolean>;
  FactoryReset(screen?: number): Promise<ErrorType | null>;
  SendRemoveDeadPixels(): Promise<boolean | null>;
  ReadHasDVISignalIn(device?: number): Promise<boolean | null>;
  ReadAllFuncCardLightSensor(): AsyncGenerator<number | null>;
  protected readFuncCardLightSensorImpl(senderIndex?: number, portIndex?: number, cardIndex?: number): Promise<number | null>;
  protected createReadGenerator<N extends ReadNames, T>(name: N, decoder: (res: Packet) => T): ScreenReadAsyncGenerator<T>;
  protected createWriter<N extends FilterHasTry<SessionAPI>[WriteNames], I = ValueTypeFromName<N>>(name: N, encoder?: Codec<I, ValueTypeFromName<N>>): ScreenWriter<I>;
  protected queue<A, R>(func: (this: ScreenConfigurator, ...args: A[]) => Promise<R>): (...args: A[]) => Promise<R>;
  /**
   * ScreenInfoAccessor::LoadDviScreenInfoFromHW
   * NovaLCT::FormMain::OnEquipmentChangeEvent
   */
  protected reloadImpl(): Promise<void>;
  /**
   * Nova.LCT.GigabitSystem.CommonInfoAccessor.dll
   *
   * Nova.LCT.GigabitSystem.CommonInfoAccessor::ScreenInfoAccessor::SaveDviScreenInfoToHW
   * @protected
   */
  protected saveImpl(): Promise<void>;
  protected saveRedundancy(index: number): Promise<void>;
  protected sendParametersToScanBoardGroupImpl(scanBdProperty: Readonly<ScanBoardProperty>, isSmartMode?: boolean, _isSmartNoSend?: boolean, senderIndex?: number, portIndex?: number, scanBdIndex?: number): Promise<void>;
  /**
   * Nova.LCT.GigabitSystem.LEDConfigAccessor
   *
   * Nova.LCT.GigabitSystem.HWConfigAccessor::PollingScannerParam
   *
   * ScannerPropertyAccessor::StartPollingScannerAccessor
   * @protected
   */
  protected ExecuteCheck(req: Readonly<Request>): Promise<void>;
  /**
   * Nova.LCT.GigabitSystem.CommonInfoAccessor, RedundancyInfoAccessor
   */
  private readRedundancy;
  private readModulation;
  private saveModulation;
  private readBase;
  /**
   * Nova.GigabitController.FrmSysConfigMode
   */
  private SetScreenALLWidth;
  private ReadDviScreenInfo;
  private ReadSenderScreenConfigInfo;
  private ReadData;
  private WriteData;
  private ReadSoftSpaceData;
}
//#endregion
//#region src/ScanBdRecordNoSendParams.d.ts
declare const ScanBdRecordNoSendParams: import("typed-struct",{
  with: {
    "resolution-mode": "import"
  }
}).StructConstructor<{
  size: number;
  num: 1;
  address: number;
  length: number;
  delay: number;
  pollingTime: number;
  pollingWaitTime: number;
  readonly data: Buffer<ArrayBufferLike>;
}, "ScanBdRecordNoSendParams">;
type ScanBdRecordNoSendParams = ExtractType<typeof ScanBdRecordNoSendParams, false>;
type SendParam = Pick<ScanBdRecordNoSendParams, 'address' | 'data' | 'delay' | 'pollingTime' | 'pollingWaitTime'> & {
  name?: string;
};
//#endregion
//#region src/ScreenInfo.d.ts
type DVI1600Info = {
  si: number;
  x1: number;
  y1: number;
  x2: number;
  y2: number;
  x3: number;
  y3: number;
  x4: number;
  y4: number;
};
type ScreenInfo = {
  screens: LEDDisplayInfo[];
  version: number;
  dviExtends?: DVI1600Info;
};
//#endregion
//#region src/configs.d.ts
type ScrConfig = ScreenInfo & {
  dviVersion: number;
  dviInfo: GraphicsDVIPortInfo;
};
/**
 * @param buffer
 */
declare const decodeScreenConfig: (buffer: Buffer) => ScrConfig;
/**
 * *.scr
 * @param pathname
 */
declare const loadScreenConfig: (pathname: string) => ScrConfig;
//#endregion
//#region src/getCabinetPosition.d.ts
type CabinetPosition = {
  column: number;
  row: number;
  left: number;
  top: number;
  sender: number;
  port: number;
  card: number;
};
declare const getCabinetPosition: (screen: LEDDisplayInfo, sender: number, port: number, card: number) => CabinetPosition | null;
//#endregion
//#region src/NcpConfig.d.ts
interface NcpConfigInfo {
  packageName: string;
  packageSize: number;
  compressedSize: number;
  encrypted: boolean;
}
interface NcpCabinetBaseInfo {
  name?: string;
  manufacture?: string;
  cardModel?: string;
  firmwareVersion?: string;
  icType?: string;
  refreshRate?: number;
  scanType?: number;
  [key: string]: unknown;
}
interface NcpCabinetConfig {
  name: string;
  revision?: number;
  firmwareFile?: string;
  firmware?: NcpReceivingCardFirmware;
  baseInfo: NcpCabinetBaseInfo;
  /** Original RCCB binary accepted by Taurus ScreenService. */
  binary: Buffer;
  /** Register writes extracted from the cabinet RCCB binary. */
  parameters: SendParam[];
}
interface ReceivingCardFirmwareFile {
  label: string;
  filename: string;
  version?: string;
  remark?: string;
}
interface ReceivingCardFirmwareInfo {
  filename: string;
  version?: string;
  model?: string;
  modelId: number;
  files: ReceivingCardFirmwareFile[];
}
interface NcpReceivingCardFirmware {
  data: Buffer;
  info: ReceivingCardFirmwareInfo;
}
interface NcpConfig {
  formatVersion?: number;
  packageName?: string;
  cabinets: NcpCabinetConfig[];
}
/** Inspect and validate a NovaStar receiving-card firmware ZIP archive. */
declare const decodeReceivingCardFirmware: (data: Buffer, filename?: string) => Promise<ReceivingCardFirmwareInfo>;
/** Inspect an NCP container without decrypting it. */
declare const inspectNcpConfig: (buffer: Buffer) => NcpConfigInfo;
/** Decode a current NovaLCT NCP package into cabinet register-write sequences. */
declare const decodeNcpConfig: (buffer: Buffer) => Promise<NcpConfig>;
/**
 * Create a new encrypted NCP package with reordered DATA group blocks in one cabinet. The input
 * buffer is not changed. All other cabinet, firmware, mode and manifest files are retained.
 */
declare const rewriteNcpDataGroupOrder: (buffer: Buffer, cabinetIndex: number, order: readonly number[]) => Promise<Buffer>;
declare const loadNcpConfigInfo: (pathname: string) => NcpConfigInfo;
declare const loadNcpConfig: (pathname: string) => Promise<NcpConfig>;
declare const saveNcpDataGroupOrder: (sourcePath: string, destinationPath: string, cabinetIndex: number, order: readonly number[]) => Promise<void>;
//#endregion
//#region src/NcpDataGroupMapping.d.ts
interface NcpDataGroupBlock {
  /** Zero-based block number in physical DATA order. */
  index: number;
  /** Zero-based first physical DATA group occupied by this block. */
  physicalStart: number;
  /** Zero-based last physical DATA group occupied by this block. */
  physicalEnd: number;
  /** Logical groups routed to the consecutive physical DATA groups. */
  logicalGroups: number[];
}
interface NcpDataGroupMapping {
  address: number;
  capacity: number;
  blocks: NcpDataGroupBlock[];
}
/**
 * Decode the irregular-cabinet physical-to-logical DATA group routing table from an NCP cabinet.
 * Empty physical positions are encoded as 0xff. Consecutive assigned positions form one block.
 */
declare const getNcpDataGroupMapping: (cabinet: Pick<NcpCabinetConfig, "parameters">) => NcpDataGroupMapping | undefined;
/**
 * Return an NCP cabinet copy whose physical DATA blocks have been assigned to screen positions in
 * the requested order. Both the output-to-logical-group assignments and the corresponding physical
 * columns of the scanner run-line table are moved. The original decoded cabinet and its RCCB binary
 * are left unchanged; the returned parameter list is ready to send.
 */
declare const reorderNcpDataGroupBlocks: (cabinet: NcpCabinetConfig, order: readonly number[]) => NcpCabinetConfig;
//#endregion
//#region src/NcpSender.d.ts
interface NcpTarget {
  sender: number;
  port: number;
  receivingCard: number;
}
interface NcpSendProgress {
  completed: number;
  total: number;
  completedBytes: number;
  totalBytes: number;
  address: number;
  name?: string;
}
interface NcpSendOptions {
  allReceivingCards?: boolean;
  readinessTargets?: readonly NcpTarget[];
  onProgress?: (progress: NcpSendProgress) => void;
}
/**
 * Send one decoded NCP cabinet configuration. The target is used for addressed writes and as the
 * default readiness-polling address; `allReceivingCards` switches parameter writes to broadcast.
 * Firmware and multi-mode files embedded in the NCP are intentionally not flashed.
 */
declare const sendNcpCabinetConfig: (session: SessionAPI, cabinet: NcpCabinetConfig, target: NcpTarget, options?: NcpSendOptions) => Promise<void>;
//#endregion
export { type API, AudioControlModeEnum, type BrightnessRGBV, type CabinetPosition, type DeviceInfo, DviSelectModeEnum, HDEnableModeEnum, HWStatus, type LEDDisplayInfo, type NcpCabinetBaseInfo, type NcpCabinetConfig, type NcpConfig, type NcpConfigInfo, type NcpDataGroupBlock, type NcpDataGroupMapping, type NcpReceivingCardFirmware, type NcpSendOptions, type NcpSendProgress, type NcpTarget, type PortCount, type ReceivingCardFirmwareFile, type ReceivingCardFirmwareInfo, ScanBoardConnectTypeEnum, type ScrConfig, ScreenConfigurator, type ScreenReadAsyncGenerator, type ScreenWriter, type SenderModulationInfo, type SenderRedundancyInfo, type SessionAPI, SimpleLEDDisplayInfo, StandardLEDDisplayInfo, VedioSelectModeEnum, ZoomTypeEnum, decodeNcpConfig, decodeReceivingCardFirmware, decodeScreenConfig, getCabinetPosition, getNcpDataGroupMapping, getScreenLocation, hasProps, inspectNcpConfig, isComplexScreen, isHorizontalConnection, isLeftConnection, isSimpleScreen, isStandardScreen, isTopConnection, itAll, itFirstNotNull, loadNcpConfig, loadNcpConfigInfo, loadScreenConfig, reorderNcpDataGroupBlocks, rewriteNcpDataGroupOrder, saveNcpDataGroupOrder, sendNcpCabinetConfig };
//# sourceMappingURL=index.d.cts.map