declare namespace CefBridgeDataExchange {
    interface DataExchangeResultBase {
        Success: boolean;
    }
    interface DataExchangeResultBaseFunc extends Function {
        prototype: DataExchangeResultBase;
        new (): DataExchangeResultBase;
    }
    var DataExchangeResultBase: DataExchangeResultBaseFunc;

    interface DataExchangeException extends System.Exception {
        NativeStackTrace: string | null;
    }
    interface DataExchangeExceptionFunc extends Function {
        prototype: DataExchangeException;
        new (message: string | null, nativeStackTrace: string | null): DataExchangeException;
    }
    var DataExchangeException: DataExchangeExceptionFunc;

    interface DataExchangeServiceFactory {
        Create<TInterface>(TInterface: {prototype: TInterface}): TInterface;
        Create$1<TInterface>(TInterface: {prototype: TInterface}, serviceName: string | null): TInterface;
    }
    interface DataExchangeServiceFactoryFunc extends Function {
        prototype: DataExchangeServiceFactory;
        new (dataExchangeDispatcher: CefBridgeDataExchange.ExternalDataExchangeDispatcher | null): DataExchangeServiceFactory;
    }
    var DataExchangeServiceFactory: DataExchangeServiceFactoryFunc;

    interface DevUtils {
    }
    interface DevUtilsFunc extends Function {
        prototype: DevUtils;
        new (): DevUtils;
        LogDebug(msg: any | null): void;
    }
    var DevUtils: DevUtilsFunc;

    interface IDataExchangeDispatcher {
        CefBridgeDataExchange$IDataExchangeDispatcher$InvokeService(serviceName: string | null, actionName: string | null, inputJson: string | null): string | null;
        InvokeService(serviceName: string | null, actionName: string | null, inputJson: string | null): string | null;
    }

    interface DataExchangeDataResult$1<T> extends CefBridgeDataExchange.DataExchangeResultBase {
        Data: T;
    }
    interface DataExchangeDataResult$1Func extends Function {
        <T>($T: Bridge.TypeRef<T>): {
            prototype: DataExchangeDataResult$1<T>;
            $ctor1: {
                new (data: T): DataExchangeDataResult$1<T>
            };
            new (): DataExchangeDataResult$1<T>;
            ctor: {
                new (): DataExchangeDataResult$1<T>
            };
        }
    }
    var DataExchangeDataResult$1: DataExchangeDataResult$1Func;

    interface DataExchangeErrorResult extends CefBridgeDataExchange.DataExchangeResultBase {
        Message: string | null;
        StackTrace: string | null;
    }
    interface DataExchangeErrorResultFunc extends Function {
        prototype: DataExchangeErrorResult;
        $ctor1: {
            new (message: string | null, StackTrace: string | null): DataExchangeErrorResult
        };
        new (): DataExchangeErrorResult;
        ctor: {
            new (): DataExchangeErrorResult
        };
    }
    var DataExchangeErrorResult: DataExchangeErrorResultFunc;

    interface ExternalDataExchangeDispatcher extends CefBridgeDataExchange.IDataExchangeDispatcher {
    }
    interface ExternalDataExchangeDispatcherFunc extends Function {
        prototype: ExternalDataExchangeDispatcher;
        new (): ExternalDataExchangeDispatcher;
    }
    var ExternalDataExchangeDispatcher: ExternalDataExchangeDispatcherFunc;
}