# AUTO-GENERATED file from IFMapApiGenerator. Do Not Edit!

class ResourceApiGen(object):
    def pre_domain_create(self, resource_dict):
        """
        Method called before domain is created
        """
        pass
    #end pre_domain_create

    def post_domain_create(self, resource_dict):
        """
        Method called after domain is created
        """
        pass
    #end post_domain_create

    def pre_domain_read(self, resource_id):
        """
        Method called before domain is read
        """
        pass
    #end pre_domain_read

    def post_domain_read(self, resource_id, resource_dict):
        """
        Method called after domain is read
        """
        pass
    #end post_domain_read

    def pre_domain_update(self, resource_id, resource_dict):
        """
        Method called before domain is updated
        """
        pass
    #end pre_domain_update

    def post_domain_update(self, resource_id, resource_dict):
        """
        Method called after domain is updated
        """
        pass
    #end post_domain_update

    def pre_domain_delete(self, resource_id):
        """
        Method called before domain is deleted
        """
        pass
    #end pre_domain_delete

    def post_domain_delete(self, resource_id, resource_dict):
        """
        Method called after domain is deleted
        """
        pass
    #end post_domain_delete

    def pre_global_vrouter_config_create(self, resource_dict):
        """
        Method called before global-vrouter-config is created
        """
        pass
    #end pre_global_vrouter_config_create

    def post_global_vrouter_config_create(self, resource_dict):
        """
        Method called after global-vrouter-config is created
        """
        pass
    #end post_global_vrouter_config_create

    def pre_global_vrouter_config_read(self, resource_id):
        """
        Method called before global-vrouter-config is read
        """
        pass
    #end pre_global_vrouter_config_read

    def post_global_vrouter_config_read(self, resource_id, resource_dict):
        """
        Method called after global-vrouter-config is read
        """
        pass
    #end post_global_vrouter_config_read

    def pre_global_vrouter_config_update(self, resource_id, resource_dict):
        """
        Method called before global-vrouter-config is updated
        """
        pass
    #end pre_global_vrouter_config_update

    def post_global_vrouter_config_update(self, resource_id, resource_dict):
        """
        Method called after global-vrouter-config is updated
        """
        pass
    #end post_global_vrouter_config_update

    def pre_global_vrouter_config_delete(self, resource_id):
        """
        Method called before global-vrouter-config is deleted
        """
        pass
    #end pre_global_vrouter_config_delete

    def post_global_vrouter_config_delete(self, resource_id, resource_dict):
        """
        Method called after global-vrouter-config is deleted
        """
        pass
    #end post_global_vrouter_config_delete

    def pre_instance_ip_create(self, resource_dict):
        """
        Method called before instance-ip is created
        """
        pass
    #end pre_instance_ip_create

    def post_instance_ip_create(self, resource_dict):
        """
        Method called after instance-ip is created
        """
        pass
    #end post_instance_ip_create

    def pre_instance_ip_read(self, resource_id):
        """
        Method called before instance-ip is read
        """
        pass
    #end pre_instance_ip_read

    def post_instance_ip_read(self, resource_id, resource_dict):
        """
        Method called after instance-ip is read
        """
        pass
    #end post_instance_ip_read

    def pre_instance_ip_update(self, resource_id, resource_dict):
        """
        Method called before instance-ip is updated
        """
        pass
    #end pre_instance_ip_update

    def post_instance_ip_update(self, resource_id, resource_dict):
        """
        Method called after instance-ip is updated
        """
        pass
    #end post_instance_ip_update

    def pre_instance_ip_delete(self, resource_id):
        """
        Method called before instance-ip is deleted
        """
        pass
    #end pre_instance_ip_delete

    def post_instance_ip_delete(self, resource_id, resource_dict):
        """
        Method called after instance-ip is deleted
        """
        pass
    #end post_instance_ip_delete

    def pre_network_policy_create(self, resource_dict):
        """
        Method called before network-policy is created
        """
        pass
    #end pre_network_policy_create

    def post_network_policy_create(self, resource_dict):
        """
        Method called after network-policy is created
        """
        pass
    #end post_network_policy_create

    def pre_network_policy_read(self, resource_id):
        """
        Method called before network-policy is read
        """
        pass
    #end pre_network_policy_read

    def post_network_policy_read(self, resource_id, resource_dict):
        """
        Method called after network-policy is read
        """
        pass
    #end post_network_policy_read

    def pre_network_policy_update(self, resource_id, resource_dict):
        """
        Method called before network-policy is updated
        """
        pass
    #end pre_network_policy_update

    def post_network_policy_update(self, resource_id, resource_dict):
        """
        Method called after network-policy is updated
        """
        pass
    #end post_network_policy_update

    def pre_network_policy_delete(self, resource_id):
        """
        Method called before network-policy is deleted
        """
        pass
    #end pre_network_policy_delete

    def post_network_policy_delete(self, resource_id, resource_dict):
        """
        Method called after network-policy is deleted
        """
        pass
    #end post_network_policy_delete

    def pre_loadbalancer_pool_create(self, resource_dict):
        """
        Method called before loadbalancer-pool is created
        """
        pass
    #end pre_loadbalancer_pool_create

    def post_loadbalancer_pool_create(self, resource_dict):
        """
        Method called after loadbalancer-pool is created
        """
        pass
    #end post_loadbalancer_pool_create

    def pre_loadbalancer_pool_read(self, resource_id):
        """
        Method called before loadbalancer-pool is read
        """
        pass
    #end pre_loadbalancer_pool_read

    def post_loadbalancer_pool_read(self, resource_id, resource_dict):
        """
        Method called after loadbalancer-pool is read
        """
        pass
    #end post_loadbalancer_pool_read

    def pre_loadbalancer_pool_update(self, resource_id, resource_dict):
        """
        Method called before loadbalancer-pool is updated
        """
        pass
    #end pre_loadbalancer_pool_update

    def post_loadbalancer_pool_update(self, resource_id, resource_dict):
        """
        Method called after loadbalancer-pool is updated
        """
        pass
    #end post_loadbalancer_pool_update

    def pre_loadbalancer_pool_delete(self, resource_id):
        """
        Method called before loadbalancer-pool is deleted
        """
        pass
    #end pre_loadbalancer_pool_delete

    def post_loadbalancer_pool_delete(self, resource_id, resource_dict):
        """
        Method called after loadbalancer-pool is deleted
        """
        pass
    #end post_loadbalancer_pool_delete

    def pre_virtual_DNS_record_create(self, resource_dict):
        """
        Method called before virtual-DNS-record is created
        """
        pass
    #end pre_virtual_DNS_record_create

    def post_virtual_DNS_record_create(self, resource_dict):
        """
        Method called after virtual-DNS-record is created
        """
        pass
    #end post_virtual_DNS_record_create

    def pre_virtual_DNS_record_read(self, resource_id):
        """
        Method called before virtual-DNS-record is read
        """
        pass
    #end pre_virtual_DNS_record_read

    def post_virtual_DNS_record_read(self, resource_id, resource_dict):
        """
        Method called after virtual-DNS-record is read
        """
        pass
    #end post_virtual_DNS_record_read

    def pre_virtual_DNS_record_update(self, resource_id, resource_dict):
        """
        Method called before virtual-DNS-record is updated
        """
        pass
    #end pre_virtual_DNS_record_update

    def post_virtual_DNS_record_update(self, resource_id, resource_dict):
        """
        Method called after virtual-DNS-record is updated
        """
        pass
    #end post_virtual_DNS_record_update

    def pre_virtual_DNS_record_delete(self, resource_id):
        """
        Method called before virtual-DNS-record is deleted
        """
        pass
    #end pre_virtual_DNS_record_delete

    def post_virtual_DNS_record_delete(self, resource_id, resource_dict):
        """
        Method called after virtual-DNS-record is deleted
        """
        pass
    #end post_virtual_DNS_record_delete

    def pre_route_target_create(self, resource_dict):
        """
        Method called before route-target is created
        """
        pass
    #end pre_route_target_create

    def post_route_target_create(self, resource_dict):
        """
        Method called after route-target is created
        """
        pass
    #end post_route_target_create

    def pre_route_target_read(self, resource_id):
        """
        Method called before route-target is read
        """
        pass
    #end pre_route_target_read

    def post_route_target_read(self, resource_id, resource_dict):
        """
        Method called after route-target is read
        """
        pass
    #end post_route_target_read

    def pre_route_target_update(self, resource_id, resource_dict):
        """
        Method called before route-target is updated
        """
        pass
    #end pre_route_target_update

    def post_route_target_update(self, resource_id, resource_dict):
        """
        Method called after route-target is updated
        """
        pass
    #end post_route_target_update

    def pre_route_target_delete(self, resource_id):
        """
        Method called before route-target is deleted
        """
        pass
    #end pre_route_target_delete

    def post_route_target_delete(self, resource_id, resource_dict):
        """
        Method called after route-target is deleted
        """
        pass
    #end post_route_target_delete

    def pre_floating_ip_create(self, resource_dict):
        """
        Method called before floating-ip is created
        """
        pass
    #end pre_floating_ip_create

    def post_floating_ip_create(self, resource_dict):
        """
        Method called after floating-ip is created
        """
        pass
    #end post_floating_ip_create

    def pre_floating_ip_read(self, resource_id):
        """
        Method called before floating-ip is read
        """
        pass
    #end pre_floating_ip_read

    def post_floating_ip_read(self, resource_id, resource_dict):
        """
        Method called after floating-ip is read
        """
        pass
    #end post_floating_ip_read

    def pre_floating_ip_update(self, resource_id, resource_dict):
        """
        Method called before floating-ip is updated
        """
        pass
    #end pre_floating_ip_update

    def post_floating_ip_update(self, resource_id, resource_dict):
        """
        Method called after floating-ip is updated
        """
        pass
    #end post_floating_ip_update

    def pre_floating_ip_delete(self, resource_id):
        """
        Method called before floating-ip is deleted
        """
        pass
    #end pre_floating_ip_delete

    def post_floating_ip_delete(self, resource_id, resource_dict):
        """
        Method called after floating-ip is deleted
        """
        pass
    #end post_floating_ip_delete

    def pre_floating_ip_pool_create(self, resource_dict):
        """
        Method called before floating-ip-pool is created
        """
        pass
    #end pre_floating_ip_pool_create

    def post_floating_ip_pool_create(self, resource_dict):
        """
        Method called after floating-ip-pool is created
        """
        pass
    #end post_floating_ip_pool_create

    def pre_floating_ip_pool_read(self, resource_id):
        """
        Method called before floating-ip-pool is read
        """
        pass
    #end pre_floating_ip_pool_read

    def post_floating_ip_pool_read(self, resource_id, resource_dict):
        """
        Method called after floating-ip-pool is read
        """
        pass
    #end post_floating_ip_pool_read

    def pre_floating_ip_pool_update(self, resource_id, resource_dict):
        """
        Method called before floating-ip-pool is updated
        """
        pass
    #end pre_floating_ip_pool_update

    def post_floating_ip_pool_update(self, resource_id, resource_dict):
        """
        Method called after floating-ip-pool is updated
        """
        pass
    #end post_floating_ip_pool_update

    def pre_floating_ip_pool_delete(self, resource_id):
        """
        Method called before floating-ip-pool is deleted
        """
        pass
    #end pre_floating_ip_pool_delete

    def post_floating_ip_pool_delete(self, resource_id, resource_dict):
        """
        Method called after floating-ip-pool is deleted
        """
        pass
    #end post_floating_ip_pool_delete

    def pre_physical_router_create(self, resource_dict):
        """
        Method called before physical-router is created
        """
        pass
    #end pre_physical_router_create

    def post_physical_router_create(self, resource_dict):
        """
        Method called after physical-router is created
        """
        pass
    #end post_physical_router_create

    def pre_physical_router_read(self, resource_id):
        """
        Method called before physical-router is read
        """
        pass
    #end pre_physical_router_read

    def post_physical_router_read(self, resource_id, resource_dict):
        """
        Method called after physical-router is read
        """
        pass
    #end post_physical_router_read

    def pre_physical_router_update(self, resource_id, resource_dict):
        """
        Method called before physical-router is updated
        """
        pass
    #end pre_physical_router_update

    def post_physical_router_update(self, resource_id, resource_dict):
        """
        Method called after physical-router is updated
        """
        pass
    #end post_physical_router_update

    def pre_physical_router_delete(self, resource_id):
        """
        Method called before physical-router is deleted
        """
        pass
    #end pre_physical_router_delete

    def post_physical_router_delete(self, resource_id, resource_dict):
        """
        Method called after physical-router is deleted
        """
        pass
    #end post_physical_router_delete

    def pre_bgp_router_create(self, resource_dict):
        """
        Method called before bgp-router is created
        """
        pass
    #end pre_bgp_router_create

    def post_bgp_router_create(self, resource_dict):
        """
        Method called after bgp-router is created
        """
        pass
    #end post_bgp_router_create

    def pre_bgp_router_read(self, resource_id):
        """
        Method called before bgp-router is read
        """
        pass
    #end pre_bgp_router_read

    def post_bgp_router_read(self, resource_id, resource_dict):
        """
        Method called after bgp-router is read
        """
        pass
    #end post_bgp_router_read

    def pre_bgp_router_update(self, resource_id, resource_dict):
        """
        Method called before bgp-router is updated
        """
        pass
    #end pre_bgp_router_update

    def post_bgp_router_update(self, resource_id, resource_dict):
        """
        Method called after bgp-router is updated
        """
        pass
    #end post_bgp_router_update

    def pre_bgp_router_delete(self, resource_id):
        """
        Method called before bgp-router is deleted
        """
        pass
    #end pre_bgp_router_delete

    def post_bgp_router_delete(self, resource_id, resource_dict):
        """
        Method called after bgp-router is deleted
        """
        pass
    #end post_bgp_router_delete

    def pre_virtual_router_create(self, resource_dict):
        """
        Method called before virtual-router is created
        """
        pass
    #end pre_virtual_router_create

    def post_virtual_router_create(self, resource_dict):
        """
        Method called after virtual-router is created
        """
        pass
    #end post_virtual_router_create

    def pre_virtual_router_read(self, resource_id):
        """
        Method called before virtual-router is read
        """
        pass
    #end pre_virtual_router_read

    def post_virtual_router_read(self, resource_id, resource_dict):
        """
        Method called after virtual-router is read
        """
        pass
    #end post_virtual_router_read

    def pre_virtual_router_update(self, resource_id, resource_dict):
        """
        Method called before virtual-router is updated
        """
        pass
    #end pre_virtual_router_update

    def post_virtual_router_update(self, resource_id, resource_dict):
        """
        Method called after virtual-router is updated
        """
        pass
    #end post_virtual_router_update

    def pre_virtual_router_delete(self, resource_id):
        """
        Method called before virtual-router is deleted
        """
        pass
    #end pre_virtual_router_delete

    def post_virtual_router_delete(self, resource_id, resource_dict):
        """
        Method called after virtual-router is deleted
        """
        pass
    #end post_virtual_router_delete

    def pre_config_root_create(self, resource_dict):
        """
        Method called before config-root is created
        """
        pass
    #end pre_config_root_create

    def post_config_root_create(self, resource_dict):
        """
        Method called after config-root is created
        """
        pass
    #end post_config_root_create

    def pre_config_root_read(self, resource_id):
        """
        Method called before config-root is read
        """
        pass
    #end pre_config_root_read

    def post_config_root_read(self, resource_id, resource_dict):
        """
        Method called after config-root is read
        """
        pass
    #end post_config_root_read

    def pre_config_root_update(self, resource_id, resource_dict):
        """
        Method called before config-root is updated
        """
        pass
    #end pre_config_root_update

    def post_config_root_update(self, resource_id, resource_dict):
        """
        Method called after config-root is updated
        """
        pass
    #end post_config_root_update

    def pre_config_root_delete(self, resource_id):
        """
        Method called before config-root is deleted
        """
        pass
    #end pre_config_root_delete

    def post_config_root_delete(self, resource_id, resource_dict):
        """
        Method called after config-root is deleted
        """
        pass
    #end post_config_root_delete

    def pre_subnet_create(self, resource_dict):
        """
        Method called before subnet is created
        """
        pass
    #end pre_subnet_create

    def post_subnet_create(self, resource_dict):
        """
        Method called after subnet is created
        """
        pass
    #end post_subnet_create

    def pre_subnet_read(self, resource_id):
        """
        Method called before subnet is read
        """
        pass
    #end pre_subnet_read

    def post_subnet_read(self, resource_id, resource_dict):
        """
        Method called after subnet is read
        """
        pass
    #end post_subnet_read

    def pre_subnet_update(self, resource_id, resource_dict):
        """
        Method called before subnet is updated
        """
        pass
    #end pre_subnet_update

    def post_subnet_update(self, resource_id, resource_dict):
        """
        Method called after subnet is updated
        """
        pass
    #end post_subnet_update

    def pre_subnet_delete(self, resource_id):
        """
        Method called before subnet is deleted
        """
        pass
    #end pre_subnet_delete

    def post_subnet_delete(self, resource_id, resource_dict):
        """
        Method called after subnet is deleted
        """
        pass
    #end post_subnet_delete

    def pre_global_system_config_create(self, resource_dict):
        """
        Method called before global-system-config is created
        """
        pass
    #end pre_global_system_config_create

    def post_global_system_config_create(self, resource_dict):
        """
        Method called after global-system-config is created
        """
        pass
    #end post_global_system_config_create

    def pre_global_system_config_read(self, resource_id):
        """
        Method called before global-system-config is read
        """
        pass
    #end pre_global_system_config_read

    def post_global_system_config_read(self, resource_id, resource_dict):
        """
        Method called after global-system-config is read
        """
        pass
    #end post_global_system_config_read

    def pre_global_system_config_update(self, resource_id, resource_dict):
        """
        Method called before global-system-config is updated
        """
        pass
    #end pre_global_system_config_update

    def post_global_system_config_update(self, resource_id, resource_dict):
        """
        Method called after global-system-config is updated
        """
        pass
    #end post_global_system_config_update

    def pre_global_system_config_delete(self, resource_id):
        """
        Method called before global-system-config is deleted
        """
        pass
    #end pre_global_system_config_delete

    def post_global_system_config_delete(self, resource_id, resource_dict):
        """
        Method called after global-system-config is deleted
        """
        pass
    #end post_global_system_config_delete

    def pre_service_appliance_create(self, resource_dict):
        """
        Method called before service-appliance is created
        """
        pass
    #end pre_service_appliance_create

    def post_service_appliance_create(self, resource_dict):
        """
        Method called after service-appliance is created
        """
        pass
    #end post_service_appliance_create

    def pre_service_appliance_read(self, resource_id):
        """
        Method called before service-appliance is read
        """
        pass
    #end pre_service_appliance_read

    def post_service_appliance_read(self, resource_id, resource_dict):
        """
        Method called after service-appliance is read
        """
        pass
    #end post_service_appliance_read

    def pre_service_appliance_update(self, resource_id, resource_dict):
        """
        Method called before service-appliance is updated
        """
        pass
    #end pre_service_appliance_update

    def post_service_appliance_update(self, resource_id, resource_dict):
        """
        Method called after service-appliance is updated
        """
        pass
    #end post_service_appliance_update

    def pre_service_appliance_delete(self, resource_id):
        """
        Method called before service-appliance is deleted
        """
        pass
    #end pre_service_appliance_delete

    def post_service_appliance_delete(self, resource_id, resource_dict):
        """
        Method called after service-appliance is deleted
        """
        pass
    #end post_service_appliance_delete

    def pre_service_instance_create(self, resource_dict):
        """
        Method called before service-instance is created
        """
        pass
    #end pre_service_instance_create

    def post_service_instance_create(self, resource_dict):
        """
        Method called after service-instance is created
        """
        pass
    #end post_service_instance_create

    def pre_service_instance_read(self, resource_id):
        """
        Method called before service-instance is read
        """
        pass
    #end pre_service_instance_read

    def post_service_instance_read(self, resource_id, resource_dict):
        """
        Method called after service-instance is read
        """
        pass
    #end post_service_instance_read

    def pre_service_instance_update(self, resource_id, resource_dict):
        """
        Method called before service-instance is updated
        """
        pass
    #end pre_service_instance_update

    def post_service_instance_update(self, resource_id, resource_dict):
        """
        Method called after service-instance is updated
        """
        pass
    #end post_service_instance_update

    def pre_service_instance_delete(self, resource_id):
        """
        Method called before service-instance is deleted
        """
        pass
    #end pre_service_instance_delete

    def post_service_instance_delete(self, resource_id, resource_dict):
        """
        Method called after service-instance is deleted
        """
        pass
    #end post_service_instance_delete

    def pre_namespace_create(self, resource_dict):
        """
        Method called before namespace is created
        """
        pass
    #end pre_namespace_create

    def post_namespace_create(self, resource_dict):
        """
        Method called after namespace is created
        """
        pass
    #end post_namespace_create

    def pre_namespace_read(self, resource_id):
        """
        Method called before namespace is read
        """
        pass
    #end pre_namespace_read

    def post_namespace_read(self, resource_id, resource_dict):
        """
        Method called after namespace is read
        """
        pass
    #end post_namespace_read

    def pre_namespace_update(self, resource_id, resource_dict):
        """
        Method called before namespace is updated
        """
        pass
    #end pre_namespace_update

    def post_namespace_update(self, resource_id, resource_dict):
        """
        Method called after namespace is updated
        """
        pass
    #end post_namespace_update

    def pre_namespace_delete(self, resource_id):
        """
        Method called before namespace is deleted
        """
        pass
    #end pre_namespace_delete

    def post_namespace_delete(self, resource_id, resource_dict):
        """
        Method called after namespace is deleted
        """
        pass
    #end post_namespace_delete

    def pre_logical_interface_create(self, resource_dict):
        """
        Method called before logical-interface is created
        """
        pass
    #end pre_logical_interface_create

    def post_logical_interface_create(self, resource_dict):
        """
        Method called after logical-interface is created
        """
        pass
    #end post_logical_interface_create

    def pre_logical_interface_read(self, resource_id):
        """
        Method called before logical-interface is read
        """
        pass
    #end pre_logical_interface_read

    def post_logical_interface_read(self, resource_id, resource_dict):
        """
        Method called after logical-interface is read
        """
        pass
    #end post_logical_interface_read

    def pre_logical_interface_update(self, resource_id, resource_dict):
        """
        Method called before logical-interface is updated
        """
        pass
    #end pre_logical_interface_update

    def post_logical_interface_update(self, resource_id, resource_dict):
        """
        Method called after logical-interface is updated
        """
        pass
    #end post_logical_interface_update

    def pre_logical_interface_delete(self, resource_id):
        """
        Method called before logical-interface is deleted
        """
        pass
    #end pre_logical_interface_delete

    def post_logical_interface_delete(self, resource_id, resource_dict):
        """
        Method called after logical-interface is deleted
        """
        pass
    #end post_logical_interface_delete

    def pre_route_table_create(self, resource_dict):
        """
        Method called before route-table is created
        """
        pass
    #end pre_route_table_create

    def post_route_table_create(self, resource_dict):
        """
        Method called after route-table is created
        """
        pass
    #end post_route_table_create

    def pre_route_table_read(self, resource_id):
        """
        Method called before route-table is read
        """
        pass
    #end pre_route_table_read

    def post_route_table_read(self, resource_id, resource_dict):
        """
        Method called after route-table is read
        """
        pass
    #end post_route_table_read

    def pre_route_table_update(self, resource_id, resource_dict):
        """
        Method called before route-table is updated
        """
        pass
    #end pre_route_table_update

    def post_route_table_update(self, resource_id, resource_dict):
        """
        Method called after route-table is updated
        """
        pass
    #end post_route_table_update

    def pre_route_table_delete(self, resource_id):
        """
        Method called before route-table is deleted
        """
        pass
    #end pre_route_table_delete

    def post_route_table_delete(self, resource_id, resource_dict):
        """
        Method called after route-table is deleted
        """
        pass
    #end post_route_table_delete

    def pre_physical_interface_create(self, resource_dict):
        """
        Method called before physical-interface is created
        """
        pass
    #end pre_physical_interface_create

    def post_physical_interface_create(self, resource_dict):
        """
        Method called after physical-interface is created
        """
        pass
    #end post_physical_interface_create

    def pre_physical_interface_read(self, resource_id):
        """
        Method called before physical-interface is read
        """
        pass
    #end pre_physical_interface_read

    def post_physical_interface_read(self, resource_id, resource_dict):
        """
        Method called after physical-interface is read
        """
        pass
    #end post_physical_interface_read

    def pre_physical_interface_update(self, resource_id, resource_dict):
        """
        Method called before physical-interface is updated
        """
        pass
    #end pre_physical_interface_update

    def post_physical_interface_update(self, resource_id, resource_dict):
        """
        Method called after physical-interface is updated
        """
        pass
    #end post_physical_interface_update

    def pre_physical_interface_delete(self, resource_id):
        """
        Method called before physical-interface is deleted
        """
        pass
    #end pre_physical_interface_delete

    def post_physical_interface_delete(self, resource_id, resource_dict):
        """
        Method called after physical-interface is deleted
        """
        pass
    #end post_physical_interface_delete

    def pre_access_control_list_create(self, resource_dict):
        """
        Method called before access-control-list is created
        """
        pass
    #end pre_access_control_list_create

    def post_access_control_list_create(self, resource_dict):
        """
        Method called after access-control-list is created
        """
        pass
    #end post_access_control_list_create

    def pre_access_control_list_read(self, resource_id):
        """
        Method called before access-control-list is read
        """
        pass
    #end pre_access_control_list_read

    def post_access_control_list_read(self, resource_id, resource_dict):
        """
        Method called after access-control-list is read
        """
        pass
    #end post_access_control_list_read

    def pre_access_control_list_update(self, resource_id, resource_dict):
        """
        Method called before access-control-list is updated
        """
        pass
    #end pre_access_control_list_update

    def post_access_control_list_update(self, resource_id, resource_dict):
        """
        Method called after access-control-list is updated
        """
        pass
    #end post_access_control_list_update

    def pre_access_control_list_delete(self, resource_id):
        """
        Method called before access-control-list is deleted
        """
        pass
    #end pre_access_control_list_delete

    def post_access_control_list_delete(self, resource_id, resource_dict):
        """
        Method called after access-control-list is deleted
        """
        pass
    #end post_access_control_list_delete

    def pre_analytics_node_create(self, resource_dict):
        """
        Method called before analytics-node is created
        """
        pass
    #end pre_analytics_node_create

    def post_analytics_node_create(self, resource_dict):
        """
        Method called after analytics-node is created
        """
        pass
    #end post_analytics_node_create

    def pre_analytics_node_read(self, resource_id):
        """
        Method called before analytics-node is read
        """
        pass
    #end pre_analytics_node_read

    def post_analytics_node_read(self, resource_id, resource_dict):
        """
        Method called after analytics-node is read
        """
        pass
    #end post_analytics_node_read

    def pre_analytics_node_update(self, resource_id, resource_dict):
        """
        Method called before analytics-node is updated
        """
        pass
    #end pre_analytics_node_update

    def post_analytics_node_update(self, resource_id, resource_dict):
        """
        Method called after analytics-node is updated
        """
        pass
    #end post_analytics_node_update

    def pre_analytics_node_delete(self, resource_id):
        """
        Method called before analytics-node is deleted
        """
        pass
    #end pre_analytics_node_delete

    def post_analytics_node_delete(self, resource_id, resource_dict):
        """
        Method called after analytics-node is deleted
        """
        pass
    #end post_analytics_node_delete

    def pre_virtual_DNS_create(self, resource_dict):
        """
        Method called before virtual-DNS is created
        """
        pass
    #end pre_virtual_DNS_create

    def post_virtual_DNS_create(self, resource_dict):
        """
        Method called after virtual-DNS is created
        """
        pass
    #end post_virtual_DNS_create

    def pre_virtual_DNS_read(self, resource_id):
        """
        Method called before virtual-DNS is read
        """
        pass
    #end pre_virtual_DNS_read

    def post_virtual_DNS_read(self, resource_id, resource_dict):
        """
        Method called after virtual-DNS is read
        """
        pass
    #end post_virtual_DNS_read

    def pre_virtual_DNS_update(self, resource_id, resource_dict):
        """
        Method called before virtual-DNS is updated
        """
        pass
    #end pre_virtual_DNS_update

    def post_virtual_DNS_update(self, resource_id, resource_dict):
        """
        Method called after virtual-DNS is updated
        """
        pass
    #end post_virtual_DNS_update

    def pre_virtual_DNS_delete(self, resource_id):
        """
        Method called before virtual-DNS is deleted
        """
        pass
    #end pre_virtual_DNS_delete

    def post_virtual_DNS_delete(self, resource_id, resource_dict):
        """
        Method called after virtual-DNS is deleted
        """
        pass
    #end post_virtual_DNS_delete

    def pre_customer_attachment_create(self, resource_dict):
        """
        Method called before customer-attachment is created
        """
        pass
    #end pre_customer_attachment_create

    def post_customer_attachment_create(self, resource_dict):
        """
        Method called after customer-attachment is created
        """
        pass
    #end post_customer_attachment_create

    def pre_customer_attachment_read(self, resource_id):
        """
        Method called before customer-attachment is read
        """
        pass
    #end pre_customer_attachment_read

    def post_customer_attachment_read(self, resource_id, resource_dict):
        """
        Method called after customer-attachment is read
        """
        pass
    #end post_customer_attachment_read

    def pre_customer_attachment_update(self, resource_id, resource_dict):
        """
        Method called before customer-attachment is updated
        """
        pass
    #end pre_customer_attachment_update

    def post_customer_attachment_update(self, resource_id, resource_dict):
        """
        Method called after customer-attachment is updated
        """
        pass
    #end post_customer_attachment_update

    def pre_customer_attachment_delete(self, resource_id):
        """
        Method called before customer-attachment is deleted
        """
        pass
    #end pre_customer_attachment_delete

    def post_customer_attachment_delete(self, resource_id, resource_dict):
        """
        Method called after customer-attachment is deleted
        """
        pass
    #end post_customer_attachment_delete

    def pre_service_appliance_set_create(self, resource_dict):
        """
        Method called before service-appliance-set is created
        """
        pass
    #end pre_service_appliance_set_create

    def post_service_appliance_set_create(self, resource_dict):
        """
        Method called after service-appliance-set is created
        """
        pass
    #end post_service_appliance_set_create

    def pre_service_appliance_set_read(self, resource_id):
        """
        Method called before service-appliance-set is read
        """
        pass
    #end pre_service_appliance_set_read

    def post_service_appliance_set_read(self, resource_id, resource_dict):
        """
        Method called after service-appliance-set is read
        """
        pass
    #end post_service_appliance_set_read

    def pre_service_appliance_set_update(self, resource_id, resource_dict):
        """
        Method called before service-appliance-set is updated
        """
        pass
    #end pre_service_appliance_set_update

    def post_service_appliance_set_update(self, resource_id, resource_dict):
        """
        Method called after service-appliance-set is updated
        """
        pass
    #end post_service_appliance_set_update

    def pre_service_appliance_set_delete(self, resource_id):
        """
        Method called before service-appliance-set is deleted
        """
        pass
    #end pre_service_appliance_set_delete

    def post_service_appliance_set_delete(self, resource_id, resource_dict):
        """
        Method called after service-appliance-set is deleted
        """
        pass
    #end post_service_appliance_set_delete

    def pre_config_node_create(self, resource_dict):
        """
        Method called before config-node is created
        """
        pass
    #end pre_config_node_create

    def post_config_node_create(self, resource_dict):
        """
        Method called after config-node is created
        """
        pass
    #end post_config_node_create

    def pre_config_node_read(self, resource_id):
        """
        Method called before config-node is read
        """
        pass
    #end pre_config_node_read

    def post_config_node_read(self, resource_id, resource_dict):
        """
        Method called after config-node is read
        """
        pass
    #end post_config_node_read

    def pre_config_node_update(self, resource_id, resource_dict):
        """
        Method called before config-node is updated
        """
        pass
    #end pre_config_node_update

    def post_config_node_update(self, resource_id, resource_dict):
        """
        Method called after config-node is updated
        """
        pass
    #end post_config_node_update

    def pre_config_node_delete(self, resource_id):
        """
        Method called before config-node is deleted
        """
        pass
    #end pre_config_node_delete

    def post_config_node_delete(self, resource_id, resource_dict):
        """
        Method called after config-node is deleted
        """
        pass
    #end post_config_node_delete

    def pre_qos_queue_create(self, resource_dict):
        """
        Method called before qos-queue is created
        """
        pass
    #end pre_qos_queue_create

    def post_qos_queue_create(self, resource_dict):
        """
        Method called after qos-queue is created
        """
        pass
    #end post_qos_queue_create

    def pre_qos_queue_read(self, resource_id):
        """
        Method called before qos-queue is read
        """
        pass
    #end pre_qos_queue_read

    def post_qos_queue_read(self, resource_id, resource_dict):
        """
        Method called after qos-queue is read
        """
        pass
    #end post_qos_queue_read

    def pre_qos_queue_update(self, resource_id, resource_dict):
        """
        Method called before qos-queue is updated
        """
        pass
    #end pre_qos_queue_update

    def post_qos_queue_update(self, resource_id, resource_dict):
        """
        Method called after qos-queue is updated
        """
        pass
    #end post_qos_queue_update

    def pre_qos_queue_delete(self, resource_id):
        """
        Method called before qos-queue is deleted
        """
        pass
    #end pre_qos_queue_delete

    def post_qos_queue_delete(self, resource_id, resource_dict):
        """
        Method called after qos-queue is deleted
        """
        pass
    #end post_qos_queue_delete

    def pre_virtual_machine_create(self, resource_dict):
        """
        Method called before virtual-machine is created
        """
        pass
    #end pre_virtual_machine_create

    def post_virtual_machine_create(self, resource_dict):
        """
        Method called after virtual-machine is created
        """
        pass
    #end post_virtual_machine_create

    def pre_virtual_machine_read(self, resource_id):
        """
        Method called before virtual-machine is read
        """
        pass
    #end pre_virtual_machine_read

    def post_virtual_machine_read(self, resource_id, resource_dict):
        """
        Method called after virtual-machine is read
        """
        pass
    #end post_virtual_machine_read

    def pre_virtual_machine_update(self, resource_id, resource_dict):
        """
        Method called before virtual-machine is updated
        """
        pass
    #end pre_virtual_machine_update

    def post_virtual_machine_update(self, resource_id, resource_dict):
        """
        Method called after virtual-machine is updated
        """
        pass
    #end post_virtual_machine_update

    def pre_virtual_machine_delete(self, resource_id):
        """
        Method called before virtual-machine is deleted
        """
        pass
    #end pre_virtual_machine_delete

    def post_virtual_machine_delete(self, resource_id, resource_dict):
        """
        Method called after virtual-machine is deleted
        """
        pass
    #end post_virtual_machine_delete

    def pre_interface_route_table_create(self, resource_dict):
        """
        Method called before interface-route-table is created
        """
        pass
    #end pre_interface_route_table_create

    def post_interface_route_table_create(self, resource_dict):
        """
        Method called after interface-route-table is created
        """
        pass
    #end post_interface_route_table_create

    def pre_interface_route_table_read(self, resource_id):
        """
        Method called before interface-route-table is read
        """
        pass
    #end pre_interface_route_table_read

    def post_interface_route_table_read(self, resource_id, resource_dict):
        """
        Method called after interface-route-table is read
        """
        pass
    #end post_interface_route_table_read

    def pre_interface_route_table_update(self, resource_id, resource_dict):
        """
        Method called before interface-route-table is updated
        """
        pass
    #end pre_interface_route_table_update

    def post_interface_route_table_update(self, resource_id, resource_dict):
        """
        Method called after interface-route-table is updated
        """
        pass
    #end post_interface_route_table_update

    def pre_interface_route_table_delete(self, resource_id):
        """
        Method called before interface-route-table is deleted
        """
        pass
    #end pre_interface_route_table_delete

    def post_interface_route_table_delete(self, resource_id, resource_dict):
        """
        Method called after interface-route-table is deleted
        """
        pass
    #end post_interface_route_table_delete

    def pre_service_template_create(self, resource_dict):
        """
        Method called before service-template is created
        """
        pass
    #end pre_service_template_create

    def post_service_template_create(self, resource_dict):
        """
        Method called after service-template is created
        """
        pass
    #end post_service_template_create

    def pre_service_template_read(self, resource_id):
        """
        Method called before service-template is read
        """
        pass
    #end pre_service_template_read

    def post_service_template_read(self, resource_id, resource_dict):
        """
        Method called after service-template is read
        """
        pass
    #end post_service_template_read

    def pre_service_template_update(self, resource_id, resource_dict):
        """
        Method called before service-template is updated
        """
        pass
    #end pre_service_template_update

    def post_service_template_update(self, resource_id, resource_dict):
        """
        Method called after service-template is updated
        """
        pass
    #end post_service_template_update

    def pre_service_template_delete(self, resource_id):
        """
        Method called before service-template is deleted
        """
        pass
    #end pre_service_template_delete

    def post_service_template_delete(self, resource_id, resource_dict):
        """
        Method called after service-template is deleted
        """
        pass
    #end post_service_template_delete

    def pre_virtual_ip_create(self, resource_dict):
        """
        Method called before virtual-ip is created
        """
        pass
    #end pre_virtual_ip_create

    def post_virtual_ip_create(self, resource_dict):
        """
        Method called after virtual-ip is created
        """
        pass
    #end post_virtual_ip_create

    def pre_virtual_ip_read(self, resource_id):
        """
        Method called before virtual-ip is read
        """
        pass
    #end pre_virtual_ip_read

    def post_virtual_ip_read(self, resource_id, resource_dict):
        """
        Method called after virtual-ip is read
        """
        pass
    #end post_virtual_ip_read

    def pre_virtual_ip_update(self, resource_id, resource_dict):
        """
        Method called before virtual-ip is updated
        """
        pass
    #end pre_virtual_ip_update

    def post_virtual_ip_update(self, resource_id, resource_dict):
        """
        Method called after virtual-ip is updated
        """
        pass
    #end post_virtual_ip_update

    def pre_virtual_ip_delete(self, resource_id):
        """
        Method called before virtual-ip is deleted
        """
        pass
    #end pre_virtual_ip_delete

    def post_virtual_ip_delete(self, resource_id, resource_dict):
        """
        Method called after virtual-ip is deleted
        """
        pass
    #end post_virtual_ip_delete

    def pre_loadbalancer_member_create(self, resource_dict):
        """
        Method called before loadbalancer-member is created
        """
        pass
    #end pre_loadbalancer_member_create

    def post_loadbalancer_member_create(self, resource_dict):
        """
        Method called after loadbalancer-member is created
        """
        pass
    #end post_loadbalancer_member_create

    def pre_loadbalancer_member_read(self, resource_id):
        """
        Method called before loadbalancer-member is read
        """
        pass
    #end pre_loadbalancer_member_read

    def post_loadbalancer_member_read(self, resource_id, resource_dict):
        """
        Method called after loadbalancer-member is read
        """
        pass
    #end post_loadbalancer_member_read

    def pre_loadbalancer_member_update(self, resource_id, resource_dict):
        """
        Method called before loadbalancer-member is updated
        """
        pass
    #end pre_loadbalancer_member_update

    def post_loadbalancer_member_update(self, resource_id, resource_dict):
        """
        Method called after loadbalancer-member is updated
        """
        pass
    #end post_loadbalancer_member_update

    def pre_loadbalancer_member_delete(self, resource_id):
        """
        Method called before loadbalancer-member is deleted
        """
        pass
    #end pre_loadbalancer_member_delete

    def post_loadbalancer_member_delete(self, resource_id, resource_dict):
        """
        Method called after loadbalancer-member is deleted
        """
        pass
    #end post_loadbalancer_member_delete

    def pre_security_group_create(self, resource_dict):
        """
        Method called before security-group is created
        """
        pass
    #end pre_security_group_create

    def post_security_group_create(self, resource_dict):
        """
        Method called after security-group is created
        """
        pass
    #end post_security_group_create

    def pre_security_group_read(self, resource_id):
        """
        Method called before security-group is read
        """
        pass
    #end pre_security_group_read

    def post_security_group_read(self, resource_id, resource_dict):
        """
        Method called after security-group is read
        """
        pass
    #end post_security_group_read

    def pre_security_group_update(self, resource_id, resource_dict):
        """
        Method called before security-group is updated
        """
        pass
    #end pre_security_group_update

    def post_security_group_update(self, resource_id, resource_dict):
        """
        Method called after security-group is updated
        """
        pass
    #end post_security_group_update

    def pre_security_group_delete(self, resource_id):
        """
        Method called before security-group is deleted
        """
        pass
    #end pre_security_group_delete

    def post_security_group_delete(self, resource_id, resource_dict):
        """
        Method called after security-group is deleted
        """
        pass
    #end post_security_group_delete

    def pre_provider_attachment_create(self, resource_dict):
        """
        Method called before provider-attachment is created
        """
        pass
    #end pre_provider_attachment_create

    def post_provider_attachment_create(self, resource_dict):
        """
        Method called after provider-attachment is created
        """
        pass
    #end post_provider_attachment_create

    def pre_provider_attachment_read(self, resource_id):
        """
        Method called before provider-attachment is read
        """
        pass
    #end pre_provider_attachment_read

    def post_provider_attachment_read(self, resource_id, resource_dict):
        """
        Method called after provider-attachment is read
        """
        pass
    #end post_provider_attachment_read

    def pre_provider_attachment_update(self, resource_id, resource_dict):
        """
        Method called before provider-attachment is updated
        """
        pass
    #end pre_provider_attachment_update

    def post_provider_attachment_update(self, resource_id, resource_dict):
        """
        Method called after provider-attachment is updated
        """
        pass
    #end post_provider_attachment_update

    def pre_provider_attachment_delete(self, resource_id):
        """
        Method called before provider-attachment is deleted
        """
        pass
    #end pre_provider_attachment_delete

    def post_provider_attachment_delete(self, resource_id, resource_dict):
        """
        Method called after provider-attachment is deleted
        """
        pass
    #end post_provider_attachment_delete

    def pre_virtual_machine_interface_create(self, resource_dict):
        """
        Method called before virtual-machine-interface is created
        """
        pass
    #end pre_virtual_machine_interface_create

    def post_virtual_machine_interface_create(self, resource_dict):
        """
        Method called after virtual-machine-interface is created
        """
        pass
    #end post_virtual_machine_interface_create

    def pre_virtual_machine_interface_read(self, resource_id):
        """
        Method called before virtual-machine-interface is read
        """
        pass
    #end pre_virtual_machine_interface_read

    def post_virtual_machine_interface_read(self, resource_id, resource_dict):
        """
        Method called after virtual-machine-interface is read
        """
        pass
    #end post_virtual_machine_interface_read

    def pre_virtual_machine_interface_update(self, resource_id, resource_dict):
        """
        Method called before virtual-machine-interface is updated
        """
        pass
    #end pre_virtual_machine_interface_update

    def post_virtual_machine_interface_update(self, resource_id, resource_dict):
        """
        Method called after virtual-machine-interface is updated
        """
        pass
    #end post_virtual_machine_interface_update

    def pre_virtual_machine_interface_delete(self, resource_id):
        """
        Method called before virtual-machine-interface is deleted
        """
        pass
    #end pre_virtual_machine_interface_delete

    def post_virtual_machine_interface_delete(self, resource_id, resource_dict):
        """
        Method called after virtual-machine-interface is deleted
        """
        pass
    #end post_virtual_machine_interface_delete

    def pre_loadbalancer_healthmonitor_create(self, resource_dict):
        """
        Method called before loadbalancer-healthmonitor is created
        """
        pass
    #end pre_loadbalancer_healthmonitor_create

    def post_loadbalancer_healthmonitor_create(self, resource_dict):
        """
        Method called after loadbalancer-healthmonitor is created
        """
        pass
    #end post_loadbalancer_healthmonitor_create

    def pre_loadbalancer_healthmonitor_read(self, resource_id):
        """
        Method called before loadbalancer-healthmonitor is read
        """
        pass
    #end pre_loadbalancer_healthmonitor_read

    def post_loadbalancer_healthmonitor_read(self, resource_id, resource_dict):
        """
        Method called after loadbalancer-healthmonitor is read
        """
        pass
    #end post_loadbalancer_healthmonitor_read

    def pre_loadbalancer_healthmonitor_update(self, resource_id, resource_dict):
        """
        Method called before loadbalancer-healthmonitor is updated
        """
        pass
    #end pre_loadbalancer_healthmonitor_update

    def post_loadbalancer_healthmonitor_update(self, resource_id, resource_dict):
        """
        Method called after loadbalancer-healthmonitor is updated
        """
        pass
    #end post_loadbalancer_healthmonitor_update

    def pre_loadbalancer_healthmonitor_delete(self, resource_id):
        """
        Method called before loadbalancer-healthmonitor is deleted
        """
        pass
    #end pre_loadbalancer_healthmonitor_delete

    def post_loadbalancer_healthmonitor_delete(self, resource_id, resource_dict):
        """
        Method called after loadbalancer-healthmonitor is deleted
        """
        pass
    #end post_loadbalancer_healthmonitor_delete

    def pre_virtual_network_create(self, resource_dict):
        """
        Method called before virtual-network is created
        """
        pass
    #end pre_virtual_network_create

    def post_virtual_network_create(self, resource_dict):
        """
        Method called after virtual-network is created
        """
        pass
    #end post_virtual_network_create

    def pre_virtual_network_read(self, resource_id):
        """
        Method called before virtual-network is read
        """
        pass
    #end pre_virtual_network_read

    def post_virtual_network_read(self, resource_id, resource_dict):
        """
        Method called after virtual-network is read
        """
        pass
    #end post_virtual_network_read

    def pre_virtual_network_update(self, resource_id, resource_dict):
        """
        Method called before virtual-network is updated
        """
        pass
    #end pre_virtual_network_update

    def post_virtual_network_update(self, resource_id, resource_dict):
        """
        Method called after virtual-network is updated
        """
        pass
    #end post_virtual_network_update

    def pre_virtual_network_delete(self, resource_id):
        """
        Method called before virtual-network is deleted
        """
        pass
    #end pre_virtual_network_delete

    def post_virtual_network_delete(self, resource_id, resource_dict):
        """
        Method called after virtual-network is deleted
        """
        pass
    #end post_virtual_network_delete

    def pre_project_create(self, resource_dict):
        """
        Method called before project is created
        """
        pass
    #end pre_project_create

    def post_project_create(self, resource_dict):
        """
        Method called after project is created
        """
        pass
    #end post_project_create

    def pre_project_read(self, resource_id):
        """
        Method called before project is read
        """
        pass
    #end pre_project_read

    def post_project_read(self, resource_id, resource_dict):
        """
        Method called after project is read
        """
        pass
    #end post_project_read

    def pre_project_update(self, resource_id, resource_dict):
        """
        Method called before project is updated
        """
        pass
    #end pre_project_update

    def post_project_update(self, resource_id, resource_dict):
        """
        Method called after project is updated
        """
        pass
    #end post_project_update

    def pre_project_delete(self, resource_id):
        """
        Method called before project is deleted
        """
        pass
    #end pre_project_delete

    def post_project_delete(self, resource_id, resource_dict):
        """
        Method called after project is deleted
        """
        pass
    #end post_project_delete

    def pre_qos_forwarding_class_create(self, resource_dict):
        """
        Method called before qos-forwarding-class is created
        """
        pass
    #end pre_qos_forwarding_class_create

    def post_qos_forwarding_class_create(self, resource_dict):
        """
        Method called after qos-forwarding-class is created
        """
        pass
    #end post_qos_forwarding_class_create

    def pre_qos_forwarding_class_read(self, resource_id):
        """
        Method called before qos-forwarding-class is read
        """
        pass
    #end pre_qos_forwarding_class_read

    def post_qos_forwarding_class_read(self, resource_id, resource_dict):
        """
        Method called after qos-forwarding-class is read
        """
        pass
    #end post_qos_forwarding_class_read

    def pre_qos_forwarding_class_update(self, resource_id, resource_dict):
        """
        Method called before qos-forwarding-class is updated
        """
        pass
    #end pre_qos_forwarding_class_update

    def post_qos_forwarding_class_update(self, resource_id, resource_dict):
        """
        Method called after qos-forwarding-class is updated
        """
        pass
    #end post_qos_forwarding_class_update

    def pre_qos_forwarding_class_delete(self, resource_id):
        """
        Method called before qos-forwarding-class is deleted
        """
        pass
    #end pre_qos_forwarding_class_delete

    def post_qos_forwarding_class_delete(self, resource_id, resource_dict):
        """
        Method called after qos-forwarding-class is deleted
        """
        pass
    #end post_qos_forwarding_class_delete

    def pre_database_node_create(self, resource_dict):
        """
        Method called before database-node is created
        """
        pass
    #end pre_database_node_create

    def post_database_node_create(self, resource_dict):
        """
        Method called after database-node is created
        """
        pass
    #end post_database_node_create

    def pre_database_node_read(self, resource_id):
        """
        Method called before database-node is read
        """
        pass
    #end pre_database_node_read

    def post_database_node_read(self, resource_id, resource_dict):
        """
        Method called after database-node is read
        """
        pass
    #end post_database_node_read

    def pre_database_node_update(self, resource_id, resource_dict):
        """
        Method called before database-node is updated
        """
        pass
    #end pre_database_node_update

    def post_database_node_update(self, resource_id, resource_dict):
        """
        Method called after database-node is updated
        """
        pass
    #end post_database_node_update

    def pre_database_node_delete(self, resource_id):
        """
        Method called before database-node is deleted
        """
        pass
    #end pre_database_node_delete

    def post_database_node_delete(self, resource_id, resource_dict):
        """
        Method called after database-node is deleted
        """
        pass
    #end post_database_node_delete

    def pre_routing_instance_create(self, resource_dict):
        """
        Method called before routing-instance is created
        """
        pass
    #end pre_routing_instance_create

    def post_routing_instance_create(self, resource_dict):
        """
        Method called after routing-instance is created
        """
        pass
    #end post_routing_instance_create

    def pre_routing_instance_read(self, resource_id):
        """
        Method called before routing-instance is read
        """
        pass
    #end pre_routing_instance_read

    def post_routing_instance_read(self, resource_id, resource_dict):
        """
        Method called after routing-instance is read
        """
        pass
    #end post_routing_instance_read

    def pre_routing_instance_update(self, resource_id, resource_dict):
        """
        Method called before routing-instance is updated
        """
        pass
    #end pre_routing_instance_update

    def post_routing_instance_update(self, resource_id, resource_dict):
        """
        Method called after routing-instance is updated
        """
        pass
    #end post_routing_instance_update

    def pre_routing_instance_delete(self, resource_id):
        """
        Method called before routing-instance is deleted
        """
        pass
    #end pre_routing_instance_delete

    def post_routing_instance_delete(self, resource_id, resource_dict):
        """
        Method called after routing-instance is deleted
        """
        pass
    #end post_routing_instance_delete

    def pre_network_ipam_create(self, resource_dict):
        """
        Method called before network-ipam is created
        """
        pass
    #end pre_network_ipam_create

    def post_network_ipam_create(self, resource_dict):
        """
        Method called after network-ipam is created
        """
        pass
    #end post_network_ipam_create

    def pre_network_ipam_read(self, resource_id):
        """
        Method called before network-ipam is read
        """
        pass
    #end pre_network_ipam_read

    def post_network_ipam_read(self, resource_id, resource_dict):
        """
        Method called after network-ipam is read
        """
        pass
    #end post_network_ipam_read

    def pre_network_ipam_update(self, resource_id, resource_dict):
        """
        Method called before network-ipam is updated
        """
        pass
    #end pre_network_ipam_update

    def post_network_ipam_update(self, resource_id, resource_dict):
        """
        Method called after network-ipam is updated
        """
        pass
    #end post_network_ipam_update

    def pre_network_ipam_delete(self, resource_id):
        """
        Method called before network-ipam is deleted
        """
        pass
    #end pre_network_ipam_delete

    def post_network_ipam_delete(self, resource_id, resource_dict):
        """
        Method called after network-ipam is deleted
        """
        pass
    #end post_network_ipam_delete

    def pre_logical_router_create(self, resource_dict):
        """
        Method called before logical-router is created
        """
        pass
    #end pre_logical_router_create

    def post_logical_router_create(self, resource_dict):
        """
        Method called after logical-router is created
        """
        pass
    #end post_logical_router_create

    def pre_logical_router_read(self, resource_id):
        """
        Method called before logical-router is read
        """
        pass
    #end pre_logical_router_read

    def post_logical_router_read(self, resource_id, resource_dict):
        """
        Method called after logical-router is read
        """
        pass
    #end post_logical_router_read

    def pre_logical_router_update(self, resource_id, resource_dict):
        """
        Method called before logical-router is updated
        """
        pass
    #end pre_logical_router_update

    def post_logical_router_update(self, resource_id, resource_dict):
        """
        Method called after logical-router is updated
        """
        pass
    #end post_logical_router_update

    def pre_logical_router_delete(self, resource_id):
        """
        Method called before logical-router is deleted
        """
        pass
    #end pre_logical_router_delete

    def post_logical_router_delete(self, resource_id, resource_dict):
        """
        Method called after logical-router is deleted
        """
        pass
    #end post_logical_router_delete

#end class ResourceApiGen