/**
 * Copyright (c) 2010-2020 Contributors to the openHAB project
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0
 *
 * SPDX-License-Identifier: EPL-2.0
 */

 /* ***********************************************************
 * This file was automatically generated on 2022-01-03.      *
 *                                                           *
 * openHAB Bindings Version 2.0.0                            *
 *                                                           *
 * If you have a bugfix for this file and want to commit it, *
 * please fix the bug in the generator. You can find a link  *
 * to the generators git repository on tinkerforge.com       *
 *************************************************************/

package org.openhab.binding.tinkerforge.internal.device;

import java.net.URI;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import org.eclipse.smarthome.config.core.Configuration;
import org.eclipse.smarthome.config.core.ConfigDescription;
import org.eclipse.smarthome.config.core.ConfigDescriptionBuilder;
import org.eclipse.smarthome.config.core.ConfigDescriptionParameter.Type;
import org.eclipse.smarthome.config.core.ConfigDescriptionParameterBuilder;
import org.eclipse.smarthome.config.core.ConfigDescriptionParameterGroup;
import org.eclipse.smarthome.config.core.ParameterOption;
import org.eclipse.smarthome.core.types.State;
import org.eclipse.smarthome.core.types.StateOption;
import org.eclipse.smarthome.core.types.Command;
import org.eclipse.smarthome.core.types.CommandDescriptionBuilder;
import org.eclipse.smarthome.core.types.CommandOption;
import org.eclipse.smarthome.core.thing.ChannelUID;
import org.eclipse.smarthome.core.thing.ThingStatus;
import org.eclipse.smarthome.core.thing.ThingTypeUID;
import org.eclipse.smarthome.core.thing.binding.BaseThingHandler;
import org.eclipse.smarthome.core.thing.type.ChannelDefinitionBuilder;
import org.eclipse.smarthome.core.thing.type.ChannelType;
import org.eclipse.smarthome.core.thing.type.ChannelTypeBuilder;
import org.eclipse.smarthome.core.thing.type.ChannelTypeUID;
import org.eclipse.smarthome.core.types.RefreshType;
import org.eclipse.smarthome.core.thing.type.ThingType;
import org.eclipse.smarthome.core.thing.type.ThingTypeBuilder;
import org.eclipse.smarthome.core.types.StateDescriptionFragmentBuilder;
import org.openhab.binding.tinkerforge.internal.TinkerforgeBindingConstants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.eclipse.smarthome.core.library.types.DecimalType;
import org.eclipse.smarthome.core.library.types.QuantityType;
import org.eclipse.smarthome.core.library.unit.MetricPrefix;
import org.eclipse.smarthome.core.library.unit.SIUnits;
import org.eclipse.smarthome.core.library.unit.SmartHomeUnits;
import org.eclipse.smarthome.core.library.types.OpenClosedType;
import org.eclipse.smarthome.core.library.types.StringType;

import com.tinkerforge.BrickletIndustrialDigitalIn4;
import com.tinkerforge.IPConnection;
import com.tinkerforge.TinkerforgeException;

import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;

/**
 * Wraps the Java Bindings of the Industrial Digital In 4 Bricklet.
 * @author Erik Fleckstein - Initial contribution
 */
@NonNullByDefault
public class BrickletIndustrialDigitalIn4Wrapper extends BrickletIndustrialDigitalIn4 implements StandardFlashable, DeviceWrapper {
    public static final DeviceInfo DEVICE_INFO = new DeviceInfo(BrickletIndustrialDigitalIn4.DEVICE_DISPLAY_NAME, "brickletindustrialdigitalin4", BrickletIndustrialDigitalIn4.DEVICE_IDENTIFIER, BrickletIndustrialDigitalIn4Wrapper.class, BrickletIndustrialDigitalIn4Actions.class, "2.0.1", false);

    public BrickletIndustrialDigitalIn4Wrapper(String uid, IPConnection ipcon) {
        super(uid, ipcon);
    }

    private List<ScheduledFuture<?>> manualChannelUpdates = new ArrayList<>();
    private List<ListenerReg<?>> listenerRegs = new ArrayList<>();

