import { Response as ResponseSignatureNS } from './ResponseSignature';
import { Command as CommandNS } from './AbstractCommand';
import IAMCPCommand = CommandNS.IAMCPCommand;
import IAMCPCommandVO = CommandNS.IAMCPCommandVO;
import AbstractCommand = CommandNS.AbstractCommand;
import AbstractOrChannelOrLayerCommand = CommandNS.AbstractOrChannelOrLayerCommand;
import AbstractChannelCommand = CommandNS.AbstractChannelCommand;
import AbstractChannelOrLayerCommand = CommandNS.AbstractChannelOrLayerCommand;
import AbstractLayerWithFallbackCommand = CommandNS.AbstractLayerWithFallbackCommand;
import AbstractLayerWithCgFallbackCommand = CommandNS.AbstractLayerWithCgFallbackCommand;
import { Param as ParamNS } from './ParamSignature';
import Param = ParamNS.Param;
import { Protocol as ProtocolNS } from './ProtocolLogic';
/**
 * Internal
 */
export declare namespace AMCP {
    class CustomCommand extends AbstractCommand {
        static readonly commandString = "";
        paramProtocol: ParamNS.ParamSignature[];
    }
}
/**
 * IVideo
 */
export declare namespace AMCP {
    /**
     *
     */
    class LoadbgCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "LOADBG";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class LoadCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "LOAD";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class PlayCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "PLAY";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class PauseCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "PAUSE";
    }
    /**
     *
     */
    class ResumeCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "RESUME";
    }
    /**
     *
     */
    class StopCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "STOP";
    }
}
/**
 * IInputOutput
 */
export declare namespace AMCP {
    /**
     *
     */
    class LoadDecklinkBgCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "LOADBG";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class LoadDecklinkCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "LOAD";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class PlayDecklinkCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "PLAY";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class LoadRouteBgCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "LOADBG";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class LoadRouteCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "LOAD";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class PlayRouteCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "PLAY";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class LoadHtmlPageBgCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "LOADBG";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class LoadHtmlPageCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "LOAD";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class PlayHtmlPageCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "PLAY";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
    }
}
/**
 * ICG
 */
