Merging upstream version 9.5.1+dfsg.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 1375 insertions, 19 deletions

diff --git a/ansible_collections/cisco/aci/plugins/module_utils/aci.py b/ansible_collections/cisco/aci/plugins/module_utils/aci.py
index 9c6e2db2d..88b49cd6e 100644
--- a/ansible_collections/cisco/aci/plugins/module_utils/aci.py
+++ b/ansible_collections/cisco/aci/plugins/module_utils/aci.py
@@ -15,6 +15,8 @@
 # Copyright: (c) 2020, Anvitha Jain (@anvitha-jain) <anvjain@cisco.com>
 # Copyright: (c) 2023, Gaspard Micol (@gmicol) <gmicol@cisco.com>
 # Copyright: (c) 2023, Shreyas Srish (@shrsr) <ssrish@cisco.com>
+# Copyright: (c) 2023, Tim Cragg (@timcragg) <tcragg@cisco.com>
+# Copyright: (c) 2024, Samita Bhattacharjee (@samiib) <samitab@cisco.com>
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without modification,
@@ -134,6 +136,7 @@ def aci_argument_spec():
         use_ssl=dict(type="bool", fallback=(env_fallback, ["ACI_USE_SSL"])),
         validate_certs=dict(type="bool", fallback=(env_fallback, ["ACI_VALIDATE_CERTS"])),
         output_path=dict(type="str", fallback=(env_fallback, ["ACI_OUTPUT_PATH"])),
+        suppress_verification=dict(type="bool", aliases=["no_verification", "no_verify", "suppress_verify"], fallback=(env_fallback, ["ACI_NO_VERIFICATION"])),
     )
 
 
@@ -320,6 +323,64 @@ def integrate_url(httpapi_url, local_path):
     return {"protocol": parse_url.scheme, "host": parse_url.netloc, "path": local_path}
 
 
+def action_rule_set_comm_spec():
+    return dict(
+        community=dict(type="str"),
+        criteria=dict(type="str", choices=["append", "none", "replace"]),
+    )
+
+
+def action_rule_set_dampening_spec():
+    return dict(
+        half_life=dict(type="int"),
+        max_suppress_time=dict(type="int"),
+        reuse=dict(type="int"),
+        suppress=dict(type="int"),
+    )
+
+
+def associated_netflow_exporter_epg_spec():
+    return dict(
+        tenant=dict(type="str"),
+        ap=dict(type="str"),
+        epg=dict(type="str"),
+    )
+
+
+def associated_netflow_exporter_extepg_spec():
+    return dict(
+        tenant=dict(type="str"),
+        l3out=dict(type="str"),
+        extepg=dict(type="str"),
+    )
+
+
+def associated_netflow_exporter_vrf_spec():
+    return dict(
+        tenant=dict(type="str"),
+        vrf=dict(type="str"),
+    )
+
+
+def pim_interface_profile_spec():
+    return dict(
+        tenant=dict(type="str", aliases=["tenant_name"]),
+        pim=dict(type="str", aliases=["pim_interface_policy", "name"]),
+    )
+
+
+def igmp_interface_profile_spec():
+    return dict(tenant=dict(type="str", aliases=["tenant_name"]), igmp=dict(type="str", aliases=["igmp_interface_policy", "name"]))
+
+
+def storm_control_policy_rate_spec():
+    return dict(
+        rate=dict(type="str"),
+        burst_rate=dict(type="str"),
+        rate_type=dict(type="str", choices=["percentage", "pps"], required=True),
+    )
+
+
 class ACIModule(object):
     def __init__(self, module):
         self.module = module
@@ -356,6 +417,9 @@ class ACIModule(object):
         self.imdata = None
         self.totalCount = None
 
+        # get no verify flag
+        self.suppress_verification = self.params.get("suppress_verification")
+
         # Ensure protocol is set
         self.define_protocol()
 
@@ -779,8 +843,10 @@ class ACIModule(object):
         subclass_3=None,
         subclass_4=None,
         subclass_5=None,
+        subclass_6=None,
         child_classes=None,
         config_only=True,
+        rsp_subtree="full",
     ):
         """
         This method is used to retrieve the appropriate URL path and filter_string to make the request to the APIC.
@@ -796,6 +862,7 @@ class ACIModule(object):
         :type subclass_3: dict
         :type subclass_4: dict
         :type subclass_5: dict
+        :type subclass_6: dict
         :type child_classes: list
         :return: The path and filter_string needed to build the full URL.
         """
@@ -806,7 +873,9 @@ class ACIModule(object):
         else:
             self.child_classes = set(child_classes)
 
-        if subclass_5 is not None:
+        if subclass_6 is not None:
+            self._construct_url_7(root_class, subclass_1, subclass_2, subclass_3, subclass_4, subclass_5, subclass_6, config_only)
+        elif subclass_5 is not None:
             self._construct_url_6(root_class, subclass_1, subclass_2, subclass_3, subclass_4, subclass_5, config_only)
         elif subclass_4 is not None:
             self._construct_url_5(root_class, subclass_1, subclass_2, subclass_3, subclass_4, config_only)
@@ -828,10 +897,12 @@ class ACIModule(object):
             # Append child_classes to filter_string if filter string is empty
             self.update_qs(
                 {
-                    "rsp-subtree": "full",
+                    "rsp-subtree": rsp_subtree,
                     "rsp-subtree-class": ",".join(sorted(self.child_classes)),
                 }
             )
+        elif rsp_subtree == "children":
+            self.update_qs({"rsp-subtree": rsp_subtree})
 
     def _construct_url_1(self, obj, config_only=True):
         """
@@ -1077,7 +1148,7 @@ class ACIModule(object):
 
     def _construct_url_6(self, root, quad, ter, sec, parent, obj, config_only=True):
         """