    public void cancelManualUpdates() {
        manualChannelUpdates.forEach(f -> f.cancel(true));
    }

    public <T> T reg(T listener, Consumer<T> toRemove) {
        listenerRegs.add(new ListenerReg<T>(listener, toRemove));
        return listener;
    }

    
    private final Logger logger = LoggerFactory.getLogger(BrickletIndustrialDigitalIn4Wrapper.class);

    @Override
    public void initialize(org.eclipse.smarthome.config.core.Configuration config, Function<String, org.eclipse.smarthome.config.core.Configuration> getChannelConfigFn, BiConsumer<String, org.eclipse.smarthome.core.types.State> updateStateFn, BiConsumer<String, String> triggerChannelFn, ScheduledExecutorService scheduler, BaseThingHandler handler) throws TinkerforgeException {
        this.setResponseExpectedAll(true);
        BrickletIndustrialDigitalIn4Config cfg = (BrickletIndustrialDigitalIn4Config) config.as(BrickletIndustrialDigitalIn4Config.class);
        this.addInterruptListener(this.reg((interruptMask, valueMask) -> {if((interruptMask & (1 << 0)) > 0) {updateStateFn.accept("BrickletIndustrialDigitalIn4Input0", transformBrickletIndustrialDigitalIn4Input0Callback0(interruptMask, valueMask, cfg));}}, this::removeInterruptListener));
		this.addInterruptListener(this.reg((interruptMask, valueMask) -> {if((interruptMask & (1 << 1)) > 0) {updateStateFn.accept("BrickletIndustrialDigitalIn4Input1", transformBrickletIndustrialDigitalIn4Input1Callback0(interruptMask, valueMask, cfg));}}, this::removeInterruptListener));
		this.addInterruptListener(this.reg((interruptMask, valueMask) -> {if((interruptMask & (1 << 2)) > 0) {updateStateFn.accept("BrickletIndustrialDigitalIn4Input2", transformBrickletIndustrialDigitalIn4Input2Callback0(interruptMask, valueMask, cfg));}}, this::removeInterruptListener));
		this.addInterruptListener(this.reg((interruptMask, valueMask) -> {if((interruptMask & (1 << 3)) > 0) {updateStateFn.accept("BrickletIndustrialDigitalIn4Input3", transformBrickletIndustrialDigitalIn4Input3Callback0(interruptMask, valueMask, cfg));}}, this::removeInterruptListener));
        
		{
		this.setInterrupt((short)(this.getInterrupt() | (1 << 0)));
		}
		{
		this.setInterrupt((short)(this.getInterrupt() | (1 << 1)));
		}
		{
		this.setInterrupt((short)(this.getInterrupt() | (1 << 2)));
		}
		{
		this.setInterrupt((short)(this.getInterrupt() | (1 << 3)));
		}
		{
		BrickletIndustrialDigitalIn4EdgeCountConfig channelCfg = getChannelConfigFn.apply("BrickletIndustrialDigitalIn4EdgeCount0").as(BrickletIndustrialDigitalIn4EdgeCountConfig.class);
		this.setEdgeCountConfig((short)(1 << 0), channelCfg.edgeType.shortValue(), channelCfg.debounce.shortValue());
		if(channelCfg.updateInterval > 0) {
    this.manualChannelUpdates.add(scheduler.scheduleWithFixedDelay(() -> {if(handler.getThing().getStatus() == ThingStatus.ONLINE) {handler.handleCommand(new ChannelUID(handler.getThing().getUID(), "BrickletIndustrialDigitalIn4EdgeCount0"), RefreshType.REFRESH);}}, channelCfg.updateInterval, channelCfg.updateInterval, TimeUnit.MILLISECONDS));
}
		}
		{
		BrickletIndustrialDigitalIn4EdgeCountConfig channelCfg = getChannelConfigFn.apply("BrickletIndustrialDigitalIn4EdgeCount1").as(BrickletIndustrialDigitalIn4EdgeCountConfig.class);
		this.setEdgeCountConfig((short)(1 << 1), channelCfg.edgeType.shortValue(), channelCfg.debounce.shortValue());
		if(channelCfg.updateInterval > 0) {
    this.manualChannelUpdates.add(scheduler.scheduleWithFixedDelay(() -> {if(handler.getThing().getStatus() == ThingStatus.ONLINE) {handler.handleCommand(new ChannelUID(handler.getThing().getUID(), "BrickletIndustrialDigitalIn4EdgeCount1"), RefreshType.REFRESH);}}, channelCfg.updateInterval, channelCfg.updateInterval, TimeUnit.MILLISECONDS));
}
		}
		{
		BrickletIndustrialDigitalIn4EdgeCountConfig channelCfg = getChannelConfigFn.apply("BrickletIndustrialDigitalIn4EdgeCount2").as(BrickletIndustrialDigitalIn4EdgeCountConfig.class);
		this.setEdgeCountConfig((short)(1 << 2), channelCfg.edgeType.shortValue(), channelCfg.debounce.shortValue());
		if(channelCfg.updateInterval > 0) {
    this.manualChannelUpdates.add(scheduler.scheduleWithFixedDelay(() -> {if(handler.getThing().getStatus() == ThingStatus.ONLINE) {handler.handleCommand(new ChannelUID(handler.getThing().getUID(), "BrickletIndustrialDigitalIn4EdgeCount2"), RefreshType.REFRESH);}}, channelCfg.updateInterval, channelCfg.updateInterval, TimeUnit.MILLISECONDS));
}
		}
		{
		BrickletIndustrialDigitalIn4EdgeCountConfig channelCfg = getChannelConfigFn.apply("BrickletIndustrialDigitalIn4EdgeCount3").as(BrickletIndustrialDigitalIn4EdgeCountConfig.class);
		this.setEdgeCountConfig((short)(1 << 3), channelCfg.edgeType.shortValue(), channelCfg.debounce.shortValue());
		if(channelCfg.updateInterval > 0) {
    this.manualChannelUpdates.add(scheduler.scheduleWithFixedDelay(() -> {if(handler.getThing().getStatus() == ThingStatus.ONLINE) {handler.handleCommand(new ChannelUID(handler.getThing().getUID(), "BrickletIndustrialDigitalIn4EdgeCount3"), RefreshType.REFRESH);}}, channelCfg.updateInterval, channelCfg.updateInterval, TimeUnit.MILLISECONDS));
}
		}
    }

