From 28caae9eb50d84c2d214feb01ab31d7e8808682a Mon Sep 17 00:00:00 2001 From: GitHub Action Date: Thu, 4 Jun 2026 07:14:06 +0000 Subject: [PATCH] Auto-generated library v3.2.0 for API v1.71.0. --- docs/generation-report.md | 7 + meraki/__init__.py | 2 +- meraki/_version.py | 2 +- meraki/aio/api/appliance.py | 485 ++++++++++++++++++++++++++++++ meraki/aio/api/devices.py | 232 ++++++++++++++ meraki/aio/api/networks.py | 4 + meraki/aio/api/organizations.py | 4 + meraki/aio/api/wireless.py | 14 +- meraki/api/appliance.py | 485 ++++++++++++++++++++++++++++++ meraki/api/batch/appliance.py | 216 +++++++++++++ meraki/api/batch/devices.py | 128 ++++++++ meraki/api/batch/organizations.py | 2 + meraki/api/batch/wireless.py | 4 +- meraki/api/devices.py | 232 ++++++++++++++ meraki/api/networks.py | 4 + meraki/api/organizations.py | 4 + meraki/api/wireless.py | 14 +- pyproject.toml | 2 +- uv.lock | 2 +- 19 files changed, 1826 insertions(+), 17 deletions(-) diff --git a/docs/generation-report.md b/docs/generation-report.md index bd02f142..dea19b9e 100644 --- a/docs/generation-report.md +++ b/docs/generation-report.md @@ -1 +1,8 @@ # Generation Report + +## 2026-06-04 | Library v3.2.0 | API 1.71.0 + + +No Python keyword parameter conflicts detected. + + diff --git a/meraki/__init__.py b/meraki/__init__.py index 04eb7940..9cc2ecae 100644 --- a/meraki/__init__.py +++ b/meraki/__init__.py @@ -52,7 +52,7 @@ from meraki._version import __version__ # noqa: F401 from datetime import datetime -__api_version__ = "1.70.0" +__api_version__ = "1.71.0" __all__ = [ "APIError", diff --git a/meraki/_version.py b/meraki/_version.py index f5f41e56..11731085 100644 --- a/meraki/_version.py +++ b/meraki/_version.py @@ -1 +1 @@ -__version__ = "3.1.0" +__version__ = "3.2.0" diff --git a/meraki/aio/api/appliance.py b/meraki/aio/api/appliance.py index db28a668..2c29b70c 100644 --- a/meraki/aio/api/appliance.py +++ b/meraki/aio/api/appliance.py @@ -23,6 +23,47 @@ def getDeviceApplianceDhcpSubnets(self, serial: str): return self._session.get(metadata, resource) + def createDeviceApplianceInterfacesPortsUpdate(self, serial: str, **kwargs): + """ + **Update configurations for an appliance's specified port** + https://developer.cisco.com/meraki/api-v1/#!create-device-appliance-interfaces-ports-update + + - serial (string): Serial + - interface (object): The interface tuple used to identify the port + - enabled (boolean): Indicates whether the port is enabled + - personality (object): Describes the port's configurability + - uplink (object): The port's settings when in WAN mode + - downlink (object): The port's VLAN settings when in LAN mode + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "configure", "interfaces", "ports", "update"], + "operation": "createDeviceApplianceInterfacesPortsUpdate", + } + serial = urllib.parse.quote(str(serial), safe="") + resource = f"/devices/{serial}/appliance/interfaces/ports/update" + + body_params = [ + "interface", + "enabled", + "personality", + "uplink", + "downlink", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"createDeviceApplianceInterfacesPortsUpdate: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.post(metadata, resource, payload) + def getDeviceAppliancePerformance(self, serial: str, **kwargs): """ **Return the performance score for a single MX** @@ -1038,6 +1079,93 @@ def updateNetworkApplianceFirewallSettings(self, networkId: str, **kwargs): return self._session.put(metadata, resource, payload) + def createNetworkApplianceInterfacesL3(self, networkId: str, ipv4: dict, **kwargs): + """ + **Create wired L3 interface** + https://developer.cisco.com/meraki/api-v1/#!create-network-appliance-interfaces-l-3 + + - networkId (string): Network ID + - ipv4 (object): IPv4 configuration + - port (object): Port configuration + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "configure", "interfaces", "l3"], + "operation": "createNetworkApplianceInterfacesL3", + } + networkId = urllib.parse.quote(str(networkId), safe="") + resource = f"/networks/{networkId}/appliance/interfaces/l3" + + body_params = [ + "port", + "ipv4", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning(f"createNetworkApplianceInterfacesL3: ignoring unrecognized kwargs: {invalid}") + + return self._session.post(metadata, resource, payload) + + def updateNetworkApplianceInterfacesL3(self, networkId: str, interfaceId: str, **kwargs): + """ + **Update wired L3 interface** + https://developer.cisco.com/meraki/api-v1/#!update-network-appliance-interfaces-l-3 + + - networkId (string): Network ID + - interfaceId (string): Interface ID + - port (object): Port configuration + - ipv4 (object): IPv4 configuration + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "configure", "interfaces", "l3"], + "operation": "updateNetworkApplianceInterfacesL3", + } + networkId = urllib.parse.quote(str(networkId), safe="") + interfaceId = urllib.parse.quote(str(interfaceId), safe="") + resource = f"/networks/{networkId}/appliance/interfaces/l3/{interfaceId}" + + body_params = [ + "port", + "ipv4", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning(f"updateNetworkApplianceInterfacesL3: ignoring unrecognized kwargs: {invalid}") + + return self._session.put(metadata, resource, payload) + + def deleteNetworkApplianceInterfacesL3(self, networkId: str, interfaceId: str): + """ + **Delete wired L3 interface** + https://developer.cisco.com/meraki/api-v1/#!delete-network-appliance-interfaces-l-3 + + - networkId (string): Network ID + - interfaceId (string): Interface ID + """ + + metadata = { + "tags": ["appliance", "configure", "interfaces", "l3"], + "operation": "deleteNetworkApplianceInterfacesL3", + } + networkId = urllib.parse.quote(str(networkId), safe="") + interfaceId = urllib.parse.quote(str(interfaceId), safe="") + resource = f"/networks/{networkId}/appliance/interfaces/l3/{interfaceId}" + + return self._session.delete(metadata, resource) + def getNetworkAppliancePorts(self, networkId: str): """ **List per-port VLAN settings for all ports of a secure router or security appliance.** @@ -1087,6 +1215,7 @@ def updateNetworkAppliancePort(self, networkId: str, portId: str, **kwargs): - vlan (integer): Native VLAN when the port is in Trunk mode. Access VLAN when the port is in Access mode. - allowedVlans (string): Comma-delimited list of VLAN IDs (e.g. '2,15') for all devices. Secure Routers also support VLAN ranges (e.g. '2-10,15'). Use 'all' to permit all VLANs on the port. - accessPolicy (string): The name of the policy. Only applicable to Access ports. Valid values are: 'open', '8021x-radius', 'mac-radius', 'hybris-radius' for MX64 or Z3 or any MX supporting the per port authentication feature. Otherwise, 'open' is the only valid value and 'open' is the default value if the field is missing. + - sgt (object): Security Group Tag settings for the port. """ kwargs.update(locals()) @@ -1106,6 +1235,7 @@ def updateNetworkAppliancePort(self, networkId: str, portId: str, **kwargs): "vlan", "allowedVlans", "accessPolicy", + "sgt", ] payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} @@ -2378,6 +2508,134 @@ def disconnectNetworkApplianceUmbrellaAccount(self, networkId: str): return self._session.post(metadata, resource) + def exclusionsNetworkApplianceUmbrellaDomains(self, networkId: str, domains: list, **kwargs): + """ + **Specify one or more domain names to be excluded from being routed to Cisco Umbrella.** + https://developer.cisco.com/meraki/api-v1/#!exclusions-network-appliance-umbrella-domains + + - networkId (string): Network ID + - domains (array): Domain names to exclude from Umbrella DNS routing (e.g., 'example.com', 'corp.example.org'). Standard FQDNs only — wildcards are not supported. Values are lowercased before saving. Each call replaces the full exclusion list. + """ + + kwargs = locals() + + metadata = { + "tags": ["appliance", "configure", "umbrella", "domains"], + "operation": "exclusionsNetworkApplianceUmbrellaDomains", + } + networkId = urllib.parse.quote(str(networkId), safe="") + resource = f"/networks/{networkId}/appliance/umbrella/domains/exclusions" + + body_params = [ + "domains", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"exclusionsNetworkApplianceUmbrellaDomains: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.put(metadata, resource, payload) + + def addNetworkApplianceUmbrellaPolicies(self, networkId: str, policy: dict, **kwargs): + """ + **Add one Cisco Umbrella DNS security policy to an MX network by policy ID** + https://developer.cisco.com/meraki/api-v1/#!add-network-appliance-umbrella-policies + + - networkId (string): Network ID + - policy (object): Umbrella policy to add + """ + + kwargs = locals() + + metadata = { + "tags": ["appliance", "configure", "umbrella", "policies"], + "operation": "addNetworkApplianceUmbrellaPolicies", + } + networkId = urllib.parse.quote(str(networkId), safe="") + resource = f"/networks/{networkId}/appliance/umbrella/policies/add" + + body_params = [ + "policy", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning(f"addNetworkApplianceUmbrellaPolicies: ignoring unrecognized kwargs: {invalid}") + + return self._session.post(metadata, resource, payload) + + def removeNetworkApplianceUmbrellaPolicies(self, networkId: str, policy: dict, **kwargs): + """ + **Remove one Cisco Umbrella DNS security policy from an MX network by policy ID** + https://developer.cisco.com/meraki/api-v1/#!remove-network-appliance-umbrella-policies + + - networkId (string): Network ID + - policy (object): Umbrella policy to remove + """ + + kwargs = locals() + + metadata = { + "tags": ["appliance", "configure", "umbrella", "policies"], + "operation": "removeNetworkApplianceUmbrellaPolicies", + } + networkId = urllib.parse.quote(str(networkId), safe="") + resource = f"/networks/{networkId}/appliance/umbrella/policies/remove" + + body_params = [ + "policy", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"removeNetworkApplianceUmbrellaPolicies: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.post(metadata, resource, payload) + + def protectionNetworkApplianceUmbrella(self, networkId: str, enabled: bool, **kwargs): + """ + **Enable or disable umbrella protection for an appliance network** + https://developer.cisco.com/meraki/api-v1/#!protection-network-appliance-umbrella + + - networkId (string): Network ID + - enabled (boolean): Enable or disable umbrella protection + """ + + kwargs = locals() + + metadata = { + "tags": ["appliance", "configure", "umbrella"], + "operation": "protectionNetworkApplianceUmbrella", + } + networkId = urllib.parse.quote(str(networkId), safe="") + resource = f"/networks/{networkId}/appliance/umbrella/protection" + + body_params = [ + "enabled", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning(f"protectionNetworkApplianceUmbrella: ignoring unrecognized kwargs: {invalid}") + + return self._session.put(metadata, resource, payload) + def updateNetworkApplianceUplinksNat(self, networkId: str, uplinks: list, **kwargs): """ **Update uplink NAT settings of the specified network** @@ -2488,6 +2746,7 @@ def createNetworkApplianceVlan(self, networkId: str, id: str, name: str, **kwarg - dhcpBootNextServer (string): DHCP boot option to direct boot clients to the server to load the boot file from - dhcpBootFilename (string): DHCP boot option for boot filename - dhcpOptions (array): The list of DHCP options that will be included in DHCP responses. Each object in the list should have "code", "type", and "value" properties. + - sgt (object): Security Group Tag settings for the VLAN. - vrf (object): VRF configuration on the VLAN - uplinks (array): Per-uplink NAT exception override configuration on the VLAN. Applicable only for networks that support NAT exceptions. """ @@ -2535,6 +2794,7 @@ def createNetworkApplianceVlan(self, networkId: str, id: str, name: str, **kwarg "dhcpBootNextServer", "dhcpBootFilename", "dhcpOptions", + "sgt", "vrf", "uplinks", ] @@ -2642,6 +2902,7 @@ def updateNetworkApplianceVlan(self, networkId: str, vlanId: str, **kwargs): - mask (integer): Mask used for the subnet of all bound to the template networks. Applicable only for template network. - ipv6 (object): IPv6 configuration on the VLAN - mandatoryDhcp (object): Mandatory DHCP will enforce that clients connecting to this VLAN must use the IP address assigned by the DHCP server. Clients who use a static IP address won't be able to associate. Only available on firmware versions 17.0 and above + - sgt (object): Security Group Tag settings for the VLAN. - vrf (object): VRF configuration on the VLAN - uplinks (array): Per-uplink NAT exception override configuration on the VLAN. Applicable only for networks that support NAT exceptions. """ @@ -2693,6 +2954,7 @@ def updateNetworkApplianceVlan(self, networkId: str, vlanId: str, **kwargs): "mask", "ipv6", "mandatoryDhcp", + "sgt", "vrf", "uplinks", ] @@ -2807,6 +3069,7 @@ def updateNetworkApplianceVpnSiteToSiteVpn(self, networkId: str, mode: str, **kw - mode (string): The site-to-site VPN mode. Can be one of 'none', 'spoke' or 'hub' - hubs (array): The list of VPN hubs, in order of preference. In spoke mode, at least 1 hub is required. - subnets (array): The list of subnets and their VPN presence. + - sgt (object): Security Group Tag settings for the VPN peer. - subnet (object): Configuration of subnet features - hostTranslations (array): The list of VPN host translations. Host translations are supported starting from MX firmware version 26.1.2 """ @@ -2828,6 +3091,7 @@ def updateNetworkApplianceVpnSiteToSiteVpn(self, networkId: str, mode: str, **kw "mode", "hubs", "subnets", + "sgt", "subnet", "hostTranslations", ] @@ -2916,6 +3180,167 @@ def swapNetworkApplianceWarmSpare(self, networkId: str): return self._session.post(metadata, resource) + def getOrganizationApplianceDevicesInterfacesL3(self, organizationId: str, total_pages=1, direction="next", **kwargs): + """ + **List L3 interfaces across networks for the organization** + https://developer.cisco.com/meraki/api-v1/#!get-organization-appliance-devices-interfaces-l-3 + + - organizationId (string): Organization ID + - total_pages (integer or string): use with perPage to get total results up to total_pages*perPage; -1 or "all" for all pages + - direction (string): direction to paginate, either "next" (default) or "prev" page + - networkIds (array): Optional Network IDs to filter results + - perPage (integer): The number of entries per page returned. Acceptable range is 3 - 1000. Default is 100. + - startingAfter (string): A token used by the server to indicate the start of the page. Often this is a timestamp or an ID but it is not limited to those. This parameter should not be defined by client applications. The link for the first, last, prev, or next page in the HTTP Link header should define it. + - endingBefore (string): A token used by the server to indicate the end of the page. Often this is a timestamp or an ID but it is not limited to those. This parameter should not be defined by client applications. The link for the first, last, prev, or next page in the HTTP Link header should define it. + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "configure", "devices", "interfaces", "l3"], + "operation": "getOrganizationApplianceDevicesInterfacesL3", + } + organizationId = urllib.parse.quote(str(organizationId), safe="") + resource = f"/organizations/{organizationId}/appliance/devices/interfaces/l3" + + query_params = [ + "networkIds", + "perPage", + "startingAfter", + "endingBefore", + ] + params = {k.strip(): v for k, v in kwargs.items() if k.strip() in query_params} + + array_params = [ + "networkIds", + ] + for k, v in kwargs.items(): + if k.strip() in array_params: + params[f"{k.strip()}[]"] = kwargs[f"{k}"] + params.pop(k.strip()) + + if self._session._validate_kwargs: + all_params = query_params + array_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"getOrganizationApplianceDevicesInterfacesL3: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.get_pages(metadata, resource, params, total_pages, direction) + + def getOrganizationApplianceDevicesInterfacesPortsByDevice(self, organizationId: str, **kwargs): + """ + **Returns port configurations for appliances in a given organization** + https://developer.cisco.com/meraki/api-v1/#!get-organization-appliance-devices-interfaces-ports-by-device + + - organizationId (string): Organization ID + - serials (array): Parameter to filter the results by device serials + - interfaces (array): Parameter to filter the results by specific interfaces + - numbers (array): Parameter to filter the results by specific ports + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "configure", "devices", "interfaces", "ports", "byDevice"], + "operation": "getOrganizationApplianceDevicesInterfacesPortsByDevice", + } + organizationId = urllib.parse.quote(str(organizationId), safe="") + resource = f"/organizations/{organizationId}/appliance/devices/interfaces/ports/byDevice" + + query_params = [ + "serials", + "interfaces", + "numbers", + ] + params = {k.strip(): v for k, v in kwargs.items() if k.strip() in query_params} + + array_params = [ + "serials", + "interfaces", + "numbers", + ] + for k, v in kwargs.items(): + if k.strip() in array_params: + params[f"{k.strip()}[]"] = kwargs[f"{k}"] + params.pop(k.strip()) + + if self._session._validate_kwargs: + all_params = query_params + array_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"getOrganizationApplianceDevicesInterfacesPortsByDevice: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.get(metadata, resource, params) + + def getOrganizationApplianceDevicesPortsTransceiversReadingsHistoryByDevice( + self, organizationId: str, total_pages=1, direction="next", **kwargs + ): + """ + **Return time-series digital optical monitoring (DOM) readings for ports on each DOM-enabled Catalyst appliance in an organization.** + https://developer.cisco.com/meraki/api-v1/#!get-organization-appliance-devices-ports-transceivers-readings-history-by-device + + - organizationId (string): Organization ID + - total_pages (integer or string): use with perPage to get total results up to total_pages*perPage; -1 or "all" for all pages + - direction (string): direction to paginate, either "next" (default) or "prev" page + - perPage (integer): The number of entries per page returned. Acceptable range is 3 - 10. Default is 5. + - startingAfter (string): A token used by the server to indicate the start of the page. Often this is a timestamp or an ID but it is not limited to those. This parameter should not be defined by client applications. The link for the first, last, prev, or next page in the HTTP Link header should define it. + - endingBefore (string): A token used by the server to indicate the end of the page. Often this is a timestamp or an ID but it is not limited to those. This parameter should not be defined by client applications. The link for the first, last, prev, or next page in the HTTP Link header should define it. + - t0 (string): The beginning of the timespan for the data. The maximum lookback period is 30 days from today. + - t1 (string): The end of the timespan for the data. t1 can be a maximum of 30 days after t0. + - timespan (number): The timespan for which the information will be fetched. If specifying timespan, do not specify parameters t0 and t1. The value must be in seconds and be less than or equal to 30 days. The default is 1 day. If interval is provided, the timespan will be autocalculated. + - interval (integer): The time interval in seconds for returned data. The valid intervals are: 300, 1200, 14400, 86400. The default is 1200. Interval is calculated if time params are provided. + - networkIds (array): Networks for which information should be gathered. + - serials (array): Optional parameter to filter usage by appliance serial. + - portIds (array): Optional parameter to filter usage by port ID. + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "monitor", "devices", "ports", "transceivers", "readings", "history", "byDevice"], + "operation": "getOrganizationApplianceDevicesPortsTransceiversReadingsHistoryByDevice", + } + organizationId = urllib.parse.quote(str(organizationId), safe="") + resource = f"/organizations/{organizationId}/appliance/devices/ports/transceivers/readings/history/byDevice" + + query_params = [ + "perPage", + "startingAfter", + "endingBefore", + "t0", + "t1", + "timespan", + "interval", + "networkIds", + "serials", + "portIds", + ] + params = {k.strip(): v for k, v in kwargs.items() if k.strip() in query_params} + + array_params = [ + "networkIds", + "serials", + "portIds", + ] + for k, v in kwargs.items(): + if k.strip() in array_params: + params[f"{k.strip()}[]"] = kwargs[f"{k}"] + params.pop(k.strip()) + + if self._session._validate_kwargs: + all_params = query_params + array_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"getOrganizationApplianceDevicesPortsTransceiversReadingsHistoryByDevice: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.get_pages(metadata, resource, params, total_pages, direction) + def getOrganizationApplianceDevicesRedundancyByNetwork( self, organizationId: str, total_pages=1, direction="next", **kwargs ): @@ -3632,6 +4057,66 @@ def getOrganizationApplianceFirewallMulticastForwardingByNetwork( return self._session.get_pages(metadata, resource, params, total_pages, direction) + def getOrganizationApplianceInterfacesPacketsOverviewsByDevice( + self, organizationId: str, total_pages=1, direction="next", **kwargs + ): + """ + **Returns packet counter overviews for all interfaces on Secure Routers in the organization, including totals and average rates by packet type over the requested timespan.** + https://developer.cisco.com/meraki/api-v1/#!get-organization-appliance-interfaces-packets-overviews-by-device + + - organizationId (string): Organization ID + - total_pages (integer or string): use with perPage to get total results up to total_pages*perPage; -1 or "all" for all pages + - direction (string): direction to paginate, either "next" (default) or "prev" page + - t0 (string): The beginning of the timespan for the data. The maximum lookback period is 14 days from today. + - t1 (string): The end of the timespan for the data. t1 can be a maximum of 14 days after t0. + - timespan (number): The timespan for which the information will be fetched. If specifying timespan, do not specify parameters t0 and t1. The value must be in seconds and be less than or equal to 14 days. The default is 1 day. + - perPage (integer): The number of entries per page returned. Acceptable range is 3 - 50. Default is 10. + - startingAfter (string): A token used by the server to indicate the start of the page. Often this is a timestamp or an ID but it is not limited to those. This parameter should not be defined by client applications. The link for the first, last, prev, or next page in the HTTP Link header should define it. + - endingBefore (string): A token used by the server to indicate the end of the page. Often this is a timestamp or an ID but it is not limited to those. This parameter should not be defined by client applications. The link for the first, last, prev, or next page in the HTTP Link header should define it. + - networkIds (array): Optional parameter to filter Secure Routers in the provided networks + - serials (array): Optional parameter to filter Secure Routers by their serial numbers + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "monitor", "interfaces", "packets", "overviews", "byDevice"], + "operation": "getOrganizationApplianceInterfacesPacketsOverviewsByDevice", + } + organizationId = urllib.parse.quote(str(organizationId), safe="") + resource = f"/organizations/{organizationId}/appliance/interfaces/packets/overviews/byDevice" + + query_params = [ + "t0", + "t1", + "timespan", + "perPage", + "startingAfter", + "endingBefore", + "networkIds", + "serials", + ] + params = {k.strip(): v for k, v in kwargs.items() if k.strip() in query_params} + + array_params = [ + "networkIds", + "serials", + ] + for k, v in kwargs.items(): + if k.strip() in array_params: + params[f"{k.strip()}[]"] = kwargs[f"{k}"] + params.pop(k.strip()) + + if self._session._validate_kwargs: + all_params = query_params + array_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"getOrganizationApplianceInterfacesPacketsOverviewsByDevice: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.get_pages(metadata, resource, params, total_pages, direction) + def getOrganizationApplianceRoutingVrfsSettings(self, organizationId: str): """ **Return the VRF setting for an organization.** diff --git a/meraki/aio/api/devices.py b/meraki/aio/api/devices.py index 0b12c407..4925826a 100644 --- a/meraki/aio/api/devices.py +++ b/meraki/aio/api/devices.py @@ -679,6 +679,238 @@ def getDeviceLiveToolsPortsCycle(self, serial: str, id: str): return self._session.get(metadata, resource) + def createDeviceLiveToolsPortsStatus(self, serial: str, **kwargs): + """ + **Enqueue a job to retrieve port status for a device** + https://developer.cisco.com/meraki/api-v1/#!create-device-live-tools-ports-status + + - serial (string): Serial + - callback (object): Details for the callback. Please include either an httpServerId OR url and sharedSecret + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["devices", "liveTools", "ports", "status"], + "operation": "createDeviceLiveToolsPortsStatus", + } + serial = urllib.parse.quote(str(serial), safe="") + resource = f"/devices/{serial}/liveTools/ports/status" + + body_params = [ + "callback", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning(f"createDeviceLiveToolsPortsStatus: ignoring unrecognized kwargs: {invalid}") + + return self._session.post(metadata, resource, payload) + + def getDeviceLiveToolsPortsStatus(self, serial: str, jobId: str): + """ + **Return a port status live tool job.** + https://developer.cisco.com/meraki/api-v1/#!get-device-live-tools-ports-status + + - serial (string): Serial + - jobId (string): Job ID + """ + + metadata = { + "tags": ["devices", "liveTools", "ports", "status"], + "operation": "getDeviceLiveToolsPortsStatus", + } + serial = urllib.parse.quote(str(serial), safe="") + jobId = urllib.parse.quote(str(jobId), safe="") + resource = f"/devices/{serial}/liveTools/ports/status/{jobId}" + + return self._session.get(metadata, resource) + + def createDeviceLiveToolsPowerUsage(self, serial: str, **kwargs): + """ + **Enqueues a live tool job that retrieves details about a device's overall power usage** + https://developer.cisco.com/meraki/api-v1/#!create-device-live-tools-power-usage + + - serial (string): Serial + - callback (object): Details for the callback. Please include either an httpServerId OR url and sharedSecret + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["devices", "liveTools", "power", "usage"], + "operation": "createDeviceLiveToolsPowerUsage", + } + serial = urllib.parse.quote(str(serial), safe="") + resource = f"/devices/{serial}/liveTools/power/usage" + + body_params = [ + "callback", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning(f"createDeviceLiveToolsPowerUsage: ignoring unrecognized kwargs: {invalid}") + + return self._session.post(metadata, resource, payload) + + def getDeviceLiveToolsPowerUsage(self, serial: str, jobId: str): + """ + **Retrieve the status and results of a previously created live tool job fetching details about a device's overall power usage.** + https://developer.cisco.com/meraki/api-v1/#!get-device-live-tools-power-usage + + - serial (string): Serial + - jobId (string): Job ID + """ + + metadata = { + "tags": ["devices", "liveTools", "power", "usage"], + "operation": "getDeviceLiveToolsPowerUsage", + } + serial = urllib.parse.quote(str(serial), safe="") + jobId = urllib.parse.quote(str(jobId), safe="") + resource = f"/devices/{serial}/liveTools/power/usage/{jobId}" + + return self._session.get(metadata, resource) + + def createDeviceLiveToolsRoutingTableLookup(self, serial: str, **kwargs): + """ + **Enqueue a job to perform a routing table lookup request for a device** + https://developer.cisco.com/meraki/api-v1/#!create-device-live-tools-routing-table-lookup + + - serial (string): Serial + - type (string): The type of route defined + - destination (object): The destination IP or subnet to lookup + - nextHop (object): The next hop to lookup + - vpn (object): VPN related search criteria + - callback (object): Details for the callback. Please include either an httpServerId OR url and sharedSecret + """ + + kwargs.update(locals()) + + if "type" in kwargs: + options = [ + "BGP", + "EIGRP", + "HSRP", + "IGRP", + "ISIS", + "LISP", + "NAT", + "ND", + "NHRP", + "OMP", + "OSPF", + "RIP", + "default WAN", + "direct", + "static", + ] + assert kwargs["type"] in options, f'''"type" cannot be "{kwargs["type"]}", & must be set to one of: {options}''' + + metadata = { + "tags": ["devices", "liveTools", "routingTable", "lookups"], + "operation": "createDeviceLiveToolsRoutingTableLookup", + } + serial = urllib.parse.quote(str(serial), safe="") + resource = f"/devices/{serial}/liveTools/routingTable/lookups" + + body_params = [ + "type", + "destination", + "nextHop", + "vpn", + "callback", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"createDeviceLiveToolsRoutingTableLookup: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.post(metadata, resource, payload) + + def getDeviceLiveToolsRoutingTableLookup(self, serial: str, id: str): + """ + **Return a routing table live tool lookup job for a device** + https://developer.cisco.com/meraki/api-v1/#!get-device-live-tools-routing-table-lookup + + - serial (string): Serial + - id (string): ID + """ + + metadata = { + "tags": ["devices", "liveTools", "routingTable", "lookups"], + "operation": "getDeviceLiveToolsRoutingTableLookup", + } + serial = urllib.parse.quote(str(serial), safe="") + id = urllib.parse.quote(str(id), safe="") + resource = f"/devices/{serial}/liveTools/routingTable/lookups/{id}" + + return self._session.get(metadata, resource) + + def createDeviceLiveToolsRoutingTableSummary(self, serial: str, **kwargs): + """ + **Enqueue a routing table summary job for a device** + https://developer.cisco.com/meraki/api-v1/#!create-device-live-tools-routing-table-summary + + - serial (string): Serial + - callback (object): Details for the callback. Please include either an httpServerId OR url and sharedSecret + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["devices", "liveTools", "routingTable", "summaries"], + "operation": "createDeviceLiveToolsRoutingTableSummary", + } + serial = urllib.parse.quote(str(serial), safe="") + resource = f"/devices/{serial}/liveTools/routingTable/summaries" + + body_params = [ + "callback", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"createDeviceLiveToolsRoutingTableSummary: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.post(metadata, resource, payload) + + def getDeviceLiveToolsRoutingTableSummary(self, serial: str, id: str): + """ + **Return the status and result of a routing table summary job** + https://developer.cisco.com/meraki/api-v1/#!get-device-live-tools-routing-table-summary + + - serial (string): Serial + - id (string): ID + """ + + metadata = { + "tags": ["devices", "liveTools", "routingTable", "summaries"], + "operation": "getDeviceLiveToolsRoutingTableSummary", + } + serial = urllib.parse.quote(str(serial), safe="") + id = urllib.parse.quote(str(id), safe="") + resource = f"/devices/{serial}/liveTools/routingTable/summaries/{id}" + + return self._session.get(metadata, resource) + def createDeviceLiveToolsThroughputTest(self, serial: str, **kwargs): """ **Enqueue a job to test a device throughput, the test will run for 10 secs to test throughput** diff --git a/meraki/aio/api/networks.py b/meraki/aio/api/networks.py index ffa0e04e..666028fa 100644 --- a/meraki/aio/api/networks.py +++ b/meraki/aio/api/networks.py @@ -2661,6 +2661,8 @@ def updateNetworkSnmp(self, networkId: str, **kwargs): - access (string): The type of SNMP access. Can be one of 'none' (disabled), 'community' (V1/V2c), or 'users' (V3). - communityString (string): The SNMP community string. Only relevant if 'access' is set to 'community'. - users (array): The list of SNMP users. Only relevant if 'access' is set to 'users'. + - authentication (object): SNMPv3 authentication settings. Only relevant if 'access' is set to 'users'. + - privacy (object): SNMPv3 privacy settings. Only relevant if 'access' is set to 'users'. """ kwargs.update(locals()) @@ -2682,6 +2684,8 @@ def updateNetworkSnmp(self, networkId: str, **kwargs): "access", "communityString", "users", + "authentication", + "privacy", ] payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} diff --git a/meraki/aio/api/organizations.py b/meraki/aio/api/organizations.py index 57076563..1ef07871 100644 --- a/meraki/aio/api/organizations.py +++ b/meraki/aio/api/organizations.py @@ -98,6 +98,7 @@ def updateOrganization(self, organizationId: str, **kwargs): - name (string): The name of the organization - management (object): Information about the organization's management system - api (object): API-specific settings + - privacy (object): Privacy-related settings for the organization. """ kwargs.update(locals()) @@ -113,6 +114,7 @@ def updateOrganization(self, organizationId: str, **kwargs): "name", "management", "api", + "privacy", ] payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} @@ -5471,6 +5473,7 @@ def updateOrganizationLoginSecurity(self, organizationId: str, **kwargs): - enforceTwoFactorAuth (boolean): Boolean indicating whether users in this organization will be required to use an extra verification code when logging in to Dashboard. This code will be sent to their mobile phone via SMS, or can be generated by the authenticator application. - enforceLoginIpRanges (boolean): Boolean indicating whether organization will restrict access to Dashboard (including the API) from certain IP addresses. - loginIpRanges (array): List of acceptable IP ranges. Entries can be single IP addresses, IP address ranges, and CIDR subnets. + - enforceLockedIpSessions (boolean): Boolean indicating whether Dashboard sessions are locked to the IP address from which they were established. Only applicable to organizations that support locked-IP sessions; otherwise the parameter is ignored. - apiAuthentication (object): Details for indicating whether organization will restrict access to API (but not Dashboard) to certain IP addresses. """ @@ -5497,6 +5500,7 @@ def updateOrganizationLoginSecurity(self, organizationId: str, **kwargs): "enforceTwoFactorAuth", "enforceLoginIpRanges", "loginIpRanges", + "enforceLockedIpSessions", "apiAuthentication", ] payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} diff --git a/meraki/aio/api/wireless.py b/meraki/aio/api/wireless.py index 380d1dcc..8216c1b2 100644 --- a/meraki/aio/api/wireless.py +++ b/meraki/aio/api/wireless.py @@ -2274,7 +2274,7 @@ def updateNetworkWirelessSsid(self, networkId: str, number: str, **kwargs): - radiusServerTimeout (integer): The amount of time for which a RADIUS client waits for a reply from the RADIUS server (must be between 1-10 seconds). - radiusServerAttemptsLimit (integer): The maximum number of transmit attempts after which a RADIUS server is failed over (must be between 1-5). - radiusFallbackEnabled (boolean): Whether or not higher priority RADIUS servers should be retried after 60 seconds. - - radiusRadsec (object): The current settings for RADIUS RADSec + - radiusRadsec (object): The current settings for RADIUS RadSec - radiusCoaEnabled (boolean): If true, Meraki devices will act as a RADIUS Dynamic Authorization Server and will respond to RADIUS Change-of-Authorization and Disconnect messages sent by the RADIUS server. - radiusFailoverPolicy (string): This policy determines how authentication requests should be handled in the event that all of the configured RADIUS servers are unreachable ('Deny access' or 'Allow access') - radiusLoadBalancingPolicy (string): This policy determines which RADIUS server will be contacted first in an authentication attempt and the ordering of any necessary retry attempts ('Strict priority order' or 'Round robin') @@ -3103,6 +3103,7 @@ def updateNetworkWirelessSsidSplashSettings(self, networkId: str, number: str, * - redirectUrl (string): The custom redirect URL where the users will go after the splash page. - useRedirectUrl (boolean): The Boolean indicating whether the the user will be redirected to the custom redirect URL after the splash page. A custom redirect URL must be set if this is true. - welcomeMessage (string): The welcome message for the users on the splash page. + - userConsent (object): User consent settings - themeId (string): The id of the selected splash theme. - splashLogo (object): The logo used in the splash page. - splashImage (object): The image used in the splash page. @@ -3144,6 +3145,7 @@ def updateNetworkWirelessSsidSplashSettings(self, networkId: str, number: str, * "redirectUrl", "useRedirectUrl", "welcomeMessage", + "userConsent", "themeId", "splashLogo", "splashImage", @@ -4235,7 +4237,7 @@ def deleteOrganizationWirelessDevicesProvisioningDeployment(self, organizationId def getOrganizationWirelessDevicesRadsecCertificatesAuthorities(self, organizationId: str, **kwargs): """ - **Query for details on the organization's RADSEC device Certificate Authority certificates (CAs)** + **Query for details on the organization's RadSec device Certificate Authority certificates (CAs)** https://developer.cisco.com/meraki/api-v1/#!get-organization-wireless-devices-radsec-certificates-authorities - organizationId (string): Organization ID @@ -4276,7 +4278,7 @@ def getOrganizationWirelessDevicesRadsecCertificatesAuthorities(self, organizati def updateOrganizationWirelessDevicesRadsecCertificatesAuthorities(self, organizationId: str, **kwargs): """ - **Update an organization's RADSEC device Certificate Authority (CA) state** + **Update an organization's RadSec device Certificate Authority (CA) state** https://developer.cisco.com/meraki/api-v1/#!update-organization-wireless-devices-radsec-certificates-authorities - organizationId (string): Organization ID @@ -4311,7 +4313,7 @@ def updateOrganizationWirelessDevicesRadsecCertificatesAuthorities(self, organiz def createOrganizationWirelessDevicesRadsecCertificatesAuthority(self, organizationId: str): """ - **Create an organization's RADSEC device Certificate Authority (CA)** + **Create an organization's RadSec device Certificate Authority (CA)** https://developer.cisco.com/meraki/api-v1/#!create-organization-wireless-devices-radsec-certificates-authority - organizationId (string): Organization ID @@ -4328,7 +4330,7 @@ def createOrganizationWirelessDevicesRadsecCertificatesAuthority(self, organizat def getOrganizationWirelessDevicesRadsecCertificatesAuthoritiesCrls(self, organizationId: str, **kwargs): """ - **Query for certificate revocation list (CRL) for the organization's RADSEC device Certificate Authorities (CAs).** + **Query for certificate revocation list (CRL) for the organization's RadSec device Certificate Authorities (CAs).** https://developer.cisco.com/meraki/api-v1/#!get-organization-wireless-devices-radsec-certificates-authorities-crls - organizationId (string): Organization ID @@ -4369,7 +4371,7 @@ def getOrganizationWirelessDevicesRadsecCertificatesAuthoritiesCrls(self, organi def getOrganizationWirelessDevicesRadsecCertificatesAuthoritiesCrlsDeltas(self, organizationId: str, **kwargs): """ - **Query for all delta certificate revocation list (CRL) for the organization's RADSEC device Certificate Authority (CA) with the given id.** + **Query for all delta certificate revocation list (CRL) for the organization's RadSec device Certificate Authority (CA) with the given id.** https://developer.cisco.com/meraki/api-v1/#!get-organization-wireless-devices-radsec-certificates-authorities-crls-deltas - organizationId (string): Organization ID diff --git a/meraki/api/appliance.py b/meraki/api/appliance.py index 88d35b2b..14957aa0 100644 --- a/meraki/api/appliance.py +++ b/meraki/api/appliance.py @@ -23,6 +23,47 @@ def getDeviceApplianceDhcpSubnets(self, serial: str): return self._session.get(metadata, resource) + def createDeviceApplianceInterfacesPortsUpdate(self, serial: str, **kwargs): + """ + **Update configurations for an appliance's specified port** + https://developer.cisco.com/meraki/api-v1/#!create-device-appliance-interfaces-ports-update + + - serial (string): Serial + - interface (object): The interface tuple used to identify the port + - enabled (boolean): Indicates whether the port is enabled + - personality (object): Describes the port's configurability + - uplink (object): The port's settings when in WAN mode + - downlink (object): The port's VLAN settings when in LAN mode + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "configure", "interfaces", "ports", "update"], + "operation": "createDeviceApplianceInterfacesPortsUpdate", + } + serial = urllib.parse.quote(str(serial), safe="") + resource = f"/devices/{serial}/appliance/interfaces/ports/update" + + body_params = [ + "interface", + "enabled", + "personality", + "uplink", + "downlink", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"createDeviceApplianceInterfacesPortsUpdate: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.post(metadata, resource, payload) + def getDeviceAppliancePerformance(self, serial: str, **kwargs): """ **Return the performance score for a single MX** @@ -1038,6 +1079,93 @@ def updateNetworkApplianceFirewallSettings(self, networkId: str, **kwargs): return self._session.put(metadata, resource, payload) + def createNetworkApplianceInterfacesL3(self, networkId: str, ipv4: dict, **kwargs): + """ + **Create wired L3 interface** + https://developer.cisco.com/meraki/api-v1/#!create-network-appliance-interfaces-l-3 + + - networkId (string): Network ID + - ipv4 (object): IPv4 configuration + - port (object): Port configuration + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "configure", "interfaces", "l3"], + "operation": "createNetworkApplianceInterfacesL3", + } + networkId = urllib.parse.quote(str(networkId), safe="") + resource = f"/networks/{networkId}/appliance/interfaces/l3" + + body_params = [ + "port", + "ipv4", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning(f"createNetworkApplianceInterfacesL3: ignoring unrecognized kwargs: {invalid}") + + return self._session.post(metadata, resource, payload) + + def updateNetworkApplianceInterfacesL3(self, networkId: str, interfaceId: str, **kwargs): + """ + **Update wired L3 interface** + https://developer.cisco.com/meraki/api-v1/#!update-network-appliance-interfaces-l-3 + + - networkId (string): Network ID + - interfaceId (string): Interface ID + - port (object): Port configuration + - ipv4 (object): IPv4 configuration + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "configure", "interfaces", "l3"], + "operation": "updateNetworkApplianceInterfacesL3", + } + networkId = urllib.parse.quote(str(networkId), safe="") + interfaceId = urllib.parse.quote(str(interfaceId), safe="") + resource = f"/networks/{networkId}/appliance/interfaces/l3/{interfaceId}" + + body_params = [ + "port", + "ipv4", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning(f"updateNetworkApplianceInterfacesL3: ignoring unrecognized kwargs: {invalid}") + + return self._session.put(metadata, resource, payload) + + def deleteNetworkApplianceInterfacesL3(self, networkId: str, interfaceId: str): + """ + **Delete wired L3 interface** + https://developer.cisco.com/meraki/api-v1/#!delete-network-appliance-interfaces-l-3 + + - networkId (string): Network ID + - interfaceId (string): Interface ID + """ + + metadata = { + "tags": ["appliance", "configure", "interfaces", "l3"], + "operation": "deleteNetworkApplianceInterfacesL3", + } + networkId = urllib.parse.quote(str(networkId), safe="") + interfaceId = urllib.parse.quote(str(interfaceId), safe="") + resource = f"/networks/{networkId}/appliance/interfaces/l3/{interfaceId}" + + return self._session.delete(metadata, resource) + def getNetworkAppliancePorts(self, networkId: str): """ **List per-port VLAN settings for all ports of a secure router or security appliance.** @@ -1087,6 +1215,7 @@ def updateNetworkAppliancePort(self, networkId: str, portId: str, **kwargs): - vlan (integer): Native VLAN when the port is in Trunk mode. Access VLAN when the port is in Access mode. - allowedVlans (string): Comma-delimited list of VLAN IDs (e.g. '2,15') for all devices. Secure Routers also support VLAN ranges (e.g. '2-10,15'). Use 'all' to permit all VLANs on the port. - accessPolicy (string): The name of the policy. Only applicable to Access ports. Valid values are: 'open', '8021x-radius', 'mac-radius', 'hybris-radius' for MX64 or Z3 or any MX supporting the per port authentication feature. Otherwise, 'open' is the only valid value and 'open' is the default value if the field is missing. + - sgt (object): Security Group Tag settings for the port. """ kwargs.update(locals()) @@ -1106,6 +1235,7 @@ def updateNetworkAppliancePort(self, networkId: str, portId: str, **kwargs): "vlan", "allowedVlans", "accessPolicy", + "sgt", ] payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} @@ -2378,6 +2508,134 @@ def disconnectNetworkApplianceUmbrellaAccount(self, networkId: str): return self._session.post(metadata, resource) + def exclusionsNetworkApplianceUmbrellaDomains(self, networkId: str, domains: list, **kwargs): + """ + **Specify one or more domain names to be excluded from being routed to Cisco Umbrella.** + https://developer.cisco.com/meraki/api-v1/#!exclusions-network-appliance-umbrella-domains + + - networkId (string): Network ID + - domains (array): Domain names to exclude from Umbrella DNS routing (e.g., 'example.com', 'corp.example.org'). Standard FQDNs only — wildcards are not supported. Values are lowercased before saving. Each call replaces the full exclusion list. + """ + + kwargs = locals() + + metadata = { + "tags": ["appliance", "configure", "umbrella", "domains"], + "operation": "exclusionsNetworkApplianceUmbrellaDomains", + } + networkId = urllib.parse.quote(str(networkId), safe="") + resource = f"/networks/{networkId}/appliance/umbrella/domains/exclusions" + + body_params = [ + "domains", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"exclusionsNetworkApplianceUmbrellaDomains: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.put(metadata, resource, payload) + + def addNetworkApplianceUmbrellaPolicies(self, networkId: str, policy: dict, **kwargs): + """ + **Add one Cisco Umbrella DNS security policy to an MX network by policy ID** + https://developer.cisco.com/meraki/api-v1/#!add-network-appliance-umbrella-policies + + - networkId (string): Network ID + - policy (object): Umbrella policy to add + """ + + kwargs = locals() + + metadata = { + "tags": ["appliance", "configure", "umbrella", "policies"], + "operation": "addNetworkApplianceUmbrellaPolicies", + } + networkId = urllib.parse.quote(str(networkId), safe="") + resource = f"/networks/{networkId}/appliance/umbrella/policies/add" + + body_params = [ + "policy", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning(f"addNetworkApplianceUmbrellaPolicies: ignoring unrecognized kwargs: {invalid}") + + return self._session.post(metadata, resource, payload) + + def removeNetworkApplianceUmbrellaPolicies(self, networkId: str, policy: dict, **kwargs): + """ + **Remove one Cisco Umbrella DNS security policy from an MX network by policy ID** + https://developer.cisco.com/meraki/api-v1/#!remove-network-appliance-umbrella-policies + + - networkId (string): Network ID + - policy (object): Umbrella policy to remove + """ + + kwargs = locals() + + metadata = { + "tags": ["appliance", "configure", "umbrella", "policies"], + "operation": "removeNetworkApplianceUmbrellaPolicies", + } + networkId = urllib.parse.quote(str(networkId), safe="") + resource = f"/networks/{networkId}/appliance/umbrella/policies/remove" + + body_params = [ + "policy", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"removeNetworkApplianceUmbrellaPolicies: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.post(metadata, resource, payload) + + def protectionNetworkApplianceUmbrella(self, networkId: str, enabled: bool, **kwargs): + """ + **Enable or disable umbrella protection for an appliance network** + https://developer.cisco.com/meraki/api-v1/#!protection-network-appliance-umbrella + + - networkId (string): Network ID + - enabled (boolean): Enable or disable umbrella protection + """ + + kwargs = locals() + + metadata = { + "tags": ["appliance", "configure", "umbrella"], + "operation": "protectionNetworkApplianceUmbrella", + } + networkId = urllib.parse.quote(str(networkId), safe="") + resource = f"/networks/{networkId}/appliance/umbrella/protection" + + body_params = [ + "enabled", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning(f"protectionNetworkApplianceUmbrella: ignoring unrecognized kwargs: {invalid}") + + return self._session.put(metadata, resource, payload) + def updateNetworkApplianceUplinksNat(self, networkId: str, uplinks: list, **kwargs): """ **Update uplink NAT settings of the specified network** @@ -2488,6 +2746,7 @@ def createNetworkApplianceVlan(self, networkId: str, id: str, name: str, **kwarg - dhcpBootNextServer (string): DHCP boot option to direct boot clients to the server to load the boot file from - dhcpBootFilename (string): DHCP boot option for boot filename - dhcpOptions (array): The list of DHCP options that will be included in DHCP responses. Each object in the list should have "code", "type", and "value" properties. + - sgt (object): Security Group Tag settings for the VLAN. - vrf (object): VRF configuration on the VLAN - uplinks (array): Per-uplink NAT exception override configuration on the VLAN. Applicable only for networks that support NAT exceptions. """ @@ -2535,6 +2794,7 @@ def createNetworkApplianceVlan(self, networkId: str, id: str, name: str, **kwarg "dhcpBootNextServer", "dhcpBootFilename", "dhcpOptions", + "sgt", "vrf", "uplinks", ] @@ -2642,6 +2902,7 @@ def updateNetworkApplianceVlan(self, networkId: str, vlanId: str, **kwargs): - mask (integer): Mask used for the subnet of all bound to the template networks. Applicable only for template network. - ipv6 (object): IPv6 configuration on the VLAN - mandatoryDhcp (object): Mandatory DHCP will enforce that clients connecting to this VLAN must use the IP address assigned by the DHCP server. Clients who use a static IP address won't be able to associate. Only available on firmware versions 17.0 and above + - sgt (object): Security Group Tag settings for the VLAN. - vrf (object): VRF configuration on the VLAN - uplinks (array): Per-uplink NAT exception override configuration on the VLAN. Applicable only for networks that support NAT exceptions. """ @@ -2693,6 +2954,7 @@ def updateNetworkApplianceVlan(self, networkId: str, vlanId: str, **kwargs): "mask", "ipv6", "mandatoryDhcp", + "sgt", "vrf", "uplinks", ] @@ -2807,6 +3069,7 @@ def updateNetworkApplianceVpnSiteToSiteVpn(self, networkId: str, mode: str, **kw - mode (string): The site-to-site VPN mode. Can be one of 'none', 'spoke' or 'hub' - hubs (array): The list of VPN hubs, in order of preference. In spoke mode, at least 1 hub is required. - subnets (array): The list of subnets and their VPN presence. + - sgt (object): Security Group Tag settings for the VPN peer. - subnet (object): Configuration of subnet features - hostTranslations (array): The list of VPN host translations. Host translations are supported starting from MX firmware version 26.1.2 """ @@ -2828,6 +3091,7 @@ def updateNetworkApplianceVpnSiteToSiteVpn(self, networkId: str, mode: str, **kw "mode", "hubs", "subnets", + "sgt", "subnet", "hostTranslations", ] @@ -2916,6 +3180,167 @@ def swapNetworkApplianceWarmSpare(self, networkId: str): return self._session.post(metadata, resource) + def getOrganizationApplianceDevicesInterfacesL3(self, organizationId: str, total_pages=1, direction="next", **kwargs): + """ + **List L3 interfaces across networks for the organization** + https://developer.cisco.com/meraki/api-v1/#!get-organization-appliance-devices-interfaces-l-3 + + - organizationId (string): Organization ID + - total_pages (integer or string): use with perPage to get total results up to total_pages*perPage; -1 or "all" for all pages + - direction (string): direction to paginate, either "next" (default) or "prev" page + - networkIds (array): Optional Network IDs to filter results + - perPage (integer): The number of entries per page returned. Acceptable range is 3 - 1000. Default is 100. + - startingAfter (string): A token used by the server to indicate the start of the page. Often this is a timestamp or an ID but it is not limited to those. This parameter should not be defined by client applications. The link for the first, last, prev, or next page in the HTTP Link header should define it. + - endingBefore (string): A token used by the server to indicate the end of the page. Often this is a timestamp or an ID but it is not limited to those. This parameter should not be defined by client applications. The link for the first, last, prev, or next page in the HTTP Link header should define it. + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "configure", "devices", "interfaces", "l3"], + "operation": "getOrganizationApplianceDevicesInterfacesL3", + } + organizationId = urllib.parse.quote(str(organizationId), safe="") + resource = f"/organizations/{organizationId}/appliance/devices/interfaces/l3" + + query_params = [ + "networkIds", + "perPage", + "startingAfter", + "endingBefore", + ] + params = {k.strip(): v for k, v in kwargs.items() if k.strip() in query_params} + + array_params = [ + "networkIds", + ] + for k, v in kwargs.items(): + if k.strip() in array_params: + params[f"{k.strip()}[]"] = kwargs[f"{k}"] + params.pop(k.strip()) + + if self._session._validate_kwargs: + all_params = query_params + array_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"getOrganizationApplianceDevicesInterfacesL3: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.get_pages(metadata, resource, params, total_pages, direction) + + def getOrganizationApplianceDevicesInterfacesPortsByDevice(self, organizationId: str, **kwargs): + """ + **Returns port configurations for appliances in a given organization** + https://developer.cisco.com/meraki/api-v1/#!get-organization-appliance-devices-interfaces-ports-by-device + + - organizationId (string): Organization ID + - serials (array): Parameter to filter the results by device serials + - interfaces (array): Parameter to filter the results by specific interfaces + - numbers (array): Parameter to filter the results by specific ports + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "configure", "devices", "interfaces", "ports", "byDevice"], + "operation": "getOrganizationApplianceDevicesInterfacesPortsByDevice", + } + organizationId = urllib.parse.quote(str(organizationId), safe="") + resource = f"/organizations/{organizationId}/appliance/devices/interfaces/ports/byDevice" + + query_params = [ + "serials", + "interfaces", + "numbers", + ] + params = {k.strip(): v for k, v in kwargs.items() if k.strip() in query_params} + + array_params = [ + "serials", + "interfaces", + "numbers", + ] + for k, v in kwargs.items(): + if k.strip() in array_params: + params[f"{k.strip()}[]"] = kwargs[f"{k}"] + params.pop(k.strip()) + + if self._session._validate_kwargs: + all_params = query_params + array_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"getOrganizationApplianceDevicesInterfacesPortsByDevice: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.get(metadata, resource, params) + + def getOrganizationApplianceDevicesPortsTransceiversReadingsHistoryByDevice( + self, organizationId: str, total_pages=1, direction="next", **kwargs + ): + """ + **Return time-series digital optical monitoring (DOM) readings for ports on each DOM-enabled Catalyst appliance in an organization.** + https://developer.cisco.com/meraki/api-v1/#!get-organization-appliance-devices-ports-transceivers-readings-history-by-device + + - organizationId (string): Organization ID + - total_pages (integer or string): use with perPage to get total results up to total_pages*perPage; -1 or "all" for all pages + - direction (string): direction to paginate, either "next" (default) or "prev" page + - perPage (integer): The number of entries per page returned. Acceptable range is 3 - 10. Default is 5. + - startingAfter (string): A token used by the server to indicate the start of the page. Often this is a timestamp or an ID but it is not limited to those. This parameter should not be defined by client applications. The link for the first, last, prev, or next page in the HTTP Link header should define it. + - endingBefore (string): A token used by the server to indicate the end of the page. Often this is a timestamp or an ID but it is not limited to those. This parameter should not be defined by client applications. The link for the first, last, prev, or next page in the HTTP Link header should define it. + - t0 (string): The beginning of the timespan for the data. The maximum lookback period is 30 days from today. + - t1 (string): The end of the timespan for the data. t1 can be a maximum of 30 days after t0. + - timespan (number): The timespan for which the information will be fetched. If specifying timespan, do not specify parameters t0 and t1. The value must be in seconds and be less than or equal to 30 days. The default is 1 day. If interval is provided, the timespan will be autocalculated. + - interval (integer): The time interval in seconds for returned data. The valid intervals are: 300, 1200, 14400, 86400. The default is 1200. Interval is calculated if time params are provided. + - networkIds (array): Networks for which information should be gathered. + - serials (array): Optional parameter to filter usage by appliance serial. + - portIds (array): Optional parameter to filter usage by port ID. + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "monitor", "devices", "ports", "transceivers", "readings", "history", "byDevice"], + "operation": "getOrganizationApplianceDevicesPortsTransceiversReadingsHistoryByDevice", + } + organizationId = urllib.parse.quote(str(organizationId), safe="") + resource = f"/organizations/{organizationId}/appliance/devices/ports/transceivers/readings/history/byDevice" + + query_params = [ + "perPage", + "startingAfter", + "endingBefore", + "t0", + "t1", + "timespan", + "interval", + "networkIds", + "serials", + "portIds", + ] + params = {k.strip(): v for k, v in kwargs.items() if k.strip() in query_params} + + array_params = [ + "networkIds", + "serials", + "portIds", + ] + for k, v in kwargs.items(): + if k.strip() in array_params: + params[f"{k.strip()}[]"] = kwargs[f"{k}"] + params.pop(k.strip()) + + if self._session._validate_kwargs: + all_params = query_params + array_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"getOrganizationApplianceDevicesPortsTransceiversReadingsHistoryByDevice: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.get_pages(metadata, resource, params, total_pages, direction) + def getOrganizationApplianceDevicesRedundancyByNetwork( self, organizationId: str, total_pages=1, direction="next", **kwargs ): @@ -3632,6 +4057,66 @@ def getOrganizationApplianceFirewallMulticastForwardingByNetwork( return self._session.get_pages(metadata, resource, params, total_pages, direction) + def getOrganizationApplianceInterfacesPacketsOverviewsByDevice( + self, organizationId: str, total_pages=1, direction="next", **kwargs + ): + """ + **Returns packet counter overviews for all interfaces on Secure Routers in the organization, including totals and average rates by packet type over the requested timespan.** + https://developer.cisco.com/meraki/api-v1/#!get-organization-appliance-interfaces-packets-overviews-by-device + + - organizationId (string): Organization ID + - total_pages (integer or string): use with perPage to get total results up to total_pages*perPage; -1 or "all" for all pages + - direction (string): direction to paginate, either "next" (default) or "prev" page + - t0 (string): The beginning of the timespan for the data. The maximum lookback period is 14 days from today. + - t1 (string): The end of the timespan for the data. t1 can be a maximum of 14 days after t0. + - timespan (number): The timespan for which the information will be fetched. If specifying timespan, do not specify parameters t0 and t1. The value must be in seconds and be less than or equal to 14 days. The default is 1 day. + - perPage (integer): The number of entries per page returned. Acceptable range is 3 - 50. Default is 10. + - startingAfter (string): A token used by the server to indicate the start of the page. Often this is a timestamp or an ID but it is not limited to those. This parameter should not be defined by client applications. The link for the first, last, prev, or next page in the HTTP Link header should define it. + - endingBefore (string): A token used by the server to indicate the end of the page. Often this is a timestamp or an ID but it is not limited to those. This parameter should not be defined by client applications. The link for the first, last, prev, or next page in the HTTP Link header should define it. + - networkIds (array): Optional parameter to filter Secure Routers in the provided networks + - serials (array): Optional parameter to filter Secure Routers by their serial numbers + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["appliance", "monitor", "interfaces", "packets", "overviews", "byDevice"], + "operation": "getOrganizationApplianceInterfacesPacketsOverviewsByDevice", + } + organizationId = urllib.parse.quote(str(organizationId), safe="") + resource = f"/organizations/{organizationId}/appliance/interfaces/packets/overviews/byDevice" + + query_params = [ + "t0", + "t1", + "timespan", + "perPage", + "startingAfter", + "endingBefore", + "networkIds", + "serials", + ] + params = {k.strip(): v for k, v in kwargs.items() if k.strip() in query_params} + + array_params = [ + "networkIds", + "serials", + ] + for k, v in kwargs.items(): + if k.strip() in array_params: + params[f"{k.strip()}[]"] = kwargs[f"{k}"] + params.pop(k.strip()) + + if self._session._validate_kwargs: + all_params = query_params + array_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"getOrganizationApplianceInterfacesPacketsOverviewsByDevice: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.get_pages(metadata, resource, params, total_pages, direction) + def getOrganizationApplianceRoutingVrfsSettings(self, organizationId: str): """ **Return the VRF setting for an organization.** diff --git a/meraki/api/batch/appliance.py b/meraki/api/batch/appliance.py index 3e5585e0..93f68389 100644 --- a/meraki/api/batch/appliance.py +++ b/meraki/api/batch/appliance.py @@ -5,6 +5,39 @@ class ActionBatchAppliance(object): def __init__(self): super(ActionBatchAppliance, self).__init__() + def createDeviceApplianceInterfacesPortsUpdate(self, serial: str, **kwargs): + """ + **Update configurations for an appliance's specified port** + https://developer.cisco.com/meraki/api-v1/#!create-device-appliance-interfaces-ports-update + + - serial (string): Serial + - interface (object): The interface tuple used to identify the port + - enabled (boolean): Indicates whether the port is enabled + - personality (object): Describes the port's configurability + - uplink (object): The port's settings when in WAN mode + - downlink (object): The port's VLAN settings when in LAN mode + """ + + kwargs.update(locals()) + + serial = urllib.parse.quote(serial, safe="") + resource = f"/devices/{serial}/appliance/interfaces/ports/update" + + body_params = [ + "interface", + "enabled", + "personality", + "uplink", + "downlink", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + action = { + "resource": resource, + "operation": "update", + "body": payload, + } + return action + def updateDeviceApplianceRadioSettings(self, serial: str, **kwargs): """ **Update the radio settings of an appliance** @@ -203,6 +236,81 @@ def updateNetworkApplianceFirewallMulticastForwarding(self, networkId: str, rule } return action + def createNetworkApplianceInterfacesL3(self, networkId: str, ipv4: dict, **kwargs): + """ + **Create wired L3 interface** + https://developer.cisco.com/meraki/api-v1/#!create-network-appliance-interfaces-l-3 + + - networkId (string): Network ID + - ipv4 (object): IPv4 configuration + - port (object): Port configuration + """ + + kwargs.update(locals()) + + networkId = urllib.parse.quote(networkId, safe="") + resource = f"/networks/{networkId}/appliance/interfaces/l3" + + body_params = [ + "port", + "ipv4", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + action = { + "resource": resource, + "operation": "create", + "body": payload, + } + return action + + def updateNetworkApplianceInterfacesL3(self, networkId: str, interfaceId: str, **kwargs): + """ + **Update wired L3 interface** + https://developer.cisco.com/meraki/api-v1/#!update-network-appliance-interfaces-l-3 + + - networkId (string): Network ID + - interfaceId (string): Interface ID + - port (object): Port configuration + - ipv4 (object): IPv4 configuration + """ + + kwargs.update(locals()) + + networkId = urllib.parse.quote(networkId, safe="") + interfaceId = urllib.parse.quote(interfaceId, safe="") + resource = f"/networks/{networkId}/appliance/interfaces/l3/{interfaceId}" + + body_params = [ + "port", + "ipv4", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + action = { + "resource": resource, + "operation": "update", + "body": payload, + } + return action + + def deleteNetworkApplianceInterfacesL3(self, networkId: str, interfaceId: str): + """ + **Delete wired L3 interface** + https://developer.cisco.com/meraki/api-v1/#!delete-network-appliance-interfaces-l-3 + + - networkId (string): Network ID + - interfaceId (string): Interface ID + """ + + networkId = urllib.parse.quote(networkId, safe="") + interfaceId = urllib.parse.quote(interfaceId, safe="") + resource = f"/networks/{networkId}/appliance/interfaces/l3/{interfaceId}" + + action = { + "resource": resource, + "operation": "destroy", + } + return action + def updateNetworkAppliancePort(self, networkId: str, portId: str, **kwargs): """ **Update the per-port VLAN settings for a single secure router or security appliance port.** @@ -216,6 +324,7 @@ def updateNetworkAppliancePort(self, networkId: str, portId: str, **kwargs): - vlan (integer): Native VLAN when the port is in Trunk mode. Access VLAN when the port is in Access mode. - allowedVlans (string): Comma-delimited list of VLAN IDs (e.g. '2,15') for all devices. Secure Routers also support VLAN ranges (e.g. '2-10,15'). Use 'all' to permit all VLANs on the port. - accessPolicy (string): The name of the policy. Only applicable to Access ports. Valid values are: 'open', '8021x-radius', 'mac-radius', 'hybris-radius' for MX64 or Z3 or any MX supporting the per port authentication feature. Otherwise, 'open' is the only valid value and 'open' is the default value if the field is missing. + - sgt (object): Security Group Tag settings for the port. """ kwargs.update(locals()) @@ -231,6 +340,7 @@ def updateNetworkAppliancePort(self, networkId: str, portId: str, **kwargs): "vlan", "allowedVlans", "accessPolicy", + "sgt", ] payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} action = { @@ -805,6 +915,106 @@ def disconnectNetworkApplianceUmbrellaAccount(self, networkId: str): } return action + def exclusionsNetworkApplianceUmbrellaDomains(self, networkId: str, domains: list, **kwargs): + """ + **Specify one or more domain names to be excluded from being routed to Cisco Umbrella.** + https://developer.cisco.com/meraki/api-v1/#!exclusions-network-appliance-umbrella-domains + + - networkId (string): Network ID + - domains (array): Domain names to exclude from Umbrella DNS routing (e.g., 'example.com', 'corp.example.org'). Standard FQDNs only — wildcards are not supported. Values are lowercased before saving. Each call replaces the full exclusion list. + """ + + kwargs = locals() + + networkId = urllib.parse.quote(networkId, safe="") + resource = f"/networks/{networkId}/appliance/umbrella/domains/exclusions" + + body_params = [ + "domains", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + action = { + "resource": resource, + "operation": "action", + "body": payload, + } + return action + + def addNetworkApplianceUmbrellaPolicies(self, networkId: str, policy: dict, **kwargs): + """ + **Add one Cisco Umbrella DNS security policy to an MX network by policy ID. Idempotent — if the policy is already applied, the request succeeds and returns the current policy set unchanged.** + https://developer.cisco.com/meraki/api-v1/#!add-network-appliance-umbrella-policies + + - networkId (string): Network ID + - policy (object): Umbrella policy to add + """ + + kwargs = locals() + + networkId = urllib.parse.quote(networkId, safe="") + resource = f"/networks/{networkId}/appliance/umbrella/policies/add" + + body_params = [ + "policy", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + action = { + "resource": resource, + "operation": "policies_add", + "body": payload, + } + return action + + def removeNetworkApplianceUmbrellaPolicies(self, networkId: str, policy: dict, **kwargs): + """ + **Remove one Cisco Umbrella DNS security policy from an MX network by policy ID. Returns 204 No Content on success. Behavior when the policy is not currently applied depends on the Cisco Umbrella API response.** + https://developer.cisco.com/meraki/api-v1/#!remove-network-appliance-umbrella-policies + + - networkId (string): Network ID + - policy (object): Umbrella policy to remove + """ + + kwargs = locals() + + networkId = urllib.parse.quote(networkId, safe="") + resource = f"/networks/{networkId}/appliance/umbrella/policies/remove" + + body_params = [ + "policy", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + action = { + "resource": resource, + "operation": "policies_remove", + "body": payload, + } + return action + + def protectionNetworkApplianceUmbrella(self, networkId: str, enabled: bool, **kwargs): + """ + **Enable or disable umbrella protection for an appliance network. When 'enabled' is false, 'umbrella.organization.id' and 'umbrella.origin.id' are null in the response.** + https://developer.cisco.com/meraki/api-v1/#!protection-network-appliance-umbrella + + - networkId (string): Network ID + - enabled (boolean): Enable or disable umbrella protection + """ + + kwargs = locals() + + networkId = urllib.parse.quote(networkId, safe="") + resource = f"/networks/{networkId}/appliance/umbrella/protection" + + body_params = [ + "enabled", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + action = { + "resource": resource, + "operation": "action", + "body": payload, + } + return action + def updateNetworkApplianceUplinksNat(self, networkId: str, uplinks: list, **kwargs): """ **Update uplink NAT settings of the specified network** @@ -853,6 +1063,7 @@ def createNetworkApplianceVlan(self, networkId: str, id: str, name: str, **kwarg - dhcpBootNextServer (string): DHCP boot option to direct boot clients to the server to load the boot file from - dhcpBootFilename (string): DHCP boot option for boot filename - dhcpOptions (array): The list of DHCP options that will be included in DHCP responses. Each object in the list should have "code", "type", and "value" properties. + - sgt (object): Security Group Tag settings for the VLAN. - vrf (object): VRF configuration on the VLAN - uplinks (array): Per-uplink NAT exception override configuration on the VLAN. Applicable only for networks that support NAT exceptions. """ @@ -896,6 +1107,7 @@ def createNetworkApplianceVlan(self, networkId: str, id: str, name: str, **kwarg "dhcpBootNextServer", "dhcpBootFilename", "dhcpOptions", + "sgt", "vrf", "uplinks", ] @@ -959,6 +1171,7 @@ def updateNetworkApplianceVlan(self, networkId: str, vlanId: str, **kwargs): - mask (integer): Mask used for the subnet of all bound to the template networks. Applicable only for template network. - ipv6 (object): IPv6 configuration on the VLAN - mandatoryDhcp (object): Mandatory DHCP will enforce that clients connecting to this VLAN must use the IP address assigned by the DHCP server. Clients who use a static IP address won't be able to associate. Only available on firmware versions 17.0 and above + - sgt (object): Security Group Tag settings for the VLAN. - vrf (object): VRF configuration on the VLAN - uplinks (array): Per-uplink NAT exception override configuration on the VLAN. Applicable only for networks that support NAT exceptions. """ @@ -1006,6 +1219,7 @@ def updateNetworkApplianceVlan(self, networkId: str, vlanId: str, **kwargs): "mask", "ipv6", "mandatoryDhcp", + "sgt", "vrf", "uplinks", ] @@ -1078,6 +1292,7 @@ def updateNetworkApplianceVpnSiteToSiteVpn(self, networkId: str, mode: str, **kw - mode (string): The site-to-site VPN mode. Can be one of 'none', 'spoke' or 'hub' - hubs (array): The list of VPN hubs, in order of preference. In spoke mode, at least 1 hub is required. - subnets (array): The list of subnets and their VPN presence. + - sgt (object): Security Group Tag settings for the VPN peer. - subnet (object): Configuration of subnet features - hostTranslations (array): The list of VPN host translations. Host translations are supported starting from MX firmware version 26.1.2 """ @@ -1095,6 +1310,7 @@ def updateNetworkApplianceVpnSiteToSiteVpn(self, networkId: str, mode: str, **kw "mode", "hubs", "subnets", + "sgt", "subnet", "hostTranslations", ] diff --git a/meraki/api/batch/devices.py b/meraki/api/batch/devices.py index edc67a68..8df0ff15 100644 --- a/meraki/api/batch/devices.py +++ b/meraki/api/batch/devices.py @@ -134,6 +134,134 @@ def createDeviceLiveToolsLedsBlink(self, serial: str, duration: int, **kwargs): } return action + def createDeviceLiveToolsPortsStatus(self, serial: str, **kwargs): + """ + **Enqueue a job to retrieve port status for a device. This endpoint has a sustained rate limit of one request every five seconds per device, with an allowed burst of five requests.** + https://developer.cisco.com/meraki/api-v1/#!create-device-live-tools-ports-status + + - serial (string): Serial + - callback (object): Details for the callback. Please include either an httpServerId OR url and sharedSecret + """ + + kwargs.update(locals()) + + serial = urllib.parse.quote(serial, safe="") + resource = f"/devices/{serial}/liveTools/ports/status" + + body_params = [ + "callback", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + action = { + "resource": resource, + "operation": "status", + "body": payload, + } + return action + + def createDeviceLiveToolsPowerUsage(self, serial: str, **kwargs): + """ + **Enqueues a live tool job that retrieves details about a device's overall power usage. This endpoint has a sustained rate limit of one request every five seconds per device, with an allowed burst of five requests.** + https://developer.cisco.com/meraki/api-v1/#!create-device-live-tools-power-usage + + - serial (string): Serial + - callback (object): Details for the callback. Please include either an httpServerId OR url and sharedSecret + """ + + kwargs.update(locals()) + + serial = urllib.parse.quote(serial, safe="") + resource = f"/devices/{serial}/liveTools/power/usage" + + body_params = [ + "callback", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + action = { + "resource": resource, + "operation": "job", + "body": payload, + } + return action + + def createDeviceLiveToolsRoutingTableLookup(self, serial: str, **kwargs): + """ + **Enqueue a job to perform a routing table lookup request for a device. The routing table lookup request fetches a specific set of routes based on filters. Any combination of search filters can be applied. Only Cisco Secure Routers are supported.** + https://developer.cisco.com/meraki/api-v1/#!create-device-live-tools-routing-table-lookup + + - serial (string): Serial + - type (string): The type of route defined + - destination (object): The destination IP or subnet to lookup + - nextHop (object): The next hop to lookup + - vpn (object): VPN related search criteria + - callback (object): Details for the callback. Please include either an httpServerId OR url and sharedSecret + """ + + kwargs.update(locals()) + + if "type" in kwargs: + options = [ + "BGP", + "EIGRP", + "HSRP", + "IGRP", + "ISIS", + "LISP", + "NAT", + "ND", + "NHRP", + "OMP", + "OSPF", + "RIP", + "default WAN", + "direct", + "static", + ] + assert kwargs["type"] in options, f'''"type" cannot be "{kwargs["type"]}", & must be set to one of: {options}''' + + serial = urllib.parse.quote(serial, safe="") + resource = f"/devices/{serial}/liveTools/routingTable/lookups" + + body_params = [ + "type", + "destination", + "nextHop", + "vpn", + "callback", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + action = { + "resource": resource, + "operation": "lookup", + "body": payload, + } + return action + + def createDeviceLiveToolsRoutingTableSummary(self, serial: str, **kwargs): + """ + **Enqueue a routing table summary job for a device. The job fetches summary data such as route counts by VRF and protocol. Only Cisco Secure Routers are supported.** + https://developer.cisco.com/meraki/api-v1/#!create-device-live-tools-routing-table-summary + + - serial (string): Serial + - callback (object): Details for the callback. Please include either an httpServerId OR url and sharedSecret + """ + + kwargs.update(locals()) + + serial = urllib.parse.quote(serial, safe="") + resource = f"/devices/{serial}/liveTools/routingTable/summaries" + + body_params = [ + "callback", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + action = { + "resource": resource, + "operation": "summary", + "body": payload, + } + return action + def createDeviceLiveToolsThroughputTest(self, serial: str, **kwargs): """ **Enqueue a job to test a device throughput, the test will run for 10 secs to test throughput. This endpoint has a rate limit of one request every five seconds per device.** diff --git a/meraki/api/batch/organizations.py b/meraki/api/batch/organizations.py index 4b8adf62..127df4d9 100644 --- a/meraki/api/batch/organizations.py +++ b/meraki/api/batch/organizations.py @@ -1209,6 +1209,7 @@ def updateOrganizationLoginSecurity(self, organizationId: str, **kwargs): - enforceTwoFactorAuth (boolean): Boolean indicating whether users in this organization will be required to use an extra verification code when logging in to Dashboard. This code will be sent to their mobile phone via SMS, or can be generated by the authenticator application. - enforceLoginIpRanges (boolean): Boolean indicating whether organization will restrict access to Dashboard (including the API) from certain IP addresses. - loginIpRanges (array): List of acceptable IP ranges. Entries can be single IP addresses, IP address ranges, and CIDR subnets. + - enforceLockedIpSessions (boolean): Boolean indicating whether Dashboard sessions are locked to the IP address from which they were established. Only applicable to organizations that support locked-IP sessions; otherwise the parameter is ignored. - apiAuthentication (object): Details for indicating whether organization will restrict access to API (but not Dashboard) to certain IP addresses. """ @@ -1231,6 +1232,7 @@ def updateOrganizationLoginSecurity(self, organizationId: str, **kwargs): "enforceTwoFactorAuth", "enforceLoginIpRanges", "loginIpRanges", + "enforceLockedIpSessions", "apiAuthentication", ] payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} diff --git a/meraki/api/batch/wireless.py b/meraki/api/batch/wireless.py index f2983d22..72ff3912 100644 --- a/meraki/api/batch/wireless.py +++ b/meraki/api/batch/wireless.py @@ -725,7 +725,7 @@ def updateNetworkWirelessSsid(self, networkId: str, number: str, **kwargs): - radiusServerTimeout (integer): The amount of time for which a RADIUS client waits for a reply from the RADIUS server (must be between 1-10 seconds). - radiusServerAttemptsLimit (integer): The maximum number of transmit attempts after which a RADIUS server is failed over (must be between 1-5). - radiusFallbackEnabled (boolean): Whether or not higher priority RADIUS servers should be retried after 60 seconds. - - radiusRadsec (object): The current settings for RADIUS RADSec + - radiusRadsec (object): The current settings for RADIUS RadSec - radiusCoaEnabled (boolean): If true, Meraki devices will act as a RADIUS Dynamic Authorization Server and will respond to RADIUS Change-of-Authorization and Disconnect messages sent by the RADIUS server. - radiusFailoverPolicy (string): This policy determines how authentication requests should be handled in the event that all of the configured RADIUS servers are unreachable ('Deny access' or 'Allow access') - radiusLoadBalancingPolicy (string): This policy determines which RADIUS server will be contacted first in an authentication attempt and the ordering of any necessary retry attempts ('Strict priority order' or 'Round robin') @@ -1288,6 +1288,7 @@ def updateNetworkWirelessSsidSplashSettings(self, networkId: str, number: str, * - redirectUrl (string): The custom redirect URL where the users will go after the splash page. - useRedirectUrl (boolean): The Boolean indicating whether the the user will be redirected to the custom redirect URL after the splash page. A custom redirect URL must be set if this is true. - welcomeMessage (string): The welcome message for the users on the splash page. + - userConsent (object): User consent settings - themeId (string): The id of the selected splash theme. - splashLogo (object): The logo used in the splash page. - splashImage (object): The image used in the splash page. @@ -1325,6 +1326,7 @@ def updateNetworkWirelessSsidSplashSettings(self, networkId: str, number: str, * "redirectUrl", "useRedirectUrl", "welcomeMessage", + "userConsent", "themeId", "splashLogo", "splashImage", diff --git a/meraki/api/devices.py b/meraki/api/devices.py index ab404ce2..79865603 100644 --- a/meraki/api/devices.py +++ b/meraki/api/devices.py @@ -679,6 +679,238 @@ def getDeviceLiveToolsPortsCycle(self, serial: str, id: str): return self._session.get(metadata, resource) + def createDeviceLiveToolsPortsStatus(self, serial: str, **kwargs): + """ + **Enqueue a job to retrieve port status for a device** + https://developer.cisco.com/meraki/api-v1/#!create-device-live-tools-ports-status + + - serial (string): Serial + - callback (object): Details for the callback. Please include either an httpServerId OR url and sharedSecret + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["devices", "liveTools", "ports", "status"], + "operation": "createDeviceLiveToolsPortsStatus", + } + serial = urllib.parse.quote(str(serial), safe="") + resource = f"/devices/{serial}/liveTools/ports/status" + + body_params = [ + "callback", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning(f"createDeviceLiveToolsPortsStatus: ignoring unrecognized kwargs: {invalid}") + + return self._session.post(metadata, resource, payload) + + def getDeviceLiveToolsPortsStatus(self, serial: str, jobId: str): + """ + **Return a port status live tool job.** + https://developer.cisco.com/meraki/api-v1/#!get-device-live-tools-ports-status + + - serial (string): Serial + - jobId (string): Job ID + """ + + metadata = { + "tags": ["devices", "liveTools", "ports", "status"], + "operation": "getDeviceLiveToolsPortsStatus", + } + serial = urllib.parse.quote(str(serial), safe="") + jobId = urllib.parse.quote(str(jobId), safe="") + resource = f"/devices/{serial}/liveTools/ports/status/{jobId}" + + return self._session.get(metadata, resource) + + def createDeviceLiveToolsPowerUsage(self, serial: str, **kwargs): + """ + **Enqueues a live tool job that retrieves details about a device's overall power usage** + https://developer.cisco.com/meraki/api-v1/#!create-device-live-tools-power-usage + + - serial (string): Serial + - callback (object): Details for the callback. Please include either an httpServerId OR url and sharedSecret + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["devices", "liveTools", "power", "usage"], + "operation": "createDeviceLiveToolsPowerUsage", + } + serial = urllib.parse.quote(str(serial), safe="") + resource = f"/devices/{serial}/liveTools/power/usage" + + body_params = [ + "callback", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning(f"createDeviceLiveToolsPowerUsage: ignoring unrecognized kwargs: {invalid}") + + return self._session.post(metadata, resource, payload) + + def getDeviceLiveToolsPowerUsage(self, serial: str, jobId: str): + """ + **Retrieve the status and results of a previously created live tool job fetching details about a device's overall power usage.** + https://developer.cisco.com/meraki/api-v1/#!get-device-live-tools-power-usage + + - serial (string): Serial + - jobId (string): Job ID + """ + + metadata = { + "tags": ["devices", "liveTools", "power", "usage"], + "operation": "getDeviceLiveToolsPowerUsage", + } + serial = urllib.parse.quote(str(serial), safe="") + jobId = urllib.parse.quote(str(jobId), safe="") + resource = f"/devices/{serial}/liveTools/power/usage/{jobId}" + + return self._session.get(metadata, resource) + + def createDeviceLiveToolsRoutingTableLookup(self, serial: str, **kwargs): + """ + **Enqueue a job to perform a routing table lookup request for a device** + https://developer.cisco.com/meraki/api-v1/#!create-device-live-tools-routing-table-lookup + + - serial (string): Serial + - type (string): The type of route defined + - destination (object): The destination IP or subnet to lookup + - nextHop (object): The next hop to lookup + - vpn (object): VPN related search criteria + - callback (object): Details for the callback. Please include either an httpServerId OR url and sharedSecret + """ + + kwargs.update(locals()) + + if "type" in kwargs: + options = [ + "BGP", + "EIGRP", + "HSRP", + "IGRP", + "ISIS", + "LISP", + "NAT", + "ND", + "NHRP", + "OMP", + "OSPF", + "RIP", + "default WAN", + "direct", + "static", + ] + assert kwargs["type"] in options, f'''"type" cannot be "{kwargs["type"]}", & must be set to one of: {options}''' + + metadata = { + "tags": ["devices", "liveTools", "routingTable", "lookups"], + "operation": "createDeviceLiveToolsRoutingTableLookup", + } + serial = urllib.parse.quote(str(serial), safe="") + resource = f"/devices/{serial}/liveTools/routingTable/lookups" + + body_params = [ + "type", + "destination", + "nextHop", + "vpn", + "callback", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"createDeviceLiveToolsRoutingTableLookup: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.post(metadata, resource, payload) + + def getDeviceLiveToolsRoutingTableLookup(self, serial: str, id: str): + """ + **Return a routing table live tool lookup job for a device** + https://developer.cisco.com/meraki/api-v1/#!get-device-live-tools-routing-table-lookup + + - serial (string): Serial + - id (string): ID + """ + + metadata = { + "tags": ["devices", "liveTools", "routingTable", "lookups"], + "operation": "getDeviceLiveToolsRoutingTableLookup", + } + serial = urllib.parse.quote(str(serial), safe="") + id = urllib.parse.quote(str(id), safe="") + resource = f"/devices/{serial}/liveTools/routingTable/lookups/{id}" + + return self._session.get(metadata, resource) + + def createDeviceLiveToolsRoutingTableSummary(self, serial: str, **kwargs): + """ + **Enqueue a routing table summary job for a device** + https://developer.cisco.com/meraki/api-v1/#!create-device-live-tools-routing-table-summary + + - serial (string): Serial + - callback (object): Details for the callback. Please include either an httpServerId OR url and sharedSecret + """ + + kwargs.update(locals()) + + metadata = { + "tags": ["devices", "liveTools", "routingTable", "summaries"], + "operation": "createDeviceLiveToolsRoutingTableSummary", + } + serial = urllib.parse.quote(str(serial), safe="") + resource = f"/devices/{serial}/liveTools/routingTable/summaries" + + body_params = [ + "callback", + ] + payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} + + if self._session._validate_kwargs: + all_params = [] + body_params + invalid = [k for k in kwargs if k.strip() not in all_params and k != "self"] + if invalid and self._session._logger: + self._session._logger.warning( + f"createDeviceLiveToolsRoutingTableSummary: ignoring unrecognized kwargs: {invalid}" + ) + + return self._session.post(metadata, resource, payload) + + def getDeviceLiveToolsRoutingTableSummary(self, serial: str, id: str): + """ + **Return the status and result of a routing table summary job** + https://developer.cisco.com/meraki/api-v1/#!get-device-live-tools-routing-table-summary + + - serial (string): Serial + - id (string): ID + """ + + metadata = { + "tags": ["devices", "liveTools", "routingTable", "summaries"], + "operation": "getDeviceLiveToolsRoutingTableSummary", + } + serial = urllib.parse.quote(str(serial), safe="") + id = urllib.parse.quote(str(id), safe="") + resource = f"/devices/{serial}/liveTools/routingTable/summaries/{id}" + + return self._session.get(metadata, resource) + def createDeviceLiveToolsThroughputTest(self, serial: str, **kwargs): """ **Enqueue a job to test a device throughput, the test will run for 10 secs to test throughput** diff --git a/meraki/api/networks.py b/meraki/api/networks.py index eb8ae8e4..9acaa98a 100644 --- a/meraki/api/networks.py +++ b/meraki/api/networks.py @@ -2661,6 +2661,8 @@ def updateNetworkSnmp(self, networkId: str, **kwargs): - access (string): The type of SNMP access. Can be one of 'none' (disabled), 'community' (V1/V2c), or 'users' (V3). - communityString (string): The SNMP community string. Only relevant if 'access' is set to 'community'. - users (array): The list of SNMP users. Only relevant if 'access' is set to 'users'. + - authentication (object): SNMPv3 authentication settings. Only relevant if 'access' is set to 'users'. + - privacy (object): SNMPv3 privacy settings. Only relevant if 'access' is set to 'users'. """ kwargs.update(locals()) @@ -2682,6 +2684,8 @@ def updateNetworkSnmp(self, networkId: str, **kwargs): "access", "communityString", "users", + "authentication", + "privacy", ] payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} diff --git a/meraki/api/organizations.py b/meraki/api/organizations.py index ae425f85..713c6f39 100644 --- a/meraki/api/organizations.py +++ b/meraki/api/organizations.py @@ -98,6 +98,7 @@ def updateOrganization(self, organizationId: str, **kwargs): - name (string): The name of the organization - management (object): Information about the organization's management system - api (object): API-specific settings + - privacy (object): Privacy-related settings for the organization. """ kwargs.update(locals()) @@ -113,6 +114,7 @@ def updateOrganization(self, organizationId: str, **kwargs): "name", "management", "api", + "privacy", ] payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} @@ -5471,6 +5473,7 @@ def updateOrganizationLoginSecurity(self, organizationId: str, **kwargs): - enforceTwoFactorAuth (boolean): Boolean indicating whether users in this organization will be required to use an extra verification code when logging in to Dashboard. This code will be sent to their mobile phone via SMS, or can be generated by the authenticator application. - enforceLoginIpRanges (boolean): Boolean indicating whether organization will restrict access to Dashboard (including the API) from certain IP addresses. - loginIpRanges (array): List of acceptable IP ranges. Entries can be single IP addresses, IP address ranges, and CIDR subnets. + - enforceLockedIpSessions (boolean): Boolean indicating whether Dashboard sessions are locked to the IP address from which they were established. Only applicable to organizations that support locked-IP sessions; otherwise the parameter is ignored. - apiAuthentication (object): Details for indicating whether organization will restrict access to API (but not Dashboard) to certain IP addresses. """ @@ -5497,6 +5500,7 @@ def updateOrganizationLoginSecurity(self, organizationId: str, **kwargs): "enforceTwoFactorAuth", "enforceLoginIpRanges", "loginIpRanges", + "enforceLockedIpSessions", "apiAuthentication", ] payload = {k.strip(): v for k, v in kwargs.items() if k.strip() in body_params} diff --git a/meraki/api/wireless.py b/meraki/api/wireless.py index 6ec80c8e..00afe6d7 100644 --- a/meraki/api/wireless.py +++ b/meraki/api/wireless.py @@ -2274,7 +2274,7 @@ def updateNetworkWirelessSsid(self, networkId: str, number: str, **kwargs): - radiusServerTimeout (integer): The amount of time for which a RADIUS client waits for a reply from the RADIUS server (must be between 1-10 seconds). - radiusServerAttemptsLimit (integer): The maximum number of transmit attempts after which a RADIUS server is failed over (must be between 1-5). - radiusFallbackEnabled (boolean): Whether or not higher priority RADIUS servers should be retried after 60 seconds. - - radiusRadsec (object): The current settings for RADIUS RADSec + - radiusRadsec (object): The current settings for RADIUS RadSec - radiusCoaEnabled (boolean): If true, Meraki devices will act as a RADIUS Dynamic Authorization Server and will respond to RADIUS Change-of-Authorization and Disconnect messages sent by the RADIUS server. - radiusFailoverPolicy (string): This policy determines how authentication requests should be handled in the event that all of the configured RADIUS servers are unreachable ('Deny access' or 'Allow access') - radiusLoadBalancingPolicy (string): This policy determines which RADIUS server will be contacted first in an authentication attempt and the ordering of any necessary retry attempts ('Strict priority order' or 'Round robin') @@ -3103,6 +3103,7 @@ def updateNetworkWirelessSsidSplashSettings(self, networkId: str, number: str, * - redirectUrl (string): The custom redirect URL where the users will go after the splash page. - useRedirectUrl (boolean): The Boolean indicating whether the the user will be redirected to the custom redirect URL after the splash page. A custom redirect URL must be set if this is true. - welcomeMessage (string): The welcome message for the users on the splash page. + - userConsent (object): User consent settings - themeId (string): The id of the selected splash theme. - splashLogo (object): The logo used in the splash page. - splashImage (object): The image used in the splash page. @@ -3144,6 +3145,7 @@ def updateNetworkWirelessSsidSplashSettings(self, networkId: str, number: str, * "redirectUrl", "useRedirectUrl", "welcomeMessage", + "userConsent", "themeId", "splashLogo", "splashImage", @@ -4235,7 +4237,7 @@ def deleteOrganizationWirelessDevicesProvisioningDeployment(self, organizationId def getOrganizationWirelessDevicesRadsecCertificatesAuthorities(self, organizationId: str, **kwargs): """ - **Query for details on the organization's RADSEC device Certificate Authority certificates (CAs)** + **Query for details on the organization's RadSec device Certificate Authority certificates (CAs)** https://developer.cisco.com/meraki/api-v1/#!get-organization-wireless-devices-radsec-certificates-authorities - organizationId (string): Organization ID @@ -4276,7 +4278,7 @@ def getOrganizationWirelessDevicesRadsecCertificatesAuthorities(self, organizati def updateOrganizationWirelessDevicesRadsecCertificatesAuthorities(self, organizationId: str, **kwargs): """ - **Update an organization's RADSEC device Certificate Authority (CA) state** + **Update an organization's RadSec device Certificate Authority (CA) state** https://developer.cisco.com/meraki/api-v1/#!update-organization-wireless-devices-radsec-certificates-authorities - organizationId (string): Organization ID @@ -4311,7 +4313,7 @@ def updateOrganizationWirelessDevicesRadsecCertificatesAuthorities(self, organiz def createOrganizationWirelessDevicesRadsecCertificatesAuthority(self, organizationId: str): """ - **Create an organization's RADSEC device Certificate Authority (CA)** + **Create an organization's RadSec device Certificate Authority (CA)** https://developer.cisco.com/meraki/api-v1/#!create-organization-wireless-devices-radsec-certificates-authority - organizationId (string): Organization ID @@ -4328,7 +4330,7 @@ def createOrganizationWirelessDevicesRadsecCertificatesAuthority(self, organizat def getOrganizationWirelessDevicesRadsecCertificatesAuthoritiesCrls(self, organizationId: str, **kwargs): """ - **Query for certificate revocation list (CRL) for the organization's RADSEC device Certificate Authorities (CAs).** + **Query for certificate revocation list (CRL) for the organization's RadSec device Certificate Authorities (CAs).** https://developer.cisco.com/meraki/api-v1/#!get-organization-wireless-devices-radsec-certificates-authorities-crls - organizationId (string): Organization ID @@ -4369,7 +4371,7 @@ def getOrganizationWirelessDevicesRadsecCertificatesAuthoritiesCrls(self, organi def getOrganizationWirelessDevicesRadsecCertificatesAuthoritiesCrlsDeltas(self, organizationId: str, **kwargs): """ - **Query for all delta certificate revocation list (CRL) for the organization's RADSEC device Certificate Authority (CA) with the given id.** + **Query for all delta certificate revocation list (CRL) for the organization's RadSec device Certificate Authority (CA) with the given id.** https://developer.cisco.com/meraki/api-v1/#!get-organization-wireless-devices-radsec-certificates-authorities-crls-deltas - organizationId (string): Organization ID diff --git a/pyproject.toml b/pyproject.toml index 1e2592ce..bd3071a4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "meraki" -version = "3.1.0" +version = "3.2.0" description = "Cisco Meraki Dashboard API library" authors = [ {name = "Cisco Meraki", email = "api-feedback@meraki.net"} diff --git a/uv.lock b/uv.lock index 3aa0e840..e67da646 100644 --- a/uv.lock +++ b/uv.lock @@ -537,7 +537,7 @@ wheels = [ [[package]] name = "meraki" -version = "3.1.0" +version = "3.2.0" source = { editable = "." } dependencies = [ { name = "aiohttp" },