-        This method is used by construct_url when the object is the fourth-level class.
+        This method is used by construct_url when the object is the fifth-level class.
         """
         root_rn = root.get("aci_rn")
         root_obj = root.get("module_object")
@@ -1145,6 +1216,85 @@ class ACIModule(object):
             # Query for a specific object of the module's class
             self.path = "api/mo/uni/{0}/{1}/{2}/{3}/{4}/{5}.json".format(root_rn, quad_rn, ter_rn, sec_rn, parent_rn, obj_rn)
 
+    def _construct_url_7(self, root, quin, quad, ter, sec, parent, obj, config_only=True):
+        """
+        This method is used by construct_url when the object is the sixth-level class.
+        """
+        root_rn = root.get("aci_rn")
+        root_obj = root.get("module_object")
+        quin_rn = quin.get("aci_rn")
+        quin_obj = quin.get("module_object")
+        quad_rn = quad.get("aci_rn")
+        quad_obj = quad.get("module_object")
+        ter_rn = ter.get("aci_rn")
+        ter_obj = ter.get("module_object")
+        sec_rn = sec.get("aci_rn")
+        sec_obj = sec.get("module_object")
+        parent_rn = parent.get("aci_rn")
+        parent_obj = parent.get("module_object")
+        obj_class = obj.get("aci_class")
+        obj_rn = obj.get("aci_rn")
+        obj_filter = obj.get("target_filter")
+        mo = obj.get("module_object")
+
+        if self.child_classes is None:
+            self.child_classes = [obj_class]
+
+        if self.module.params.get("state") in ("absent", "present"):
+            # State is absent or present
+            self.path = "api/mo/uni/{0}/{1}/{2}/{3}/{4}/{5}/{6}.json".format(root_rn, quin_rn, quad_rn, ter_rn, sec_rn, parent_rn, obj_rn)
+            if config_only:
+                self.update_qs({"rsp-prop-include": "config-only"})
+            self.obj_filter = obj_filter
+        # TODO: Add all missing cases
+        elif root_obj is None:
+            self.child_classes.add(obj_class)
+            self.path = "api/class/{0}.json".format(obj_class)
+            self.update_qs({"query-target-filter": self.build_filter(obj_class, obj_filter)})
+        elif quin_obj is None:
+            self.child_classes.add(obj_class)
+            self.path = "api/mo/uni/{0}.json".format(root_rn)
+            # NOTE: No need to select by root_filter
+            # self.update_qs({'query-target-filter': self.build_filter(root_class, root_filter)})
+            # TODO: Filter by quin_filter, parent and obj_filter
+            self.update_qs({"rsp-subtree-filter": self.build_filter(obj_class, obj_filter)})
+        elif quad_obj is None:
+            self.child_classes.add(obj_class)
+            self.path = "api/mo/uni/{0}/{1}.json".format(root_rn, quin_rn)
+            # NOTE: No need to select by root_filter
+            # self.update_qs({'query-target-filter': self.build_filter(root_class, root_filter)})
+            # TODO: Filter by quin_filter, parent and obj_filter
+            self.update_qs({"rsp-subtree-filter": self.build_filter(obj_class, obj_filter)})
+        elif ter_obj is None:
+            self.child_classes.add(obj_class)
+            self.path = "api/mo/uni/{0}/{1}/{2}.json".format(root_rn, quin_rn, quad_rn)
+            # NOTE: No need to select by quad_filter
+            # self.update_qs({'query-target-filter': self.build_filter(quin_class, quin_filter)})
+            # TODO: Filter by ter_filter, parent and obj_filter
+            self.update_qs({"rsp-subtree-filter": self.build_filter(obj_class, obj_filter)})
+        elif sec_obj is None:
+            self.child_classes.add(obj_class)
+            self.path = "api/mo/uni/{0}/{1}/{2}/{3}.json".format(root_rn, quin_rn, quad_rn, ter_rn)
+            # NOTE: No need to select by ter_filter
+            # self.update_qs({'query-target-filter': self.build_filter(ter_class, ter_filter)})
+            # TODO: Filter by sec_filter, parent and obj_filter
+            self.update_qs({"rsp-subtree-filter": self.build_filter(obj_class, obj_filter)})
+        elif parent_obj is None:
+            self.child_classes.add(obj_class)
+            self.path = "api/mo/uni/{0}/{1}/{2}/{3}/{4}.json".format(root_rn, quin_rn, quad_rn, ter_rn, sec_rn)
+            # NOTE: No need to select by sec_filter
+            # self.update_qs({'query-target-filter': self.build_filter(sec_class, sec_filter)})
+            # TODO: Filter by parent_filter and obj_filter
+            self.update_qs({"rsp-subtree-filter": self.build_filter(obj_class, obj_filter)})
+        elif mo is None:
+            self.child_classes.add(obj_class)
+            self.path = "api/mo/uni/{0}/{1}/{2}/{3}/{4}/{5}.json".format(root_rn, quin_rn, quad_rn, ter_rn, sec_rn, parent_rn)
+            # NOTE: No need to select by parent_filter
+            # self.update_qs({'query-target-filter': self.build_filter(parent_class, parent_filter)})
+        else:
+            # Query for a specific object of the module's class
+            self.path = "api/mo/uni/{0}/{1}/{2}/{3}/{4}/{5}/{6}.json".format(root_rn, quin_rn, quad_rn, ter_rn, sec_rn, parent_rn, obj_rn)
+
     def delete_config(self):
         """
         This method is used to handle the logic when the modules state is equal to absent. The method only pushes a change if
@@ -1161,7 +1311,7 @@ class ACIModule(object):
             self.result["changed"] = True
             self.method = "DELETE"
 
-    def get_diff(self, aci_class):
+    def get_diff(self, aci_class, required_properties=None):
         """
         This method is used to get the difference between the proposed and existing configurations. Each module
         should call the get_existing method before this method, and add the proposed config to the module results
@@ -1183,6 +1333,8 @@ class ACIModule(object):
             # add name back to config only if the configs do not match
             if config:
                 # TODO: If URLs are built with the object's name, then we should be able to leave off adding the name back
+                if required_properties and isinstance(required_properties, dict):
+                    config.update(required_properties)
                 config = {aci_class: {"attributes": config}}
 
             # check for updates to child configs and update new config dictionary
@@ -1369,23 +1521,30 @@ class ACIModule(object):
 
         # add child objects to proposed
         if child_configs:
-            children = []
-            for child in child_configs:
-                child_copy = deepcopy(child)
-                has_value = False
-                for root_key in child_copy.keys():
-                    for final_keys, values in child_copy[root_key]["attributes"].items():
-                        if values is None:
-                            child[root_key]["attributes"].pop(final_keys)
-                        else:
-                            child[root_key]["attributes"][final_keys] = str(values)
-                            has_value = True
-                if has_value:
-                    children.append(child)
+            children = self.handle_child_configs(child_configs)
 
             if children:
                 self.proposed[aci_class].update(dict(children=children))
 
+    def handle_child_configs(self, child_configs):
+        children = []
+        for child in child_configs:
+            child_copy = deepcopy(child)
+            has_value = False
+            for class_name in child_copy.keys():
+                for attribute, value in child_copy[class_name]["attributes"].items():
+                    if value is None:
+                        child[class_name]["attributes"].pop(attribute)
+                    else:
+                        child[class_name]["attributes"][attribute] = str(value)
+                        has_value = True
+                if child_copy[class_name].get("children") is not None:
+                    has_value = True
+                    child[class_name]["children"] = self.handle_child_configs(child_copy[class_name]["children"])
+            if has_value:
+                children.append(child)
+        return children
+
     def post_config(self, parent_class=None):
         """
         This method is used to handle the logic when the modules state is equal to present. The method only pushes a change if
@@ -1438,7 +1597,15 @@ class ACIModule(object):
         if "state" in self.params:
             self.original = self.existing
             if self.params.get("state") in ("absent", "present"):
-                self.get_existing()
+                if self.suppress_verification:
+                    if self.result["changed"]:
+                        self.result["current_verified"] = False
+                        self.existing = [self.proposed]
+                    else:
+                        self.result["current_verified"] = True
+                        # exisiting already equals the previous
+                else:
+                    self.get_existing()
 
             # if self.module._diff and self.original != self.existing:
             #     self.result['diff'] = dict(