    @Override
    public void dispose(org.eclipse.smarthome.config.core.Configuration config) throws TinkerforgeException {
        listenerRegs.forEach(ListenerReg::deregister);

        
        this.setInterrupt((short)(this.getInterrupt() & ~(1 << 0)));
		this.setInterrupt((short)(this.getInterrupt() & ~(1 << 1)));
		this.setInterrupt((short)(this.getInterrupt() & ~(1 << 2)));
		this.setInterrupt((short)(this.getInterrupt() & ~(1 << 3)));
		
    }

    @Override
    public List<String> getEnabledChannels(org.eclipse.smarthome.config.core.Configuration config) throws TinkerforgeException{
        List<String> result = new ArrayList<String>();
        result.add("BrickletIndustrialDigitalIn4Input0");
		result.add("BrickletIndustrialDigitalIn4Input1");
		result.add("BrickletIndustrialDigitalIn4Input2");
		result.add("BrickletIndustrialDigitalIn4Input3");
		result.add("BrickletIndustrialDigitalIn4EdgeCount0");
		result.add("BrickletIndustrialDigitalIn4EdgeCount1");
		result.add("BrickletIndustrialDigitalIn4EdgeCount2");
		result.add("BrickletIndustrialDigitalIn4EdgeCount3");
        return result;
    }