export declare namespace AMCP {
    /**
     *
     */
    class CGAddCommand extends AbstractLayerWithCgFallbackCommand {
        static readonly commandString = "CG";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class CGPlayCommand extends AbstractLayerWithCgFallbackCommand {
        static readonly commandString = "CG";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class CGStopCommand extends AbstractLayerWithCgFallbackCommand {
        static readonly commandString = "CG";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class CGNextCommand extends AbstractLayerWithCgFallbackCommand {
        static readonly commandString = "CG";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class CGRemoveCommand extends AbstractLayerWithCgFallbackCommand {
        static readonly commandString = "CG";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class CGClearCommand extends AbstractLayerWithCgFallbackCommand {
        static readonly commandString = "CG";
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class CGUpdateCommand extends AbstractLayerWithCgFallbackCommand {
        static readonly commandString = "CG";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     * @todo: 201 response code, parsing???????
     */
    class CGInvokeCommand extends AbstractLayerWithCgFallbackCommand {
        static readonly commandString = "CG";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
}
/**
 * IMixer
 * @todo: switch 201/202 based on mode
 */
export declare namespace AMCP {
    /**
     *
     */
    class MixerKeyerCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: ProtocolNS.Depends[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusKeyerCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     * @todo	Validata/clamp lamp number range?
     */
    class MixerChromaCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    class MixerStatusChromaCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerBlendCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: ProtocolNS.Depends[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusBlendCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerOpacityCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: ProtocolNS.Depends[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusOpacityCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerBrightnessCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: ProtocolNS.Depends[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusBrightnessCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerSaturationCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: ProtocolNS.Depends[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusSaturationCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerContrastCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: ProtocolNS.Depends[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusContrastCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     * @todo:	verify `gamma` value range
     */
    class MixerLevelsCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: (ProtocolNS.Depends | ProtocolNS.Coupled)[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusLevelsCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerFillCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: (ProtocolNS.Depends | ProtocolNS.Coupled)[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusFillCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerClipCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: (ProtocolNS.Depends | ProtocolNS.Coupled)[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusClipCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerAnchorCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: (ProtocolNS.Depends | ProtocolNS.Coupled)[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusAnchorCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerCropCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: (ProtocolNS.Depends | ProtocolNS.Coupled)[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusCropCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerRotationCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: ProtocolNS.Depends[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusRotationCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerPerspectiveCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: (ProtocolNS.Depends | ProtocolNS.Coupled)[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusPerspectiveCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerMipmapCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: ProtocolNS.Depends[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusMipmapCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerVolumeCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: ProtocolNS.Depends[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusVolumeCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerMastervolumeCommand extends AbstractChannelCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: ProtocolNS.Depends[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusMastervolumeCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStraightAlphaOutputCommand extends AbstractChannelCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: ProtocolNS.Depends[];
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerStatusStraightAlphaOutputCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "MIXER";
        static readonly protocolLogic: never[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerGridCommand extends AbstractChannelCommand {
        static readonly commandString = "MIXER";
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerCommitCommand extends AbstractChannelCommand {
        static readonly commandString = "MIXER";
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class MixerClearCommand extends AbstractChannelOrLayerCommand {
        static readonly commandString = "MIXER";
        paramProtocol: ParamNS.ParamSignature[];
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
}
/**
 * IChannel
 */
export declare namespace AMCP {
    /**
     *
     */
    class ClearCommand extends AbstractChannelOrLayerCommand {
        static readonly commandString = "CLEAR";
    }
    /**
     *
     */
    class CallCommand extends AbstractLayerWithFallbackCommand {
        static readonly commandString = "CALL";
        static readonly protocolLogic: ProtocolNS.OneOf[];
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class SwapCommand extends AbstractChannelOrLayerCommand {
        static readonly commandString = "SWAP";
        /**
         *
         */
        constructor();
    }
    /**
     *
     */
    class AddCommand extends AbstractChannelCommand {
        static readonly commandString = "ADD";
    }
    /**
     *
     */
    class AddDecklinkCommand extends AbstractChannelOrLayerCommand {
        static readonly commandString = "ADD";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class AddImageCommand extends AbstractChannelOrLayerCommand {
        static readonly commandString = "ADD";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class AddFileCommand extends AbstractChannelOrLayerCommand {
        static readonly commandString = "ADD";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class AddStreamCommand extends AbstractChannelOrLayerCommand {
        static readonly commandString = "ADD";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class RemoveCommand extends AbstractChannelOrLayerCommand {
        static readonly commandString = "REMOVE";
    }
    class RemoveDecklinkCommand extends AbstractChannelOrLayerCommand {
        static readonly commandString = "REMOVE";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class RemoveImageCommand extends AbstractChannelOrLayerCommand {
        static readonly commandString = "REMOVE";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class RemoveFileCommand extends AbstractChannelOrLayerCommand {
        static readonly commandString = "REMOVE";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class RemoveStreamCommand extends AbstractChannelOrLayerCommand {
        static readonly commandString = "REMOVE";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class PrintCommand extends AbstractChannelCommand {
        static readonly commandString = "PRINT";
    }
    /**
     *
     */
    class SetCommand extends AbstractChannelCommand {
        static readonly commandString = "SET";
    }
    /**
     *
     */
    class LockCommand extends AbstractChannelCommand {
        static readonly commandString = "LOCK";
        static readonly protocolLogic: ProtocolNS.IProtocolLogic[];
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class ChannelGridCommand extends AbstractCommand {
        static readonly commandString = "CHANNEL_GRID";
    }
    /**
     *
     */
    class GlGCCommand extends AbstractCommand {
        static readonly commandString = "GL GC";
    }
}
/**
 * IData
 */
export declare namespace AMCP {
    /**
     *
     */
    class DataStoreCommand extends AbstractCommand {
        static readonly commandString = "DATA STORE";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class DataRetrieveCommand extends AbstractCommand {
        static readonly commandString = "DATA RETRIEVE";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class DataListCommand extends AbstractCommand {
        static readonly commandString = "DATA LIST";
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class DataRemoveCommand extends AbstractCommand {
        static readonly commandString = "DATA REMOVE";
        paramProtocol: ParamNS.ParamSignature[];
    }
}
/**
 * IThumbnail
 */
export declare namespace AMCP {
    /**
     *
     */
    class ThumbnailListCommand extends AbstractCommand {
        static readonly commandString = "THUMBNAIL LIST";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class ThumbnailRetrieveCommand extends AbstractCommand {
        static readonly commandString = "THUMBNAIL RETRIEVE";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class ThumbnailGenerateCommand extends AbstractCommand {
        static readonly commandString = "THUMBNAIL GENERATE";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class ThumbnailGenerateAllCommand extends AbstractCommand {
        static readonly commandString = "THUMBNAIL GENERATE_ALL";
    }
}
/**
 * IInfo
 */
export declare namespace AMCP {
    /**
     *
     */
    class CinfCommand extends AbstractCommand {
        static readonly commandString = "CINF";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class ClsCommand extends AbstractCommand {
        static readonly commandString = "CLS";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class FlsCommand extends AbstractCommand {
        static readonly commandString = "FLS";
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class TlsCommand extends AbstractCommand {
        static readonly commandString = "TLS";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class VersionCommand extends AbstractCommand {
        static readonly commandString = "VERSION";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class InfoCommand extends AbstractOrChannelOrLayerCommand {
        static readonly commandString = "INFO";
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params?: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class InfoTemplateCommand extends AbstractCommand {
        static readonly commandString = "INFO TEMPLATE";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class InfoConfigCommand extends AbstractCommand {
        static readonly commandString = "INFO CONFIG";
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]), context?: Object);
    }
    /**
     *
     */
    class InfoPathsCommand extends AbstractCommand {
        static readonly commandString = "INFO PATHS";
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class InfoSystemCommand extends AbstractCommand {
        static readonly commandString = "INFO SYSTEM";
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class InfoServerCommand extends AbstractCommand {
        static readonly commandString = "INFO SERVER";
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class InfoQueuesCommand extends AbstractCommand {
        static readonly commandString = "INFO QUEUES";
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class InfoThreadsCommand extends AbstractCommand {
        static readonly commandString = "INFO THREADS";
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class InfoDelayCommand extends AbstractChannelOrLayerCommand {
        static readonly commandString = "INFO";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     * @todo: response validator/parser
     */
    class CGInfoCommand extends AbstractLayerWithCgFallbackCommand {
        static readonly commandString = "CG";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
        /**
         *
         */
        constructor(params: (string | Param | (string | Param)[]));
    }
    /**
     *
     */
    class GlInfoCommand extends AbstractCommand {
        static readonly commandString = "GL INFO";
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class LogLevelCommand extends AbstractCommand {
        static readonly commandString = "LOG LEVEL";
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     * @protocol	Needs either `calltrace` or `communication` parameter.
     */
    class LogCategoryCommand extends AbstractCommand {
        static readonly commandString = "LOG CATEGORY";
        static readonly protocolLogic: ProtocolNS.OneOf[];
        paramProtocol: ParamNS.ParamSignature[];
    }
    /**
     *
     */
    class DiagCommand extends AbstractCommand {
        static readonly commandString = "DIAG";
    }
    /**
     * @todo: mixed mode!!!!
     * 202/201
     */
    class HelpCommand extends AbstractCommand {
        static readonly commandString = "HELP";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class HelpProducerCommand extends AbstractCommand {
        static readonly commandString = "HELP PRODUCER";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    /**
     *
     */
    class HelpConsumerCommand extends AbstractCommand {
        static readonly commandString = "HELP CONSUMER";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
}
/**
 * IOperation
 */
export declare namespace AMCP {
    /**
     * @todo: response
     */
    class ByeCommand extends AbstractCommand {
        static readonly commandString = "BYE";
    }
    /**
     * @todo: response
     */
    class KillCommand extends AbstractCommand {
        static readonly commandString = "KILL";
    }
    /**
     * @todo: response
     */
    class RestartCommand extends AbstractCommand {
        static readonly commandString = "RESTART";
    }
    class PingCommand extends AbstractCommand {
        static readonly commandString = "PING";
    }
}
/**
 * IScheduling
 */
export declare namespace AMCP {
    class TimeCommand extends AbstractChannelCommand {
        static readonly commandString = "TIME";
        paramProtocol: ParamNS.ParamSignature[];
        responseProtocol: ResponseSignatureNS.ResponseSignature;
    }
    class ScheduleSetCommand extends AbstractCommand {
        static readonly commandString = "SCHEDULE SET";
        paramProtocol: ParamNS.ParamSignature[];
    }
    class ScheduleRemoveCommand extends AbstractCommand {
        static readonly commandString = "SCHEDULE REMOVE";
        paramProtocol: ParamNS.ParamSignature[];
    }
    class ScheduleClearCommand extends AbstractCommand {
        static readonly commandString = "SCHEDULE CLEAR";
    }
    class ScheduleListCommand extends AbstractCommand {
        static readonly commandString = "SCHEDULE LIST";
        paramProtocol: ParamNS.ParamSignature[];
    }
}
/**
 * Factory
 */
export declare namespace AMCPUtil {
    /**
     *
     */
    function deSerialize(cmd: IAMCPCommandVO, id: string): IAMCPCommand;
    /**
     *
     */
    class CasparCGSocketResponse {
        statusCode: number;
        token: string | undefined;
        responseString: string;
        items: Array<string>;
        /**
         *
         */
        constructor(responseString: string);
        /**
         *
         */
        static evaluateStatusCode(responseString: string): number;
        /**
         *
         */
        static parseToken(responseString: string): string | undefined;
    }
}