diff --git a/ansible_collections/cisco/aci/plugins/module_utils/annotation_unsupported.py b/ansible_collections/cisco/aci/plugins/module_utils/annotation_unsupported.py
new file mode 100644
index 000000000..6e34889fb
--- /dev/null
+++ b/ansible_collections/cisco/aci/plugins/module_utils/annotation_unsupported.py
@@ -0,0 +1,853 @@
+# Code generated by release_script GitHub action; DO NOT EDIT MANUALLY.
+ANNOTATION_UNSUPPORTED = [
+    "topRoot",
+    "monPol",
+    "monATarget",
+    "monTarget",
+    "moTopProps",
+    "moModifiable",
+    "moOwnable",
+    "moResolvable",
+    "moASubj",
+    "actionACont",
+    "taskExec",
+    "namingNamedObject",
+    "namingNamedIdentifiedObject",
+    "conditionInfo",
+    "conditionRetP",
+    "conditionRecord",
+    "conditionLoggable",
+    "faultInfo",
+    "relnInst",
+    "relnTo",
+    "relnFrom",
+    "statsItem",
+    "statsAColl",
+    "statsAThrP",
+    "relnTaskRef",
+    "hvsNode",
+    "qosACong",
+    "qosAQueue",
+    "qosABuffer",
+    "qosASched",
+    "qosClassification",
+    "qosADscpClass",
+    "qosADot1PClass",
+    "lacpALagPol",
+    "pconsRef",
+    "eventARetP",
+    "faultAThrValue",
+    "faultARetP",
+    "configABackupP",
+    "dnsAProfile",
+    "dnsAProv",
+    "dnsADomain",
+    "dnsALbl",
+    "sysdebugRepository",
+    "sysdebugFile",
+    "sysdebugLogBehavior",
+    "firmwareSource",
+    "firmwareAFwStatusCont",
+    "firmwareARunning",
+    "firmwareAFwP",
+    "maintAMaintP",
+    "maintUserNotif",
+    "fabricComp",
+    "fabricANode",
+    "fabricALink",
+    "ruleDefinition",
+    "ruleItem",
+    "ruleRequirement",
+    "ruleSizeRequirement",
+    "stpAIfPol",
+    "haHaTest",
+    "rtctrlAMatchRule",
+    "rtctrlAMatchIpRule",
+    "rtctrlAMatchRtType",
+    "rtctrlASubnet",
+    "rtctrlAAttrP",
+    "rtctrlASetRule",
+    "rtctrlASetTag",
+    "rtctrlASetComm",
+    "rtctrlASetRtMetric",
+    "rtctrlASetPref",
+    "rtctrlASetNh",
+    "rtctrlASetOspfFwdAddr",
+    "rtctrlASetOspfNssa",
+    "bgpAAsP",
+    "bgpACtxPol",
+    "bgpAPeerPfxPol",
+    "bgpAPeerP",
+    "bgpAExtP",
+    "cdpAIfPol",
+    "fabricProtoIfPol",
+    "fabricL2IfPol",
+    "fabricL3IfPol",
+    "lldpAIfPol",
+    "fabricProtoPol",
+    "fabricProtoComp",
+    "fabricL2ProtoPol",
+    "fabricL3ProtoPol",
+    "fabricL2ProtoComp",
+    "fabricL3ProtoComp",
+    "fabricProtoInstPol",
+    "fabricUtilInstPol",
+    "fabricL2InstPol",
+    "fabricL3InstPol",
+    "fabricProtoDomPol",
+    "fabricL2DomPol",
+    "fabricL3DomPol",
+    "fabricL3CtxPol",
+    "l2AInstPol",
+    "fabricMaintPol",
+    "fabricNodeGrp",
+    "fabricAPodBlk",
+    "fabricANodeBlk",
+    "fabricAPortBlk",
+    "fabricSelector",
+    "fabricANodeS",
+    "fabricNodeS",
+    "fabricACardS",
+    "fabricCardS",
+    "fabricAPortS",
+    "fabricPortS",
+    "fabricIntfPol",
+    "fabricAProfile",
+    "fabricProfile",
+    "fabricPolGrp",
+    "fabricNodeP",
+    "fabricCardP",
+    "fabricPortP",
+    "fabricAPortPGrp",
+    "fabricANodePGrp",
+    "fabricACardPGrp",
+    "fabricSpAPortPGrp",
+    "fabricLeAPortPGrp",
+    "fabricAProtPol",
+    "fabricANodePEp",
+    "fabricPol",
+    "fabricInfrP",
+    "fabricInfrExP",
+    "fabricDom",
+    "fabricDef",
+    "fabricAPolGrp",
+    "vsvcAProvLbl",
+    "vsvcAConsLbl",
+    "compASvcVM",
+    "compNic",
+    "compPNic",
+    "compEntity",
+    "compElement",
+    "compContE",
+    "compObj",
+    "compCont",
+    "compProvP",
+    "compDomP",
+    "compCtrlrP",
+    "compAccessP",
+    "compUsrAccP",
+    "compHost",
+    "compPHost",
+    "vzACollection",
+    "vzACtrct",
+    "vzABrCP",
+    "vzAIf",
+    "vzAFilterable",
+    "vzAFilterableUnit",
+    "vzASubj",
+    "vzATerm",
+    "vzASTerm",
+    "vzALbl",
+    "vzACompLbl",
+    "vzAnyToCollection",
+    "vzAFilter",
+    "vzAFiltEntry",
+    "ospfACtxPol",
+    "ospfAIfP",
+    "ospfAExtP",
+    "dhcpARelayP",
+    "dhcpALbl",
+    "dhcpAInfraProvP",
+    "poolElement",
+    "poolPoolable",
+    "poolPoolMember",
+    "poolPool",
+    "pkiItem",
+    "aaaDefinition",
+    "commDefinition",
+    "pkiDefinition",
+    "aaaSystemUser",
+    "aaaBanner",
+    "aaaUserAction",
+    "aaaARetP",
+    "commComp",
+    "commWeb",
+    "commShell",
+    "aaaRealm",
+    "aaaConfig",
+    "aaaAuthMethod",
+    "aaaEp",
+    "aaaAProvider",
+    "aaaProviderGroup",
+    "adcomATsInfoUnit",
+    "adcomARwi",
+    "healthARetP",
+    "healthAInst",
+    "igmpASnoopPol",
+    "sysfileEp",
+    "sysfileRepository",
+    "sysfileInstance",
+    "fileARemoteHost",
+    "fileARemotePath",
+    "monProtoP",
+    "monSecAuthP",
+    "monGroup",
+    "monSubj",
+    "monSrc",
+    "conditionCondP",
+    "ctrlrDom",
+    "l2extADomP",
+    "l2extALNodeP",
+    "l2extAIfP",
+    "l2extAInstPSubnet",
+    "extnwEPg",
+    "extnwOut",
+    "extnwDomP",
+    "extnwAInstPSubnet",
+    "extnwALNodeP",
+    "extnwALIfP",
+    "l3extADomP",
+    "l3extALNodeP",
+    "l3extAIfP",
+    "l3extAMember",
+    "l3extAInstPSubnet",
+    "trigSchedWindowP",
+    "trigInst",
+    "trigWindow",
+    "trigSchedWindow",
+    "trigExecutable",
+    "trigTriggerable",
+    "trigSingleTriggerable",
+    "fvACont",
+    "fvADeplCont",
+    "fvL2Dom",
+    "fvABD",
+    "fvABDPol",
+    "fvAEpRetPol",
+    "fvComp",
+    "fvATg",
+    "fvEPgToCollection",
+    "fvADomP",
+    "fvEPg",
+    "fvCEPg",
+    "fvAREpPCtrct",
+    "fvDom",
+    "fvL3Dom",
+    "fvACtx",
+    "fvNwEp",
+    "fvATp",
+    "fvEp",
+    "fvPEp",
+    "fvAEpDef",
+    "fvTo",
+    "fvFrom",
+    "mgmtAZone",
+    "mgmtAInstPSubnet",
+    "eqptdiagpTestSet",
+    "eqptdiagpTestSetBoot",
+    "eqptdiagpTestSetHealth",
+    "eqptdiagpTestSetOd",
+    "eqptdiagpPortTestSetOd",
+    "eqptdiagpPortTestSetBt",
+    "eqptdiagpPortTestSetHl",
+    "eqptdiagpLpTsOd",
+    "eqptdiagpFpTsOd",
+    "eqptdiagpCardTestSetOd",
+    "eqptdiagpSupCTsOd",
+    "eqptdiagpSysCTsOd",
+    "eqptdiagpFcTsOd",
+    "eqptdiagpLcTsOd",
+    "eqptdiagpExtChCardTsOd",
+    "eqptdiagpPol",
+    "eqptdiagpHealthPol",
+    "eqptdiagpASynthObj",
+    "oamExec",
+    "pingAExec",
+    "tracerouteAExec",
+    "bgpAf",
+    "dhcpAddr",
+    "dhcpNode",
+    "dhcpResp",
+    "eqptALPort",
+    "dbgACRulePCommon",
+    "dbgacTenantSpaceCmn",
+    "dbgacEpgCmn",
+    "dbgacFromEpgCmn",
+    "dbgacToEpgCmn",
+    "dbgacFromEpCmn",
+    "dbgacToEpCmn",
+    "dbgexpExportP",
+    "dbgexpNodeStatus",
+    "spanASrcGrp",
+    "spanASrc",
+    "spanASpanLbl",
+    "spanADest",
+    "spanAVSrc",
+    "spanAVSrcGrp",
+    "spanAVDestGrp",
+    "spanAVDest",
+    "svccorePol",
+    "svccoreACore",
+    "traceroutepTrP",
+    "syntheticObject",
+    "syntheticAContext",
+    "syntheticATestObj",
+    "syntheticTLTestObj",
+    "syntheticCTestObj",
+    "monExportP",
+    "ipARouteP",
+    "ipANexthopP",
+    "infraFexBlk",
+    "infraANodeS",
+    "infraNodeGrp",
+    "infraPortS",
+    "infraEPg",
+    "infraACEPg",
+    "infraAPEPg",
+    "infraANode",
+    "infraAIpP",
+    "infraProfile",
+    "infraPolGrp",
+    "infraAccBaseGrp",
+    "infraFexGrp",
+    "infraAccGrp",
+    "infraLbl",
+    "infraAPEp",
+    "infraACEp",
+    "infraAFunc",
+    "infraGeNode",
+    "infraADomP",
+    "infraDomP",
+    "infraExP",
+    "datetimeAPol",
+    "datetimeANtpAuthKey",
+    "datetimeANtpProv",
+    "fvnsAAddrBlk",
+    "fvnsAEncapBlk",
+    "fvnsAInstP",
+    "fvnsAVxlanInstP",
+    "fvnsAAddrInstP",
+    "polAttTgt",
+    "snmpAPol",
+    "snmpACommunityP",
+    "snmpAUserP",
+    "snmpAClientGrpP",
+    "snmpAClientP",
+    "snmpACtxP",
+    "fvDef",
+    "fvNp",
+    "fvUp",
+    "polNToRef",
+    "polNFromRef",
+    "polObj",
+    "polDef",
+    "polDefRoot",
+    "polComp",
+    "polInstr",
+    "polCont",
+    "polDom",
+    "polCtrlr",
+    "polCompl",
+    "polComplElem",
+    "polConsElem",
+    "polLbl",
+    "polProvLbl",
+    "polConsLbl",
+    "polIf",
+    "polProvIf",
+    "polConsIf",
+    "polRelnHolder",
+    "polNs",
+    "polAConfIssues",
+    "vnsAGraph",
+    "vnsANode",
+    "vnsAFuncNode",
+    "vnsAFolder",
+    "vnsACCfgRel",
+    "vnsAParam",
+    "vnsATerm",
+    "vnsATermNode",
+    "vnsAbsTermNode",
+    "vnsALDevCtx",
+    "vnsALIfCtx",
+    "vnsAConn",
+    "vnsAFuncConn",
+    "vnsATermConn",
+    "vnsAConnection",
+    "vnsAL4L7ServiceFault",
+    "vnsACCfg",
+    "vnsALDevIf",
+    "vnsALDev",
+    "vnsALIf",
+    "vnsALDevLIf",
+    "vnsDevItem",
+    "fabricAPathIssues",
+    "conditionSevAsnP",
+    "fvAStCEp",
+    "fabricNodeToPolicy",
+    "aaaADomainRef",
+    "fvAEpTaskAggr",
+    "vzToRFltP",
+    "fvAToBD",
+    "frmwrkARelDelCont",
+    "infraDomainToNs",
+    "infraToAInstP",
+    "aaaARbacRule",
+    "statsDebugItem",
+    "vzInterfaceToCollection",
+    "spanAToCEp",
+    "fabricAOOSReln",
+    "l4AVxlanInstPol",
+    "fabricVxlanInstPol",
+    "fabricL1IfPol",
+    "frmwrkARelDelControl",
+    "spanACEpDef",
+    "eptrkEpRslt",
+    "mcpAIfPol",
+    "ipmcsnoopRtrIf",
+    "bfdAf",
+    "bgpALocalAsnP",
+    "bgpACtxAfPol",
+    "l3extADefaultRouteLeakP",
+    "fvAStIp",
+    "rtctrlASetRtMetricType",
+    "vnsAEPpInfo",
+    "ndAIfPol",
+    "ndAPfxPol",
+    "eigrpACtxAfPol",
+    "eigrpAStubP",
+    "eigrpAIfP",
+    "eigrpAExtP",
+    "l3extAIp",
+    "fabricProtoConsFrom",
+    "fabricProtoConsTo",
+    "fabricAPathS",
+    "infraAAccBndlGrp",
+    "fabricNodeToPathOverridePolicy",
+    "adcomARwiAdvanced",
+    "fvAClassifier",
+    "fvACrtrn",
+    "fvAttr",
+    "fvAVmAttr",
+    "fvAIpAttr",
+    "fvAMacAttr",
+    "fvAProtoAttr",
+    "polADependentOn",
+    "vnsAVRoutingNetworks",
+    "l3extARouteTagPol",
+    "nwsAFwPol",
+    "fabricL4IfPol",
+    "fvAVip",
+    "fvAAREpPUpdate",
+    "conditionSummary",
+    "polAPrToPol",
+    "polAObjToPolReln",
+    "fvACrRule",
+    "fvASCrtrn",
+    "fvnsAVlanInstP",
+    "vzAnyToInterface",
+    "fvEPgToInterface",
+    "fabricPodGrp",
+    "fabricAPodS",
+    "infraPodGrp",
+    "vnsAMgmt",
+    "fabricPolicyGrpToMonitoring",
+    "plannerIPs",
+    "plannerAObject",
+    "plannerAEpg",
+    "compAPltfmP",
+    "compAVmmPltfmP",
+    "compAVmmSecP",
+    "bgpARRP",
+    "bgpARtTargetP",
+    "bgpARtTarget",
+    "l3extAFabricExtRoutingP",
+    "fvAFabricExtConnP",
+    "fvAPodConnP",
+    "fvAPeeringP",
+    "fvANode",
+    "plannerATmpl",
+    "nwsASrc",
+    "nwsASyslogSrc",
+    "throttlerASub",
+    "qosADscpTrans",
+    "fvARsToRemote",
+    "vnsOrchReq",
+    "vnsOrchResp",
+    "fcprARs",
+    "dbgexpTechSupOnDBase",
+    "infraGeSnNode",
+    "l3extAConsLbl",
+    "l3extAProvLbl",
+    "trigATriggeredWindow",
+    "qosADppPol",
+    "bfdAInstPol",
+    "bfdAIfPol",
+    "bfdAIfP",
+    "plannerADomainTmpl",
+    "plannerAEpgDomain",
+    "vmmACapObj",
+    "vmmACapInfo",
+    "fvARsToRemoteFC",
+    "rtctrlAMatchCommFactor",
+    "rtctrlAMatchCommTerm",
+    "rtctrlAMatchCommRegexTerm",
+    "rtctrlASetDamp",
+    "rtctrlASetWeight",
+    "hvsContE",
+    "hvsUsegContE",
+    "compAPvlanP",
+    "usegAUsegEPg",
+    "fvAStAttr",
+    "fvADyAttr",
+    "mgmtAIp",
+    "faultARsToRemote",
+    "analyticsACfgSrv",
+    "infraAAccGrp",
+    "infraSpAccGrp",
+    "infraANodeP",
+    "infraPortP",
+    "infraAPathS",
+    "ipmcsnoopMcSrc",
+    "ipmcsnoopTgtIf",
+    "analyticsACluster",
+    "rtdmcAIfPol",
+    "rtdmcARtMapPol",
+    "rtdmcAExtP",
+    "rtdmcACtxPol",
+    "rtdmcARPPol",
+    "rtdmcAAutoRPPol",
+    "rtdmcABSRPPol",
+    "rtdmcAStaticRPPol",
+    "rtdmcAStaticRPEntry",
+    "rtdmcARPGrpRangePol",
+    "rtdmcARegTrPol",
+    "rtdmcAResPol",
+    "rtdmcAPatPol",
+    "rtdmcAASMPatPol",
+    "rtdmcASGRangeExpPol",
+    "rtdmcASharedRangePol",
+    "rtdmcASSMPatPol",
+    "rtdmcASSMRangePol",
+    "rtdmcABidirPatPol",
+    "pimAIfP",
+    "rtdmcARtMapEntry",
+    "rtdmcAJPFilterPol",
+    "rtdmcANbrFilterPol",
+    "rtdmcAMAFilter",
+    "rtdmcABSRFilter",
+    "rtdmcAFilterPol",
+    "fvAEPgPathAtt",
+    "fvnsAVsanInstP",
+    "ipmcAIfPol",
+    "ipmcAStRepPol",
+    "ipmcAStateLPol",
+    "ipmcARepPol",
+    "ipmcACtxPol",
+    "ipmcASSMXlateP",
+    "igmpAIfP",
+    "vmmEpgAggr",
+    "apPluginName",
+    "rtdmcAIfPolCont",
+    "fabricL2PortSecurityPol",
+    "fcAPinningP",
+    "fcAPinningLbl",
+    "fabricAONodeS",
+    "infraAONodeS",
+    "analyticsRemoteNode",
+    "analyticsTarget",
+    "fabricASubPortBlk",
+    "bgpARtTargetInstrP",
+    "hsrpAIfPol",
+    "hsrpAGroupPol",
+    "hsrpAGroupP",
+    "hsrpASecVip",
+    "hsrpAIfP",
+    "netflowARecordPol",
+    "netflowAExporterPol",
+    "netflowARsInterfaceToMonitor",
+    "netflowARsMonitorToRecord",
+    "netflowARsMonitorToExporter",
+    "netflowAMonitorPol",
+    "igmpASnoopStaticGroup",
+    "igmpASnoopAccessGroup",
+    "netflowAFabExporterPol",
+    "fabricQinqIfPol",
+    "orchsEntity",
+    "orchsElement",
+    "vnsNATReq",
+    "vnsLBReq",
+    "aclACL",
+    "aclL3ACE",
+    "apDockerName",
+    "hostprotASubj",
+    "macsecAAIfPol",
+    "macsecAIfPol",
+    "macsecAAParamPol",
+    "macsecAParamPol",
+    "macsecAAKeyChainPol",
+    "macsecAAKeyPol",
+    "macsecAKeyChainPol",
+    "macsecAKeyPol",
+    "fvAIntersiteConnP",
+    "fvAIntersiteConnPDef",
+    "fvASiteConnP",
+    "coppAProfile",
+    "coppACustomValues",
+    "infraNodeS",
+    "rtctrlASetASPath",
+    "rtctrlASetASPathASN",
+    "fvADnsAttr",
+    "dnsepgFault",
+    "dnsepgASvrGrp",
+    "dnsepgAMgmt",
+    "dnsepgASvr",
+    "dnsepgADomain",
+    "ipANexthopEpP",
+    "vmmInjectedObject",
+    "poeAIfPol",
+    "iaclAProfile",
+    "telemetryAServer",
+    "snmpATrapFwdServerP",
+    "dwdmAOptChnlIfPol",
+    "vzARuleOwner",
+    "telemetryAServerPol",
+    "telemetryARemoteServer",
+    "telemetryAFlowServers",
+    "telemetryAServerP",
+    "plannerAEpgFilter",
+    "callhomeASrc",
+    "callhomeADest",
+    "callhomeAGroup",
+    "fvAEpAnycast",
+    "tagTag",
+    "tagAnnotation",
+    "tagASelector",
+    "infraFcAccGrp",
+    "infraAFcAccBndlGrp",
+    "vsanARsVsanPathAtt",
+    "vsanARtVsanPathAtt",
+    "vzSubjectToFilter",
+    "telemetryAStreamEnable",
+    "cloudsecASaKeyP",
+    "rtdmcAInterVRFPol",
+    "rtdmcAInterVRFEntry",
+    "cloudsecAControl",
+    "adepgAResElement",
+    "adepgAElement",
+    "adepgACont",
+    "adepgAOrgUnit",
+    "adepgEntity",
+    "adepgContE",
+    "fvAIdAttr",
+    "edmObj",
+    "edmCont",
+    "edmGroupP",
+    "edmMgrP",
+    "edmEntity",
+    "edmElement",
+    "edmContE",
+    "authASvrGroup",
+    "authASvr",
+    "authBaseUsrAccP",
+    "cloudsecASaKeyPLocal",
+    "cloudsecASaKeyPRemote",
+    "cloudsecASaKeyStatus",
+    "cloudsecASaKeyStatusLocal",
+    "cloudsecASaKeyStatusRemote",
+    "cloudsecASpKeySt",
+    "cloudsecACapability",
+    "aaaRbacAnnotation",
+    "lacpAEnhancedLagPol",
+    "compAHvHealth",
+    "mldASnoopPol",
+    "fvAExtRoutes",
+    "fvAExtRoutableRemoteSitePodSubnet",
+    "fvAEpNlb",
+    "extdevSDWanASlaPol",
+    "eigrpAAuthIfP",
+    "fvAAKeyChainPol",
+    "fvAAKeyPol",
+    "fvAKeyChainPol",
+    "fvAKeyPol",
+    "fvSyntheticIp",
+    "edmACapFlags",
+    "cloudABgpPeerP",
+    "cloudABgpAsP",
+    "cloudARouterP",
+    "cloudAIntNetworkP",
+    "cloudAExtNetworkP",
+    "cloudAHostRouterPol",
+    "cloudAHostBootstrapPol",
+    "cloudAVpnGwPol",
+    "cloudAHostIfP",
+    "cloudALoopbackIfP",
+    "cloudAL3IfP",
+    "cloudAIpv4AddrP",
+    "cloudAL3TunnelIfP",
+    "cloudAIpSecTunnelIfP",
+    "cloudAOspfIfP",
+    "cloudAOspfAreaP",
+    "cloudACtxProfile",
+    "cloudACidr",
+    "cloudASubnet",
+    "cloudAAwsLogGroup",
+    "cloudAAwsFlowLogPol",
+    "cloudAProvider",
+    "cloudAAwsProvider",
+    "cloudAAEPg",
+    "cloudAEPSelector",
+    "cloudAEPSelectorDef",
+    "cloudADomP",
+    "genericsARule",
+    "ipsecAIsakmpPhase1Pol",
+    "ipsecAIsakmpPhase2Pol",
+    "resolutionARsToRemote",
+    "cloudtemplateASubnetPool",
+    "fvAACrtrn",
+    "fvAUsegAssocBD",
+    "cloudALDev",
+    "cloudAListener",
+    "cloudAPool",
+    "cloudAListenerRule",
+    "cloudARuleCondition",
+    "cloudARuleAction",
+    "cloudACertStore",
+    "cloudACertificate",
+    "arpAIfPol",
+    "compNameIdentEntity",
+    "edmAOperCont",
+    "edmAStatsCont",
+    "cloudASvcPol",
+    "hcloudATgStats",
+    "statsANWStatsObj",
+    "statsATunnel",
+    "cloudAController",
+    "cloudAApicSubnet",
+    "cloudAApicSubnetPool",
+    "cloudABaseEPg",
+    "cloudASvcEPg",
+    "statsAALbStats",
+    "mldASnoopStaticGroup",
+    "mldASnoopAccessGroup",
+    "datetimeANtpIFFKey",
+    "hcloudRouterStateOper",
+    "vmmAUplinkP",
+    "vmmAUplinkPCont",
+    "cloudAAFilter",
+    "fvASDWanPrefixTaskAggr",
+    "cloudAProvResP",
+    "bfdAMhInstPol",
+    "bfdAMhIfPol",
+    "fvAEPSelector",
+    "ptpAACfg",
+    "ptpACfg",
+    "fabricL2BDPol",
+    "rtdmcABDPol",
+    "rtdmcABDFilter",
+    "ptpAProfile",
+    "mdpADomP",
+    "mdpADomainPeeringPol",
+    "mdpAPeeringDomain",
+    "mdpANodeP",
+    "mdpAClassId",
+    "mdpATenant",
+    "mplsAExtP",
+    "mplsAIfP",
+    "mplsALabelPol",
+    "mplsANodeSidP",
+    "qosAMplsIngressRule",
+    "qosMplsMarking",
+    "qosAMplsEgressRule",
+    "cloudAGatewayRouterP",
+    "cloudATransitHubGwPol",
+    "cloudAL3IntTunnelIfP",
+    "cloudABdiId",
+    "mplsASrgbLabelPol",
+    "bfdAMhNodePol",
+    "bfdANodeP",
+    "leakASubnet",
+    "rtctrlASetNhUnchanged",
+    "mdpAService",
+    "cloudALIf",
+    "cloudAParamPol",
+    "cloudAComputePol",
+    "cloudAMgmtPol",
+    "cloudANWParams",
+    "fvRtScopeFrom",
+    "cloudACtxUnderlayP",
+    "cloudAHealthProbe",
+    "leakARouteCont",
+    "netflowAVmmExporterPol",
+    "cloudABrownfield",
+    "cloudAMapping",
+    "cloudASelectedEP",
+    "statsANlbStats",
+    "mdpAEntity",
+    "dbgANodeInst",
+    "snmpACtrlrInst",
+    "cloudAFrontendIPv4Addr",
+    "qosAUburst",
+    "telemetryAFteEvents",
+    "telemetryAFteEventsTcpFlags",
+    "telemetryAFteEventsExt",
+    "cloudACloudSvcEPg",
+    "hcloudASvcResBase",
+    "bgpADomainIdBase",
+    "fvAEpTag",
+    "bgpASiteOfOriginP",
+    "fvAEPSelectorDef",
+    "vmmCFaultInfo",
+    "synceAAIfPol",
+    "synceAIfPol",
+    "rtctrlASetRedistMultipath",
+    "cloudANextHopIp",
+    "cloudAVrfRouteLeakPol",
+    "hcloudALeakedPfx",
+    "leakAPrefix",
+    "fvARogueExceptionMac",
+    "bfdAMicroBfdP",
+    "hcloudAIntPfx",
+    "hcloudAExtPfx",
+    "cloudAVpnNetworkP",
+    "snmpUser",
+    "cloudAVirtualWanP",
+    "fvAFBRGroup",
+    "fvAFBRoute",
+    "fvAFBRMember",
+    "rtctrlASetPolicyTag",
+    "fvACtxRtSummPol",
+    "fvARtSummSubnet",
+    "fvAIntraVrfFabricImpRtctrlP",
+    "fvAFabricExpRtctrlP",
+    "cloudAVip",
+    "rtctrlAMatchAsPathRegexTerm",
+    "cloudAGcpFlowLogPol",
+    "statsAGcpNWStatsObj",
+    "cloudABfdPol",
+    "cloudABfdP",
+    "bgpACtxAddlPathPol",
+    "xcvrOpticsIfPol",
+    "xcvrOpticsFabIfPol",
+    "hostprotANamespace",
+    "fvARouteDeployP",
+    "rtdmcACSWPol",
+    "rtdmcACSWEntry",
+    "analyticsTo",
+    "analyticsFrom",
+    "dmemotltestAbsObject",
+    "bgpAsnmpBgpTraps",
+    "l3extARogueExceptionMac",
+    "l3extARogueExceptionMacGroup",
+    "vzAFiltPZEntry",
+]
diff --git a/ansible_collections/cisco/aci/plugins/module_utils/constants.py b/ansible_collections/cisco/aci/plugins/module_utils/constants.py
index 165b63431..26818ff64 100644
--- a/ansible_collections/cisco/aci/plugins/module_utils/constants.py
+++ b/ansible_collections/cisco/aci/plugins/module_utils/constants.py
@@ -97,4 +97,340 @@ EP_LOOP_PROTECTION_ACTION_MAPPING = {"bd": "bd-learn-disable", "port": "port-dis
 
 FABRIC_POD_SELECTOR_TYPE_MAPPING = dict(all="ALL", range="range")
 
-TLS_MAPPING = {"tls_v1.0": "TLSv1", "tls_v1.1": "TLSv1.1", "tls_v1.2": "TLSv1.2"}
+OPFLEX_TLS_MAPPING = {"tls_v1.0": "TLSv1", "tls_v1.1": "TLSv1.1", "tls_v1.2": "TLSv1.2"}
+
+HTTP_TLS_MAPPING = {"tls_v1.0": "TLSv1", "tls_v1.1": "TLSv1.1", "tls_v1.2": "TLSv1.2", "tls_v1.3": "TLSv1.3"}
+
+ACI_ACCESS_SWITCH_POLICY_GROUP_CLASS_MAPPING = dict(
+    spine=dict(
+        class_name="infraSpineAccNodePGrp",
+        rn="infra/funcprof/spaccnodepgrp-{0}",
+        copp_pre_filter_policy=dict(class_name="infraRsIaclSpineProfile", tn_name="tnIaclSpineProfileName"),
+        bfd_ipv4_policy=dict(class_name="infraRsSpineBfdIpv4InstPol", tn_name="tnBfdIpv4InstPolName"),
+        bfd_ipv6_policy=dict(class_name="infraRsSpineBfdIpv6InstPol", tn_name="tnBfdIpv6InstPolName"),
+        copp_policy=dict(class_name="infraRsSpineCoppProfile", tn_name="tnCoppSpineProfileName"),
+        cdp_policy=dict(class_name="infraRsSpinePGrpToCdpIfPol", tn_name="tnCdpIfPolName"),
+        lldp_policy=dict(class_name="infraRsSpinePGrpToLldpIfPol", tn_name="tnLldpIfPolName"),
+        usb_configuration_policy=dict(class_name="infraRsSpineTopoctrlUsbConfigProfilePol", tn_name="tnTopoctrlUsbConfigProfilePolName"),
+    ),
+    leaf=dict(
+        class_name="infraAccNodePGrp",
+        rn="infra/funcprof/accnodepgrp-{0}",
+        copp_pre_filter_policy=dict(class_name="infraRsIaclLeafProfile", tn_name="tnIaclLeafProfileName"),
+        bfd_ipv4_policy=dict(class_name="infraRsBfdIpv4InstPol", tn_name="tnBfdIpv4InstPolName"),
+        bfd_ipv6_policy=dict(class_name="infraRsBfdIpv6InstPol", tn_name="tnBfdIpv6InstPolName"),
+        copp_policy=dict(class_name="infraRsLeafCoppProfile", tn_name="tnCoppLeafProfileName"),
+        cdp_policy=dict(class_name="infraRsLeafPGrpToCdpIfPol", tn_name="tnCdpIfPolName"),
+        lldp_policy=dict(class_name="infraRsLeafPGrpToLldpIfPol", tn_name="tnLldpIfPolName"),
+        usb_configuration_policy=dict(class_name="infraRsLeafTopoctrlUsbConfigProfilePol", tn_name="tnTopoctrlUsbConfigProfilePolName"),
+    ),
+)
+
+PIM_SETTING_CONTROL_STATE_MAPPING = {"fast": "fast-conv", "strict": "strict-rfc-compliant"}
+
+ACI_CLASS_MAPPING = dict(
+    consumer={
+        "class": "fvRsCons",
+        "rn": "rscons-",
+        "name": "tnVzBrCPName",
+    },
+    provider={
+        "class": "fvRsProv",
+        "rn": "rsprov-",
+        "name": "tnVzBrCPName",
+    },
+    taboo={
+        "class": "fvRsProtBy",
+        "rn": "rsprotBy-",
+        "name": "tnVzTabooName",
+    },
+    interface={
+        "class": "fvRsConsIf",
+        "rn": "rsconsIf-",
+        "name": "tnVzCPIfName",
+    },
+    intra_epg={
+        "class": "fvRsIntraEpg",
+        "rn": "rsintraEpg-",
+        "name": "tnVzBrCPName",
+    },
+)
+
+PROVIDER_MATCH_MAPPING = dict(
+    all="All",
+    at_least_one="AtleastOne",
+    at_most_one="AtmostOne",
+    none="None",
+)
+
+CONTRACT_LABEL_MAPPING = dict(
+    consumer="vzConsLbl",
+    provider="vzProvLbl",
+)
+
+SUBJ_LABEL_MAPPING = dict(
+    consumer="vzConsSubjLbl",
+    provider="vzProvSubjLbl",
+)
+
+SUBJ_LABEL_RN = dict(
+    consumer="conssubjlbl-",
+    provider="provsubjlbl-",
+)
+
+MATCH_ACTION_RULE_SET_METRIC_TYPE_MAPPING = {"ospf_type_1": "ospf-type1", "ospf_type_2": "ospf-type2", "": ""}
+
+MATCH_EIGRP_INTERFACE_POLICY_DELAY_UNIT_MAPPING = dict(picoseconds="pico", tens_of_microseconds="tens-of-micro")
+
+MATCH_EIGRP_INTERFACE_POLICY_CONTROL_STATE_MAPPING = dict(bfd="bfd", nexthop_self="nh-self", passive="passive", split_horizon="split-horizon")
+
+MATCH_TARGET_COS_MAPPING = {
+    "background": "0",
+    "best_effort": "1",
+    "excellent_effort": "2",
+    "critical_applications": "3",
+    "video": "4",
+    "voice": "5",
+    "internetwork_control": "6",
+    "network_control": "7",
+    "unspecified": "unspecified",
+}
+
+MATCH_PIM_INTERFACE_POLICY_CONTROL_STATE_MAPPING = dict(multicast_domain_boundary="border", strict_rfc_compliant="strict-rfc-compliant", passive="passive")
+
+MATCH_PIM_INTERFACE_POLICY_AUTHENTICATION_TYPE_MAPPING = dict(none="none", md5_hmac="ah-md5")
+
+MATCH_COLLECT_NETFLOW_RECORD_MAPPING = dict(
+    bytes_counter="count-bytes",
+    pkts_counter="count-pkts",
+    pkt_disposition="pkt-disp",
+    sampler_id="sampler-id",
+    source_interface="src-intf",
+    tcp_flags="tcp-flags",
+    first_pkt_timestamp="ts-first",
+    recent_pkt_timestamp="ts-recent",
+)
+
+MATCH_MATCH_NETFLOW_RECORD_MAPPING = dict(
+    destination_ipv4_v6="dst-ip",
+    destination_ipv4="dst-ipv4",
+    destination_ipv6="dst-ipv6",
+    destination_mac="dst-mac",
+    destination_port="dst-port",
+    ethertype="ethertype",
+    ip_protocol="proto",
+    source_ipv4_v6="src-ip",
+    source_ipv4="src-ipv4",
+    source_ipv6="src-ipv6",
+    source_mac="src-mac",
+    source_port="src-port",
+    ip_tos="tos",
+    unspecified="unspecified",
+    vlan="vlan",
+)
+
+MATCH_SOURCE_IP_TYPE_NETFLOW_EXPORTER_MAPPING = dict(
+    custom_source_ip="custom-src-ip",
+    inband_management_ip="inband-mgmt-ip",
+    out_of_band_management_ip="oob-mgmt-ip",
+    ptep="ptep",
+)
+
+ECC_CURVE = {"P256": "prime256v1", "P384": "secp384r1", "P521": "secp521r1", "none": "none"}
+
+THROTTLE_UNIT = dict(requests_per_second="r/s", requests_per_minute="r/m")
+
+SSH_CIPHERS = dict(
+    aes128_ctr="aes128-ctr",
+    aes192_ctr="aes192-ctr",
+    aes256_ctr="aes256-ctr",
+    aes128_gcm="aes128-gcm@openssh.com",
+    aes256_gcm="aes256-gcm@openssh.com",
+    chacha20="chacha20-poly1305@openssh.com",
+)
+
+SSH_MACS = dict(
+    sha1="hmac-sha1",
+    sha2_256="hmac-sha2-256",
+    sha2_512="hmac-sha2-512",
+    sha2_256_etm="hmac-sha2-256-etm@openssh.com",
+    sha2_512_etm="hmac-sha2-512-etm@openssh.com",
+)
+
+KEX_ALGORITHMS = dict(
+    dh_sha1="diffie-hellman-group14-sha1",
+    dh_sha256="diffie-hellman-group14-sha256",
+    dh_sha512="diffie-hellman-group16-sha512",
+    curve_sha256="curve25519-sha256",
+    curve_sha256_libssh="curve25519-sha256@libssh.org",
+    ecdh_256="ecdh-sha2-nistp256",
+    ecdh_384="ecdh-sha2-nistp384",
+    ecdh_521="ecdh-sha2-nistp521",
+)
+
+USEG_ATTRIBUTE_MAPPING = dict(
+    ip=dict(attribute_type="ip", attribute_class="fvIpAttr", rn_format="ipattr-{0}"),
+    mac=dict(attribute_type="mac", attribute_class="fvMacAttr", rn_format="macattr-{0}"),
+    dns=dict(attribute_type="dns", attribute_class="fvDnsAttr", rn_format="dnsattr-{0}"),
+    ad_group=dict(attribute_type="ad", attribute_class="fvIdGroupAttr", rn_format="idgattr-[{0}]"),
+    vm_custom_attr=dict(attribute_type="custom-label", attribute_class="fvVmAttr", rn_format="vmattr-{0}"),
+    vm_vmm_domain=dict(attribute_type="domain", attribute_class="fvVmAttr", rn_format="vmattr-{0}"),
+    vm_operating_system=dict(attribute_type="guest-os", attribute_class="fvVmAttr", rn_format="vmattr-{0}"),
+    vm_hypervisor_id=dict(attribute_type="hv", attribute_class="fvVmAttr", rn_format="vmattr-{0}"),
+    vm_datacenter=dict(attribute_type="rootContName", attribute_class="fvVmAttr", rn_format="vmattr-{0}"),
+    vm_id=dict(attribute_type="vm", attribute_class="fvVmAttr", rn_format="vmattr-{0}"),
+    vm_name=dict(attribute_type="vm-name", attribute_class="fvVmAttr", rn_format="vmattr-{0}"),
+    vm_folder=dict(attribute_type="vm-folder", attribute_class="fvVmAttr", rn_format="vmattr-{0}"),
+    vm_folder_path=dict(attribute_type="vmfolder-path", attribute_class="fvVmAttr", rn_format="vmattr-{0}"),
+    vm_vnic=dict(attribute_type="vnic", attribute_class="fvVmAttr", rn_format="vmattr-{0}"),
+    vm_tag=dict(attribute_type="tag", attribute_class="fvVmAttr", rn_format="vmattr-{0}"),
+)
+
+OPERATOR_MAPPING = dict(equals="equals", contains="contains", starts_with="startsWith", ends_with="endsWith")
+
+MATCH_STORM_CONTROL_POLICY_TYPE_MAPPING = dict(all_types="Invalid", unicast_broadcast_multicast="Valid")
+
+POLICY_LABEL_COLORS = [
+    "alice_blue",
+    "antique_white",
+    "aqua",
+    "aquamarine",
+    "azure",
+    "beige",
+    "bisque",
+    "black",
+    "blanched_almond",
+    "blue",
+    "blue_violet",
+    "brown",
+    "burlywood",
+    "cadet_blue",
+    "chartreuse",
+    "chocolate",
+    "coral",
+    "cornflower_blue",
+    "cornsilk",
+    "crimson",
+    "cyan",
+    "dark_blue",
+    "dark_cyan",
+    "dark_goldenrod",
+    "dark_gray",
+    "dark_green",
+    "dark_khaki",
+    "dark_magenta",
+    "dark_olive_green",
+    "dark_orange",
+    "dark_orchid",
+    "dark_red",
+    "dark_salmon",
+    "dark_sea_green",
+    "dark_slate_blue",
+    "dark_slate_gray",
+    "dark_turquoise",
+    "dark_violet",
+    "deep_pink",
+    "deep_sky_blue",
+    "dim_gray",
+    "dodger_blue",
+    "fire_brick",
+    "floral_white",
+    "forest_green",
+    "fuchsia",
+    "gainsboro",
+    "ghost_white",
+    "gold",
+    "goldenrod",
+    "gray",
+    "green",
+    "green_yellow",
+    "honeydew",
+    "hot_pink",
+    "indian_red",
+    "indigo",
+    "ivory",
+    "khaki",
+    "lavender",
+    "lavender_blush",
+    "lawn_green",
+    "lemon_chiffon",
+    "light_blue",
+    "light_coral",
+    "light_cyan",
+    "light_goldenrod_yellow",
+    "light_gray",
+    "light_green",
+    "light_pink",
+    "light_salmon",
+    "light_sea_green",
+    "light_sky_blue",
+    "light_slate_gray",
+    "light_steel_blue",
+    "light_yellow",
+    "lime",
+    "lime_green",
+    "linen",
+    "magenta",
+    "maroon",
+    "medium_aquamarine",
+    "medium_blue",
+    "medium_orchid",
+    "medium_purple",
+    "medium_sea_green",
+    "medium_slate_blue",
+    "medium_spring_green",
+    "medium_turquoise",
+    "medium_violet_red",
+    "midnight_blue",
+    "mint_cream",
+    "misty_rose",
+    "moccasin",
+    "navajo_white",
+    "navy",
+    "old_lace",
+    "olive",
+    "olive_drab",
+    "orange",
+    "orange_red",
+    "orchid",
+    "pale_goldenrod",
+    "pale_green",
+    "pale_turquoise",
+    "pale_violet_red",
+    "papaya_whip",
+    "peachpuff",
+    "peru",
+    "pink",
+    "plum",
+    "powder_blue",
+    "purple",
+    "red",
+    "rosy_brown",
+    "royal_blue",
+    "saddle_brown",
+    "salmon",
+    "sandy_brown",
+    "sea_green",
+    "seashell",
+    "sienna",
+    "silver",
+    "sky_blue",
+    "slate_blue",
+    "slate_gray",
+    "snow",
+    "spring_green",
+    "steel_blue",
+    "tan",
+    "teal",
+    "thistle",
+    "tomato",
+    "turquoise",
+    "violet",
+    "wheat",
+    "white",
+    "white_smoke",
+    "yellow",
+    "yellow_green",
+]
+
+MATCH_ACCESS_POLICIES_SELECTOR_TYPE = dict(range="range", all="ALL")