    public static @Nullable ChannelType getChannelType(ChannelTypeUID channelTypeUID) {
        switch(channelTypeUID.getId()) {
            case "BrickletIndustrialDigitalIn4Input":
                return ChannelTypeBuilder.state(new ChannelTypeUID("tinkerforge", "BrickletIndustrialDigitalIn4Input"), "NOT USED", "Contact").withConfigDescriptionURI(URI.create("channel-type:tinkerforge:BrickletIndustrialDigitalIn4Input")).withDescription("The logic level that is currently measured on the channel.").build();
            case "BrickletIndustrialDigitalIn4EdgeCount":
                return ChannelTypeBuilder.state(new ChannelTypeUID("tinkerforge", "BrickletIndustrialDigitalIn4EdgeCount"), "NOT USED", "Number:Dimensionless").withConfigDescriptionURI(URI.create("channel-type:tinkerforge:BrickletIndustrialDigitalIn4EdgeCount")).withDescription("The current value of the edge counter of the channel.")
.withStateDescription(StateDescriptionFragmentBuilder.create().withPattern("%d").withReadOnly(true).build().toStateDescription()).build();
default:
                break;
        }

        return null;
    }

    public static ThingType getThingType(ThingTypeUID thingTypeUID) {
             Map<String, String> thingTypeProperties = ThingTypeBuilder.instance(thingTypeUID, "unused").build().getProperties();
             Map<String, String> props = new HashMap<String, String>(thingTypeProperties);
             props.putIfAbsent(TinkerforgeBindingConstants.PROPERTY_MINIMUM_FIRMWARE_VERSION, DEVICE_INFO.minimumFWVersion);
        return ThingTypeBuilder.instance(thingTypeUID, "Tinkerforge Industrial Digital In 4 Bricklet").isListed(false).withSupportedBridgeTypeUIDs(Arrays.asList(TinkerforgeBindingConstants.THING_TYPE_BRICK_DAEMON.toString())).withConfigDescriptionURI(URI.create("thing-type:tinkerforge:" + thingTypeUID.getId())).withDescription("4 galvanically isolated digital inputs").withChannelDefinitions(Arrays.asList(new ChannelDefinitionBuilder("BrickletIndustrialDigitalIn4Input0", new ChannelTypeUID("tinkerforge", "BrickletIndustrialDigitalIn4Input")).withLabel("Input Value 0").build(), new ChannelDefinitionBuilder("BrickletIndustrialDigitalIn4Input1", new ChannelTypeUID("tinkerforge", "BrickletIndustrialDigitalIn4Input")).withLabel("Input Value 1").build(), new ChannelDefinitionBuilder("BrickletIndustrialDigitalIn4Input2", new ChannelTypeUID("tinkerforge", "BrickletIndustrialDigitalIn4Input")).withLabel("Input Value 2").build(), new ChannelDefinitionBuilder("BrickletIndustrialDigitalIn4Input3", new ChannelTypeUID("tinkerforge", "BrickletIndustrialDigitalIn4Input")).withLabel("Input Value 3").build(), new ChannelDefinitionBuilder("BrickletIndustrialDigitalIn4EdgeCount0", new ChannelTypeUID("tinkerforge", "BrickletIndustrialDigitalIn4EdgeCount")).withLabel("Edge Count 0").build(), new ChannelDefinitionBuilder("BrickletIndustrialDigitalIn4EdgeCount1", new ChannelTypeUID("tinkerforge", "BrickletIndustrialDigitalIn4EdgeCount")).withLabel("Edge Count 1").build(), new ChannelDefinitionBuilder("BrickletIndustrialDigitalIn4EdgeCount2", new ChannelTypeUID("tinkerforge", "BrickletIndustrialDigitalIn4EdgeCount")).withLabel("Edge Count 2").build(), new ChannelDefinitionBuilder("BrickletIndustrialDigitalIn4EdgeCount3", new ChannelTypeUID("tinkerforge", "BrickletIndustrialDigitalIn4EdgeCount")).withLabel("Edge Count 3").build())).withProperties(props).build();
    }

    public static @Nullable ConfigDescription getConfigDescription(URI uri) {
        switch(uri.toASCIIString()) {
            case "thing-type:tinkerforge:brickletindustrialdigitalin4":
                return ConfigDescriptionBuilder.create(uri).withParameters(Arrays.asList()).withParameterGroups(Arrays.asList()).build();
            case "channel-type:tinkerforge:BrickletIndustrialDigitalIn4Input":
                return ConfigDescriptionBuilder.create(uri).withParameters(Arrays.asList()).withParameterGroups(Arrays.asList()).build();
            case "channel-type:tinkerforge:BrickletIndustrialDigitalIn4EdgeCount":
                return ConfigDescriptionBuilder.create(uri).withParameters(Arrays.asList(ConfigDescriptionParameterBuilder.create("edgeType", Type.INTEGER).withDefault("0").withDescription("Configures if rising edges, falling edges or both are counted.").withLabel("Edge Type").withAdvanced(true).withLimitToOptions(true).withOptions(Arrays.asList(new ParameterOption("0", "Rising"), new ParameterOption("1", "Falling"), new ParameterOption("2", "Both"))).build(), ConfigDescriptionParameterBuilder.create("debounce", Type.INTEGER).withDefault("100").withDescription("The debounce time is the minimum time between two count increments.").withLabel("Debounce Time").withAdvanced(true).withMinimum(BigDecimal.valueOf(0)).withMaximum(BigDecimal.valueOf(255)).build(), ConfigDescriptionParameterBuilder.create("resetOnRead", Type.BOOLEAN).withDefault("false").withDescription("Enabling this will reset the edge counter after openHAB reads its value. Use this if you want relative counts per update.").withLabel("Reset Edge Counter On Update").build(), ConfigDescriptionParameterBuilder.create("updateInterval", Type.INTEGER).withDefault("1000").withDescription("Specifies the update interval in milliseconds. A value of 0 disables automatic updates.").withLabel("Update Interval").withUnit("ms").build())).withParameterGroups(Arrays.asList()).build();
            default:
                break;
        }
        return null;
    }

        @Override
    public void refreshValue(String channel, org.eclipse.smarthome.config.core.Configuration config, org.eclipse.smarthome.config.core.Configuration channelConfig, BiConsumer<String, org.eclipse.smarthome.core.types.State> updateStateFn, BiConsumer<String, String> triggerChannelFn) throws TinkerforgeException {
        BrickletIndustrialDigitalIn4Config cfg = (BrickletIndustrialDigitalIn4Config) config.as(BrickletIndustrialDigitalIn4Config.class);
switch(channel) {
            case "BrickletIndustrialDigitalIn4Input0":
                   {
            int value = this.getValue();
            if(true)
                updateStateFn.accept(channel, transformBrickletIndustrialDigitalIn4Input0Getter0(value, cfg));
        }
                   return;
            case "BrickletIndustrialDigitalIn4Input1":
                   {
            int value = this.getValue();
            if(true)
                updateStateFn.accept(channel, transformBrickletIndustrialDigitalIn4Input1Getter0(value, cfg));
        }
                   return;
            case "BrickletIndustrialDigitalIn4Input2":
                   {
            int value = this.getValue();
            if(true)
                updateStateFn.accept(channel, transformBrickletIndustrialDigitalIn4Input2Getter0(value, cfg));
        }
                   return;
            case "BrickletIndustrialDigitalIn4Input3":
                   {
            int value = this.getValue();
            if(true)
                updateStateFn.accept(channel, transformBrickletIndustrialDigitalIn4Input3Getter0(value, cfg));
        }
                   return;
            case "BrickletIndustrialDigitalIn4EdgeCount0": {
                   BrickletIndustrialDigitalIn4EdgeCountConfig channelCfg = channelConfig.as(BrickletIndustrialDigitalIn4EdgeCountConfig.class);
                   {
            long value = this.getEdgeCount((short)0, channelCfg.resetOnRead);
            if(true)
                updateStateFn.accept(channel, transformBrickletIndustrialDigitalIn4EdgeCount0Getter0(value, cfg));
        }
                   return;
               }
            case "BrickletIndustrialDigitalIn4EdgeCount1": {
                   BrickletIndustrialDigitalIn4EdgeCountConfig channelCfg = channelConfig.as(BrickletIndustrialDigitalIn4EdgeCountConfig.class);
                   {
            long value = this.getEdgeCount((short)1, channelCfg.resetOnRead);
            if(true)
                updateStateFn.accept(channel, transformBrickletIndustrialDigitalIn4EdgeCount1Getter0(value, cfg));
        }
                   return;
               }
            case "BrickletIndustrialDigitalIn4EdgeCount2": {
                   BrickletIndustrialDigitalIn4EdgeCountConfig channelCfg = channelConfig.as(BrickletIndustrialDigitalIn4EdgeCountConfig.class);
                   {
            long value = this.getEdgeCount((short)2, channelCfg.resetOnRead);
            if(true)
                updateStateFn.accept(channel, transformBrickletIndustrialDigitalIn4EdgeCount2Getter0(value, cfg));
        }
                   return;
               }
            case "BrickletIndustrialDigitalIn4EdgeCount3": {
                   BrickletIndustrialDigitalIn4EdgeCountConfig channelCfg = channelConfig.as(BrickletIndustrialDigitalIn4EdgeCountConfig.class);
                   {
            long value = this.getEdgeCount((short)3, channelCfg.resetOnRead);
            if(true)
                updateStateFn.accept(channel, transformBrickletIndustrialDigitalIn4EdgeCount3Getter0(value, cfg));
        }
                   return;
               }
default:
                logger.warn("Refresh for unknown channel {}", channel);
                break;
        }
    }
    

        @Override
    public List<SetterRefresh> handleCommand(org.eclipse.smarthome.config.core.Configuration config, org.eclipse.smarthome.config.core.Configuration channelConfig, String channel, Command command) throws TinkerforgeException {
        List<SetterRefresh> result = Collections.emptyList();
        
        switch(channel) {
            default:
                logger.warn("Command for unknown channel {}", channel);
        }
        return result;
    }

        private org.eclipse.smarthome.core.types.State transformBrickletIndustrialDigitalIn4Input0Callback0(int interruptMask, int valueMask, BrickletIndustrialDigitalIn4Config cfg) {
        return (valueMask & (1 << 0)) > 0 ? OpenClosedType.CLOSED : OpenClosedType.OPEN;
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletIndustrialDigitalIn4Input1Callback0(int interruptMask, int valueMask, BrickletIndustrialDigitalIn4Config cfg) {
        return (valueMask & (1 << 1)) > 0 ? OpenClosedType.CLOSED : OpenClosedType.OPEN;
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletIndustrialDigitalIn4Input2Callback0(int interruptMask, int valueMask, BrickletIndustrialDigitalIn4Config cfg) {
        return (valueMask & (1 << 2)) > 0 ? OpenClosedType.CLOSED : OpenClosedType.OPEN;
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletIndustrialDigitalIn4Input3Callback0(int interruptMask, int valueMask, BrickletIndustrialDigitalIn4Config cfg) {
        return (valueMask & (1 << 3)) > 0 ? OpenClosedType.CLOSED : OpenClosedType.OPEN;
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletIndustrialDigitalIn4Input0Getter0(int value, BrickletIndustrialDigitalIn4Config cfg) {
        return (value & (1 << 0)) > 0 ? OpenClosedType.CLOSED : OpenClosedType.OPEN;
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletIndustrialDigitalIn4Input1Getter0(int value, BrickletIndustrialDigitalIn4Config cfg) {
        return (value & (1 << 1)) > 0 ? OpenClosedType.CLOSED : OpenClosedType.OPEN;
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletIndustrialDigitalIn4Input2Getter0(int value, BrickletIndustrialDigitalIn4Config cfg) {
        return (value & (1 << 2)) > 0 ? OpenClosedType.CLOSED : OpenClosedType.OPEN;
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletIndustrialDigitalIn4Input3Getter0(int value, BrickletIndustrialDigitalIn4Config cfg) {
        return (value & (1 << 3)) > 0 ? OpenClosedType.CLOSED : OpenClosedType.OPEN;
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletIndustrialDigitalIn4EdgeCount0Getter0(long value, BrickletIndustrialDigitalIn4Config cfg) {
        return new DecimalType(value);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletIndustrialDigitalIn4EdgeCount1Getter0(long value, BrickletIndustrialDigitalIn4Config cfg) {
        return new DecimalType(value);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletIndustrialDigitalIn4EdgeCount2Getter0(long value, BrickletIndustrialDigitalIn4Config cfg) {
        return new DecimalType(value);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletIndustrialDigitalIn4EdgeCount3Getter0(long value, BrickletIndustrialDigitalIn4Config cfg) {
        return new DecimalType(value);
    }

}