"Fossies" - the Fresh Open Source Software Archive

Member "cells-3.0.3/vendor/github.com/softlayer/softlayer-go/services/network.go" (30 Nov 2021, 674557 Bytes) of package /linux/misc/pydio-cells-3.0.3.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Go source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 /**
    2  * Copyright 2016 IBM Corp.
    3  *
    4  * Licensed under the Apache License, Version 2.0 (the "License");
    5  * you may not use this file except in compliance with the License.
    6  * You may obtain a copy of the License at
    7  *
    8  *    http://www.apache.org/licenses/LICENSE-2.0
    9  *
   10  * Unless required by applicable law or agreed to in writing, software
   11  * distributed under the License is distributed on an "AS IS" BASIS,
   12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   13  * See the License for the specific language governing permissions and
   14  * limitations under the License.
   15  */
   16 
   17 /**
   18  * AUTOMATICALLY GENERATED CODE - DO NOT MODIFY
   19  */
   20 
   21 package services
   22 
   23 import (
   24     "fmt"
   25     "strings"
   26 
   27     "github.com/softlayer/softlayer-go/datatypes"
   28     "github.com/softlayer/softlayer-go/session"
   29     "github.com/softlayer/softlayer-go/sl"
   30 )
   31 
   32 // no documentation yet
   33 type Network struct {
   34     Session *session.Session
   35     Options sl.Options
   36 }
   37 
   38 // GetNetworkService returns an instance of the Network SoftLayer service
   39 func GetNetworkService(sess *session.Session) Network {
   40     return Network{Session: sess}
   41 }
   42 
   43 func (r Network) Id(id int) Network {
   44     r.Options.Id = &id
   45     return r
   46 }
   47 
   48 func (r Network) Mask(mask string) Network {
   49     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
   50         mask = fmt.Sprintf("mask[%s]", mask)
   51     }
   52 
   53     r.Options.Mask = mask
   54     return r
   55 }
   56 
   57 func (r Network) Filter(filter string) Network {
   58     r.Options.Filter = filter
   59     return r
   60 }
   61 
   62 func (r Network) Limit(limit int) Network {
   63     r.Options.Limit = &limit
   64     return r
   65 }
   66 
   67 func (r Network) Offset(offset int) Network {
   68     r.Options.Offset = &offset
   69     return r
   70 }
   71 
   72 // Provide a template containing the following properties to create a Network:
   73 // * networkIdentifier
   74 // * cidr
   75 // * name
   76 //
   77 //
   78 // The ``networkIdentifier`` must be an IP address within RFC 1918 blocks:
   79 // * 192.168.0.0/16
   80 // * 172.16.0.0/12
   81 // * 10.0.0.0/8
   82 // The ``cidr`` must be an integer between 16 and 24, inclusive. The ``networkIdentifier``/``cidr`` must represent a valid subnet specification. The ``name`` must not be empty, but otherwise can contain up to 50 characters of user specified information to identify the Network.
   83 //
   84 // The subnet specification of the Network bounds the IP address space which can be utilized and constrains the creation of Subnets within the Network.
   85 //
   86 // Example networkIdentifier/CIDR combinations:
   87 // * 192.168.0.0/16
   88 // * 192.168.0.0/17
   89 // * 172.16.0.0/16
   90 // * 172.31.0.0/16
   91 // * 10.0.0.0/16
   92 // * 10.255.0.0/16
   93 func (r Network) CreateObject(templateObject *datatypes.Network) (resp datatypes.Network, err error) {
   94     params := []interface{}{
   95         templateObject,
   96     }
   97     err = r.Session.DoRequest("SoftLayer_Network", "createObject", params, &r.Options, &resp)
   98     return
   99 }
  100 
  101 // Creation of a Subnet is necessary prior to provisioning compute resources into a Network. In order to create a Subnet, both a [[SoftLayer_Network_Subnet|Subnet]] and [[SoftLayer_Network_Pod|Pod]] must be specified. The Pod determines where the Subnet will be available for use by compute resources.
  102 //
  103 // Provide a Subnet template containing the following properties:
  104 // * networkIdentifier
  105 // * cidr
  106 // The ``networkIdentifier`` must represent an IP address within that specified by the Network. The ``cidr`` must be an integer between 24 and 29, inclusive, and represent a subnet size smaller than the Network's. The ``networkIdentifier``/``cidr`` must represent a valid subnet specification.
  107 //
  108 // Provide a Pod template containing the following property:
  109 // * name
  110 // The ``name`` must represent a valid Pod e.g. sjc01.pod02. See [[SoftLayer_Network_Pod (type)]] for more information.
  111 //
  112 // The following constraints apply to Subnet creation:
  113 // * It must fit within the bounds of the Network.
  114 // * It must be no larger than /24 and no smaller than /29.
  115 // * Its size must not equal that of the Network. This implies that a fully
  116 // utilized Network will have a minimum of two Subnets.
  117 // * The Pod must support the ability to create Networks by having the
  118 // SUPPORTS_CUSTOMER_DEFINED_NETWORK capability. See [[SoftLayer_Network_Pod/getCapabilities]].
  119 func (r Network) CreateSubnet(subnet *datatypes.Network_Subnet, pod *datatypes.Network_Pod) (resp datatypes.Network_Subnet, err error) {
  120     params := []interface{}{
  121         subnet,
  122         pod,
  123     }
  124     err = r.Session.DoRequest("SoftLayer_Network", "createSubnet", params, &r.Options, &resp)
  125     return
  126 }
  127 
  128 // Remove the specified Network along with any Subnets.
  129 func (r Network) DeleteObject() (resp bool, err error) {
  130     err = r.Session.DoRequest("SoftLayer_Network", "deleteObject", nil, &r.Options, &resp)
  131     return
  132 }
  133 
  134 //
  135 //
  136 // Provide a Subnet template containing the following properties:
  137 // * networkIdentifier
  138 // * cidr
  139 // The ``networkIdentifier`` must represent an IP address within that specified by the Network. The ``cidr`` must be an integer between 24 and 29, inclusive, and represent a subnet size smaller than the Network's. The ``networkIdentifier``/``cidr`` must represent a valid subnet specification. Or:
  140 // * id
  141 // The ``id`` must identify a Subnet in the Network. If the ``id`` is provided, the ``networkIdentifier``/``cidr`` will be ignored.
  142 //
  143 // Subnets may only be removed when no compute resources are utilizing them.
  144 func (r Network) DeleteSubnet(subnet *datatypes.Network_Subnet) (resp bool, err error) {
  145     params := []interface{}{
  146         subnet,
  147     }
  148     err = r.Session.DoRequest("SoftLayer_Network", "deleteSubnet", params, &r.Options, &resp)
  149     return
  150 }
  151 
  152 // Modify either the ``name`` or ``notes`` properties of a Network.
  153 func (r Network) EditObject(templateObject *datatypes.Network) (resp bool, err error) {
  154     params := []interface{}{
  155         templateObject,
  156     }
  157     err = r.Session.DoRequest("SoftLayer_Network", "editObject", params, &r.Options, &resp)
  158     return
  159 }
  160 
  161 // no documentation yet
  162 func (r Network) GetAllObjects() (resp []datatypes.Network, err error) {
  163     err = r.Session.DoRequest("SoftLayer_Network", "getAllObjects", nil, &r.Options, &resp)
  164     return
  165 }
  166 
  167 // Retrieve The size of the Network specified in CIDR notation. Specified in conjunction with the ``networkIdentifier`` to describe the bounding subnet size for the Network. Required for creation. See [[SoftLayer_Network/createObject]] documentation for creation details.
  168 func (r Network) GetCidr() (resp int, err error) {
  169     err = r.Session.DoRequest("SoftLayer_Network", "getCidr", nil, &r.Options, &resp)
  170     return
  171 }
  172 
  173 // Retrieve A name for the Network. This is required during creation of a Network and is entirely user defined.
  174 func (r Network) GetName() (resp string, err error) {
  175     err = r.Session.DoRequest("SoftLayer_Network", "getName", nil, &r.Options, &resp)
  176     return
  177 }
  178 
  179 // Retrieve The starting IP address of the Network. Specified in conjunction with the ``cidr`` property to specify the bounding IP address space for the Network. Required for creation. See [[SoftLayer_Network/createObject]] documentation for creation details.
  180 func (r Network) GetNetworkIdentifier() (resp string, err error) {
  181     err = r.Session.DoRequest("SoftLayer_Network", "getNetworkIdentifier", nil, &r.Options, &resp)
  182     return
  183 }
  184 
  185 // Retrieve Notes, or a description of the Network. This is entirely user defined.
  186 func (r Network) GetNotes() (resp string, err error) {
  187     err = r.Session.DoRequest("SoftLayer_Network", "getNotes", nil, &r.Options, &resp)
  188     return
  189 }
  190 
  191 // no documentation yet
  192 func (r Network) GetObject() (resp datatypes.Network, err error) {
  193     err = r.Session.DoRequest("SoftLayer_Network", "getObject", nil, &r.Options, &resp)
  194     return
  195 }
  196 
  197 // Retrieve The Subnets within the Network. These represent the realized segments of the Network and reside within a [[SoftLayer_Network_Pod|Pod]]. A Subnet must be specified when provisioning a compute resource within a Network.
  198 func (r Network) GetSubnets() (resp []datatypes.Network_Subnet, err error) {
  199     err = r.Session.DoRequest("SoftLayer_Network", "getSubnets", nil, &r.Options, &resp)
  200     return
  201 }
  202 
  203 // The SoftLayer_Network_Application_Delivery_Controller data type models a single instance of an application delivery controller. Local properties are read only, except for a ''notes'' property, which can be used to describe your application delivery controller service. The type's relational properties provide more information to the service's function and login information to the controller's backend management if advanced view is enabled.
  204 type Network_Application_Delivery_Controller struct {
  205     Session *session.Session
  206     Options sl.Options
  207 }
  208 
  209 // GetNetworkApplicationDeliveryControllerService returns an instance of the Network_Application_Delivery_Controller SoftLayer service
  210 func GetNetworkApplicationDeliveryControllerService(sess *session.Session) Network_Application_Delivery_Controller {
  211     return Network_Application_Delivery_Controller{Session: sess}
  212 }
  213 
  214 func (r Network_Application_Delivery_Controller) Id(id int) Network_Application_Delivery_Controller {
  215     r.Options.Id = &id
  216     return r
  217 }
  218 
  219 func (r Network_Application_Delivery_Controller) Mask(mask string) Network_Application_Delivery_Controller {
  220     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
  221         mask = fmt.Sprintf("mask[%s]", mask)
  222     }
  223 
  224     r.Options.Mask = mask
  225     return r
  226 }
  227 
  228 func (r Network_Application_Delivery_Controller) Filter(filter string) Network_Application_Delivery_Controller {
  229     r.Options.Filter = filter
  230     return r
  231 }
  232 
  233 func (r Network_Application_Delivery_Controller) Limit(limit int) Network_Application_Delivery_Controller {
  234     r.Options.Limit = &limit
  235     return r
  236 }
  237 
  238 func (r Network_Application_Delivery_Controller) Offset(offset int) Network_Application_Delivery_Controller {
  239     r.Options.Offset = &offset
  240     return r
  241 }
  242 
  243 // Create or add to an application delivery controller based load balancer service. The loadBalancer parameter must have its ''name'', ''type'', ''sourcePort'', and ''virtualIpAddress'' properties populated. Changes are reflected immediately in the application delivery controller.
  244 func (r Network_Application_Delivery_Controller) CreateLiveLoadBalancer(loadBalancer *datatypes.Network_LoadBalancer_VirtualIpAddress) (resp bool, err error) {
  245     params := []interface{}{
  246         loadBalancer,
  247     }
  248     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "createLiveLoadBalancer", params, &r.Options, &resp)
  249     return
  250 }
  251 
  252 // Remove a virtual IP address from an application delivery controller based load balancer. Only the ''name'' property in the loadBalancer parameter must be populated. Changes are reflected immediately in the application delivery controller.
  253 func (r Network_Application_Delivery_Controller) DeleteLiveLoadBalancer(loadBalancer *datatypes.Network_LoadBalancer_VirtualIpAddress) (resp bool, err error) {
  254     params := []interface{}{
  255         loadBalancer,
  256     }
  257     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "deleteLiveLoadBalancer", params, &r.Options, &resp)
  258     return
  259 }
  260 
  261 // Remove an entire load balancer service, including all virtual IP addresses, from and application delivery controller based load balancer. The ''name'' property the and ''name'' property within the ''vip'' property of the service parameter must be provided. Changes are reflected immediately in the application delivery controller.
  262 func (r Network_Application_Delivery_Controller) DeleteLiveLoadBalancerService(service *datatypes.Network_LoadBalancer_Service) (err error) {
  263     var resp datatypes.Void
  264     params := []interface{}{
  265         service,
  266     }
  267     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "deleteLiveLoadBalancerService", params, &r.Options, &resp)
  268     return
  269 }
  270 
  271 // Edit an applications delivery controller record. Currently only a controller's notes property is editable.
  272 func (r Network_Application_Delivery_Controller) EditObject(templateObject *datatypes.Network_Application_Delivery_Controller) (resp bool, err error) {
  273     params := []interface{}{
  274         templateObject,
  275     }
  276     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "editObject", params, &r.Options, &resp)
  277     return
  278 }
  279 
  280 // Retrieve The SoftLayer customer account that owns an application delivery controller record.
  281 func (r Network_Application_Delivery_Controller) GetAccount() (resp datatypes.Account, err error) {
  282     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getAccount", nil, &r.Options, &resp)
  283     return
  284 }
  285 
  286 // Retrieve The average daily public bandwidth usage for the current billing cycle.
  287 func (r Network_Application_Delivery_Controller) GetAverageDailyPublicBandwidthUsage() (resp datatypes.Float64, err error) {
  288     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getAverageDailyPublicBandwidthUsage", nil, &r.Options, &resp)
  289     return
  290 }
  291 
  292 // no documentation yet
  293 func (r Network_Application_Delivery_Controller) GetBandwidthDataByDate(startDateTime *datatypes.Time, endDateTime *datatypes.Time, networkType *string) (resp []datatypes.Metric_Tracking_Object_Data, err error) {
  294     params := []interface{}{
  295         startDateTime,
  296         endDateTime,
  297         networkType,
  298     }
  299     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getBandwidthDataByDate", params, &r.Options, &resp)
  300     return
  301 }
  302 
  303 // Use this method when needing a bandwidth image for a single application delivery controller. It will gather the correct input parameters for the generic graphing utility based on the date ranges
  304 func (r Network_Application_Delivery_Controller) GetBandwidthImageByDate(startDateTime *datatypes.Time, endDateTime *datatypes.Time, networkType *string) (resp datatypes.Container_Bandwidth_GraphOutputs, err error) {
  305     params := []interface{}{
  306         startDateTime,
  307         endDateTime,
  308         networkType,
  309     }
  310     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getBandwidthImageByDate", params, &r.Options, &resp)
  311     return
  312 }
  313 
  314 // Retrieve The billing item for a Application Delivery Controller.
  315 func (r Network_Application_Delivery_Controller) GetBillingItem() (resp datatypes.Billing_Item_Network_Application_Delivery_Controller, err error) {
  316     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getBillingItem", nil, &r.Options, &resp)
  317     return
  318 }
  319 
  320 // Retrieve Previous configurations for an Application Delivery Controller.
  321 func (r Network_Application_Delivery_Controller) GetConfigurationHistory() (resp []datatypes.Network_Application_Delivery_Controller_Configuration_History, err error) {
  322     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getConfigurationHistory", nil, &r.Options, &resp)
  323     return
  324 }
  325 
  326 // Retrieve bandwidth graph by date.
  327 func (r Network_Application_Delivery_Controller) GetCustomBandwidthDataByDate(graphData *datatypes.Container_Graph) (resp datatypes.Container_Graph, err error) {
  328     params := []interface{}{
  329         graphData,
  330     }
  331     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getCustomBandwidthDataByDate", params, &r.Options, &resp)
  332     return
  333 }
  334 
  335 // Retrieve The datacenter that the application delivery controller resides in.
  336 func (r Network_Application_Delivery_Controller) GetDatacenter() (resp datatypes.Location, err error) {
  337     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getDatacenter", nil, &r.Options, &resp)
  338     return
  339 }
  340 
  341 // Retrieve A brief description of an application delivery controller record.
  342 func (r Network_Application_Delivery_Controller) GetDescription() (resp string, err error) {
  343     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getDescription", nil, &r.Options, &resp)
  344     return
  345 }
  346 
  347 // Retrieve The date in which the license for this application delivery controller will expire.
  348 func (r Network_Application_Delivery_Controller) GetLicenseExpirationDate() (resp datatypes.Time, err error) {
  349     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getLicenseExpirationDate", nil, &r.Options, &resp)
  350     return
  351 }
  352 
  353 // Get the graph image for an application delivery controller service based on the supplied graph type and metric.  The available graph types are: 'connections' and 'status', and the available metrics are: 'day', 'week' and 'month'.
  354 //
  355 // This method returns the raw binary image data.
  356 func (r Network_Application_Delivery_Controller) GetLiveLoadBalancerServiceGraphImage(service *datatypes.Network_LoadBalancer_Service, graphType *string, metric *string) (resp []byte, err error) {
  357     params := []interface{}{
  358         service,
  359         graphType,
  360         metric,
  361     }
  362     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getLiveLoadBalancerServiceGraphImage", params, &r.Options, &resp)
  363     return
  364 }
  365 
  366 // Retrieve The virtual IP address records that belong to an application delivery controller based load balancer.
  367 func (r Network_Application_Delivery_Controller) GetLoadBalancers() (resp []datatypes.Network_LoadBalancer_VirtualIpAddress, err error) {
  368     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getLoadBalancers", nil, &r.Options, &resp)
  369     return
  370 }
  371 
  372 // Retrieve A flag indicating that this Application Delivery Controller is a managed resource.
  373 func (r Network_Application_Delivery_Controller) GetManagedResourceFlag() (resp bool, err error) {
  374     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getManagedResourceFlag", nil, &r.Options, &resp)
  375     return
  376 }
  377 
  378 // Retrieve An application delivery controller's management ip address.
  379 func (r Network_Application_Delivery_Controller) GetManagementIpAddress() (resp string, err error) {
  380     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getManagementIpAddress", nil, &r.Options, &resp)
  381     return
  382 }
  383 
  384 // Retrieve The network VLAN that an application delivery controller resides on.
  385 func (r Network_Application_Delivery_Controller) GetNetworkVlan() (resp datatypes.Network_Vlan, err error) {
  386     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getNetworkVlan", nil, &r.Options, &resp)
  387     return
  388 }
  389 
  390 // Retrieve The network VLANs that an application delivery controller resides on.
  391 func (r Network_Application_Delivery_Controller) GetNetworkVlans() (resp []datatypes.Network_Vlan, err error) {
  392     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getNetworkVlans", nil, &r.Options, &resp)
  393     return
  394 }
  395 
  396 // getObject retrieves the SoftLayer_Network_Application_Delivery_Controller object whose ID number corresponds to the ID number of the init parameter passed to the SoftLayer_Network_Application_Delivery_Controller service. You can only retrieve application delivery controllers that are associated with your SoftLayer customer account.
  397 func (r Network_Application_Delivery_Controller) GetObject() (resp datatypes.Network_Application_Delivery_Controller, err error) {
  398     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getObject", nil, &r.Options, &resp)
  399     return
  400 }
  401 
  402 // Retrieve The total public outbound bandwidth for the current billing cycle.
  403 func (r Network_Application_Delivery_Controller) GetOutboundPublicBandwidthUsage() (resp datatypes.Float64, err error) {
  404     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getOutboundPublicBandwidthUsage", nil, &r.Options, &resp)
  405     return
  406 }
  407 
  408 // Retrieve The password used to connect to an application delivery controller's management interface when it is operating in advanced view mode.
  409 func (r Network_Application_Delivery_Controller) GetPassword() (resp datatypes.Software_Component_Password, err error) {
  410     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getPassword", nil, &r.Options, &resp)
  411     return
  412 }
  413 
  414 // Retrieve An application delivery controller's primary public IP address.
  415 func (r Network_Application_Delivery_Controller) GetPrimaryIpAddress() (resp string, err error) {
  416     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getPrimaryIpAddress", nil, &r.Options, &resp)
  417     return
  418 }
  419 
  420 // Retrieve The projected public outbound bandwidth for the current billing cycle.
  421 func (r Network_Application_Delivery_Controller) GetProjectedPublicBandwidthUsage() (resp datatypes.Float64, err error) {
  422     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getProjectedPublicBandwidthUsage", nil, &r.Options, &resp)
  423     return
  424 }
  425 
  426 // Retrieve A network application controller's subnets. A subnet is a group of IP addresses
  427 func (r Network_Application_Delivery_Controller) GetSubnets() (resp []datatypes.Network_Subnet, err error) {
  428     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getSubnets", nil, &r.Options, &resp)
  429     return
  430 }
  431 
  432 // Retrieve
  433 func (r Network_Application_Delivery_Controller) GetTagReferences() (resp []datatypes.Tag_Reference, err error) {
  434     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getTagReferences", nil, &r.Options, &resp)
  435     return
  436 }
  437 
  438 // Retrieve
  439 func (r Network_Application_Delivery_Controller) GetType() (resp datatypes.Network_Application_Delivery_Controller_Type, err error) {
  440     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getType", nil, &r.Options, &resp)
  441     return
  442 }
  443 
  444 // Retrieve
  445 func (r Network_Application_Delivery_Controller) GetVirtualIpAddresses() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress, err error) {
  446     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "getVirtualIpAddresses", nil, &r.Options, &resp)
  447     return
  448 }
  449 
  450 // Restore an application delivery controller's base configuration state. The configuration will be set to what it was when initially provisioned.
  451 func (r Network_Application_Delivery_Controller) RestoreBaseConfiguration() (resp bool, err error) {
  452     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "restoreBaseConfiguration", nil, &r.Options, &resp)
  453     return
  454 }
  455 
  456 // Restore an application delivery controller's configuration state.
  457 func (r Network_Application_Delivery_Controller) RestoreConfiguration(configurationHistoryId *int) (resp bool, err error) {
  458     params := []interface{}{
  459         configurationHistoryId,
  460     }
  461     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "restoreConfiguration", params, &r.Options, &resp)
  462     return
  463 }
  464 
  465 // Save an application delivery controller's configuration state. The notes property for this method is optional.
  466 func (r Network_Application_Delivery_Controller) SaveCurrentConfiguration(notes *string) (resp datatypes.Network_Application_Delivery_Controller_Configuration_History, err error) {
  467     params := []interface{}{
  468         notes,
  469     }
  470     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "saveCurrentConfiguration", params, &r.Options, &resp)
  471     return
  472 }
  473 
  474 // Update the the virtual IP address interface within an application delivery controller based load balancer identified by the ''name'' property in the loadBalancer parameter. You only need to set the properties in the loadBalancer parameter that you wish to change. Any virtual IP properties omitted or left empty are ignored. Changes are reflected immediately in the application delivery controller.
  475 func (r Network_Application_Delivery_Controller) UpdateLiveLoadBalancer(loadBalancer *datatypes.Network_LoadBalancer_VirtualIpAddress) (resp bool, err error) {
  476     params := []interface{}{
  477         loadBalancer,
  478     }
  479     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "updateLiveLoadBalancer", params, &r.Options, &resp)
  480     return
  481 }
  482 
  483 // Update the NetScaler VPX License.
  484 //
  485 // This service will create a transaction to update a NetScaler VPX License.  After the license is updated the load balancer will reboot in order to apply the newly issued license
  486 //
  487 // The load balancer will be unavailable during the reboot.
  488 func (r Network_Application_Delivery_Controller) UpdateNetScalerLicense() (resp datatypes.Provisioning_Version1_Transaction, err error) {
  489     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller", "updateNetScalerLicense", nil, &r.Options, &resp)
  490     return
  491 }
  492 
  493 // The SoftLayer_Network_Application_Delivery_Controller_Configuration_History data type models a single instance of a configuration history entry for an application delivery controller. The configuration history entries are used to support creating backups of an application delivery controller's configuration state in order to restore them later if needed.
  494 type Network_Application_Delivery_Controller_Configuration_History struct {
  495     Session *session.Session
  496     Options sl.Options
  497 }
  498 
  499 // GetNetworkApplicationDeliveryControllerConfigurationHistoryService returns an instance of the Network_Application_Delivery_Controller_Configuration_History SoftLayer service
  500 func GetNetworkApplicationDeliveryControllerConfigurationHistoryService(sess *session.Session) Network_Application_Delivery_Controller_Configuration_History {
  501     return Network_Application_Delivery_Controller_Configuration_History{Session: sess}
  502 }
  503 
  504 func (r Network_Application_Delivery_Controller_Configuration_History) Id(id int) Network_Application_Delivery_Controller_Configuration_History {
  505     r.Options.Id = &id
  506     return r
  507 }
  508 
  509 func (r Network_Application_Delivery_Controller_Configuration_History) Mask(mask string) Network_Application_Delivery_Controller_Configuration_History {
  510     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
  511         mask = fmt.Sprintf("mask[%s]", mask)
  512     }
  513 
  514     r.Options.Mask = mask
  515     return r
  516 }
  517 
  518 func (r Network_Application_Delivery_Controller_Configuration_History) Filter(filter string) Network_Application_Delivery_Controller_Configuration_History {
  519     r.Options.Filter = filter
  520     return r
  521 }
  522 
  523 func (r Network_Application_Delivery_Controller_Configuration_History) Limit(limit int) Network_Application_Delivery_Controller_Configuration_History {
  524     r.Options.Limit = &limit
  525     return r
  526 }
  527 
  528 func (r Network_Application_Delivery_Controller_Configuration_History) Offset(offset int) Network_Application_Delivery_Controller_Configuration_History {
  529     r.Options.Offset = &offset
  530     return r
  531 }
  532 
  533 // deleteObject permanently removes a configuration history record
  534 func (r Network_Application_Delivery_Controller_Configuration_History) DeleteObject() (resp bool, err error) {
  535     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_Configuration_History", "deleteObject", nil, &r.Options, &resp)
  536     return
  537 }
  538 
  539 // Retrieve The application delivery controller that a configuration history record belongs to.
  540 func (r Network_Application_Delivery_Controller_Configuration_History) GetController() (resp datatypes.Network_Application_Delivery_Controller, err error) {
  541     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_Configuration_History", "getController", nil, &r.Options, &resp)
  542     return
  543 }
  544 
  545 // no documentation yet
  546 func (r Network_Application_Delivery_Controller_Configuration_History) GetObject() (resp datatypes.Network_Application_Delivery_Controller_Configuration_History, err error) {
  547     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_Configuration_History", "getObject", nil, &r.Options, &resp)
  548     return
  549 }
  550 
  551 // no documentation yet
  552 type Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute struct {
  553     Session *session.Session
  554     Options sl.Options
  555 }
  556 
  557 // GetNetworkApplicationDeliveryControllerLoadBalancerHealthAttributeService returns an instance of the Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute SoftLayer service
  558 func GetNetworkApplicationDeliveryControllerLoadBalancerHealthAttributeService(sess *session.Session) Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute {
  559     return Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute{Session: sess}
  560 }
  561 
  562 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute) Id(id int) Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute {
  563     r.Options.Id = &id
  564     return r
  565 }
  566 
  567 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute) Mask(mask string) Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute {
  568     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
  569         mask = fmt.Sprintf("mask[%s]", mask)
  570     }
  571 
  572     r.Options.Mask = mask
  573     return r
  574 }
  575 
  576 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute) Filter(filter string) Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute {
  577     r.Options.Filter = filter
  578     return r
  579 }
  580 
  581 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute) Limit(limit int) Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute {
  582     r.Options.Limit = &limit
  583     return r
  584 }
  585 
  586 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute) Offset(offset int) Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute {
  587     r.Options.Offset = &offset
  588     return r
  589 }
  590 
  591 // Retrieve
  592 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute) GetHealthCheck() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Health_Check, err error) {
  593     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute", "getHealthCheck", nil, &r.Options, &resp)
  594     return
  595 }
  596 
  597 // no documentation yet
  598 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute) GetObject() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute, err error) {
  599     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute", "getObject", nil, &r.Options, &resp)
  600     return
  601 }
  602 
  603 // Retrieve
  604 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute) GetType() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type, err error) {
  605     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute", "getType", nil, &r.Options, &resp)
  606     return
  607 }
  608 
  609 // no documentation yet
  610 type Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type struct {
  611     Session *session.Session
  612     Options sl.Options
  613 }
  614 
  615 // GetNetworkApplicationDeliveryControllerLoadBalancerHealthAttributeTypeService returns an instance of the Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type SoftLayer service
  616 func GetNetworkApplicationDeliveryControllerLoadBalancerHealthAttributeTypeService(sess *session.Session) Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type {
  617     return Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type{Session: sess}
  618 }
  619 
  620 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type) Id(id int) Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type {
  621     r.Options.Id = &id
  622     return r
  623 }
  624 
  625 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type) Mask(mask string) Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type {
  626     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
  627         mask = fmt.Sprintf("mask[%s]", mask)
  628     }
  629 
  630     r.Options.Mask = mask
  631     return r
  632 }
  633 
  634 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type) Filter(filter string) Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type {
  635     r.Options.Filter = filter
  636     return r
  637 }
  638 
  639 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type) Limit(limit int) Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type {
  640     r.Options.Limit = &limit
  641     return r
  642 }
  643 
  644 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type) Offset(offset int) Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type {
  645     r.Options.Offset = &offset
  646     return r
  647 }
  648 
  649 // no documentation yet
  650 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type) GetAllObjects() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type, err error) {
  651     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type", "getAllObjects", nil, &r.Options, &resp)
  652     return
  653 }
  654 
  655 // no documentation yet
  656 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type) GetObject() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type, err error) {
  657     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute_Type", "getObject", nil, &r.Options, &resp)
  658     return
  659 }
  660 
  661 // no documentation yet
  662 type Network_Application_Delivery_Controller_LoadBalancer_Health_Check struct {
  663     Session *session.Session
  664     Options sl.Options
  665 }
  666 
  667 // GetNetworkApplicationDeliveryControllerLoadBalancerHealthCheckService returns an instance of the Network_Application_Delivery_Controller_LoadBalancer_Health_Check SoftLayer service
  668 func GetNetworkApplicationDeliveryControllerLoadBalancerHealthCheckService(sess *session.Session) Network_Application_Delivery_Controller_LoadBalancer_Health_Check {
  669     return Network_Application_Delivery_Controller_LoadBalancer_Health_Check{Session: sess}
  670 }
  671 
  672 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check) Id(id int) Network_Application_Delivery_Controller_LoadBalancer_Health_Check {
  673     r.Options.Id = &id
  674     return r
  675 }
  676 
  677 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check) Mask(mask string) Network_Application_Delivery_Controller_LoadBalancer_Health_Check {
  678     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
  679         mask = fmt.Sprintf("mask[%s]", mask)
  680     }
  681 
  682     r.Options.Mask = mask
  683     return r
  684 }
  685 
  686 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check) Filter(filter string) Network_Application_Delivery_Controller_LoadBalancer_Health_Check {
  687     r.Options.Filter = filter
  688     return r
  689 }
  690 
  691 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check) Limit(limit int) Network_Application_Delivery_Controller_LoadBalancer_Health_Check {
  692     r.Options.Limit = &limit
  693     return r
  694 }
  695 
  696 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check) Offset(offset int) Network_Application_Delivery_Controller_LoadBalancer_Health_Check {
  697     r.Options.Offset = &offset
  698     return r
  699 }
  700 
  701 // Retrieve
  702 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check) GetAttributes() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_Health_Attribute, err error) {
  703     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Health_Check", "getAttributes", nil, &r.Options, &resp)
  704     return
  705 }
  706 
  707 // no documentation yet
  708 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check) GetObject() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Health_Check, err error) {
  709     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Health_Check", "getObject", nil, &r.Options, &resp)
  710     return
  711 }
  712 
  713 // Retrieve Collection of scale load balancers that use this health check.
  714 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check) GetScaleLoadBalancers() (resp []datatypes.Scale_LoadBalancer, err error) {
  715     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Health_Check", "getScaleLoadBalancers", nil, &r.Options, &resp)
  716     return
  717 }
  718 
  719 // Retrieve
  720 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check) GetServices() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_Service, err error) {
  721     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Health_Check", "getServices", nil, &r.Options, &resp)
  722     return
  723 }
  724 
  725 // Retrieve
  726 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check) GetType() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type, err error) {
  727     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Health_Check", "getType", nil, &r.Options, &resp)
  728     return
  729 }
  730 
  731 // no documentation yet
  732 type Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type struct {
  733     Session *session.Session
  734     Options sl.Options
  735 }
  736 
  737 // GetNetworkApplicationDeliveryControllerLoadBalancerHealthCheckTypeService returns an instance of the Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type SoftLayer service
  738 func GetNetworkApplicationDeliveryControllerLoadBalancerHealthCheckTypeService(sess *session.Session) Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type {
  739     return Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type{Session: sess}
  740 }
  741 
  742 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type) Id(id int) Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type {
  743     r.Options.Id = &id
  744     return r
  745 }
  746 
  747 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type) Mask(mask string) Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type {
  748     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
  749         mask = fmt.Sprintf("mask[%s]", mask)
  750     }
  751 
  752     r.Options.Mask = mask
  753     return r
  754 }
  755 
  756 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type) Filter(filter string) Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type {
  757     r.Options.Filter = filter
  758     return r
  759 }
  760 
  761 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type) Limit(limit int) Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type {
  762     r.Options.Limit = &limit
  763     return r
  764 }
  765 
  766 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type) Offset(offset int) Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type {
  767     r.Options.Offset = &offset
  768     return r
  769 }
  770 
  771 // no documentation yet
  772 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type) GetAllObjects() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type, err error) {
  773     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type", "getAllObjects", nil, &r.Options, &resp)
  774     return
  775 }
  776 
  777 // no documentation yet
  778 func (r Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type) GetObject() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type, err error) {
  779     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type", "getObject", nil, &r.Options, &resp)
  780     return
  781 }
  782 
  783 // no documentation yet
  784 type Network_Application_Delivery_Controller_LoadBalancer_Routing_Method struct {
  785     Session *session.Session
  786     Options sl.Options
  787 }
  788 
  789 // GetNetworkApplicationDeliveryControllerLoadBalancerRoutingMethodService returns an instance of the Network_Application_Delivery_Controller_LoadBalancer_Routing_Method SoftLayer service
  790 func GetNetworkApplicationDeliveryControllerLoadBalancerRoutingMethodService(sess *session.Session) Network_Application_Delivery_Controller_LoadBalancer_Routing_Method {
  791     return Network_Application_Delivery_Controller_LoadBalancer_Routing_Method{Session: sess}
  792 }
  793 
  794 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Method) Id(id int) Network_Application_Delivery_Controller_LoadBalancer_Routing_Method {
  795     r.Options.Id = &id
  796     return r
  797 }
  798 
  799 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Method) Mask(mask string) Network_Application_Delivery_Controller_LoadBalancer_Routing_Method {
  800     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
  801         mask = fmt.Sprintf("mask[%s]", mask)
  802     }
  803 
  804     r.Options.Mask = mask
  805     return r
  806 }
  807 
  808 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Method) Filter(filter string) Network_Application_Delivery_Controller_LoadBalancer_Routing_Method {
  809     r.Options.Filter = filter
  810     return r
  811 }
  812 
  813 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Method) Limit(limit int) Network_Application_Delivery_Controller_LoadBalancer_Routing_Method {
  814     r.Options.Limit = &limit
  815     return r
  816 }
  817 
  818 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Method) Offset(offset int) Network_Application_Delivery_Controller_LoadBalancer_Routing_Method {
  819     r.Options.Offset = &offset
  820     return r
  821 }
  822 
  823 // no documentation yet
  824 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Method) GetAllObjects() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_Routing_Method, err error) {
  825     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Routing_Method", "getAllObjects", nil, &r.Options, &resp)
  826     return
  827 }
  828 
  829 // no documentation yet
  830 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Method) GetObject() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Routing_Method, err error) {
  831     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Routing_Method", "getObject", nil, &r.Options, &resp)
  832     return
  833 }
  834 
  835 // no documentation yet
  836 type Network_Application_Delivery_Controller_LoadBalancer_Routing_Type struct {
  837     Session *session.Session
  838     Options sl.Options
  839 }
  840 
  841 // GetNetworkApplicationDeliveryControllerLoadBalancerRoutingTypeService returns an instance of the Network_Application_Delivery_Controller_LoadBalancer_Routing_Type SoftLayer service
  842 func GetNetworkApplicationDeliveryControllerLoadBalancerRoutingTypeService(sess *session.Session) Network_Application_Delivery_Controller_LoadBalancer_Routing_Type {
  843     return Network_Application_Delivery_Controller_LoadBalancer_Routing_Type{Session: sess}
  844 }
  845 
  846 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Type) Id(id int) Network_Application_Delivery_Controller_LoadBalancer_Routing_Type {
  847     r.Options.Id = &id
  848     return r
  849 }
  850 
  851 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Type) Mask(mask string) Network_Application_Delivery_Controller_LoadBalancer_Routing_Type {
  852     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
  853         mask = fmt.Sprintf("mask[%s]", mask)
  854     }
  855 
  856     r.Options.Mask = mask
  857     return r
  858 }
  859 
  860 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Type) Filter(filter string) Network_Application_Delivery_Controller_LoadBalancer_Routing_Type {
  861     r.Options.Filter = filter
  862     return r
  863 }
  864 
  865 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Type) Limit(limit int) Network_Application_Delivery_Controller_LoadBalancer_Routing_Type {
  866     r.Options.Limit = &limit
  867     return r
  868 }
  869 
  870 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Type) Offset(offset int) Network_Application_Delivery_Controller_LoadBalancer_Routing_Type {
  871     r.Options.Offset = &offset
  872     return r
  873 }
  874 
  875 // no documentation yet
  876 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Type) GetAllObjects() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_Routing_Type, err error) {
  877     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Routing_Type", "getAllObjects", nil, &r.Options, &resp)
  878     return
  879 }
  880 
  881 // no documentation yet
  882 func (r Network_Application_Delivery_Controller_LoadBalancer_Routing_Type) GetObject() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Routing_Type, err error) {
  883     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Routing_Type", "getObject", nil, &r.Options, &resp)
  884     return
  885 }
  886 
  887 // no documentation yet
  888 type Network_Application_Delivery_Controller_LoadBalancer_Service struct {
  889     Session *session.Session
  890     Options sl.Options
  891 }
  892 
  893 // GetNetworkApplicationDeliveryControllerLoadBalancerServiceService returns an instance of the Network_Application_Delivery_Controller_LoadBalancer_Service SoftLayer service
  894 func GetNetworkApplicationDeliveryControllerLoadBalancerServiceService(sess *session.Session) Network_Application_Delivery_Controller_LoadBalancer_Service {
  895     return Network_Application_Delivery_Controller_LoadBalancer_Service{Session: sess}
  896 }
  897 
  898 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) Id(id int) Network_Application_Delivery_Controller_LoadBalancer_Service {
  899     r.Options.Id = &id
  900     return r
  901 }
  902 
  903 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) Mask(mask string) Network_Application_Delivery_Controller_LoadBalancer_Service {
  904     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
  905         mask = fmt.Sprintf("mask[%s]", mask)
  906     }
  907 
  908     r.Options.Mask = mask
  909     return r
  910 }
  911 
  912 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) Filter(filter string) Network_Application_Delivery_Controller_LoadBalancer_Service {
  913     r.Options.Filter = filter
  914     return r
  915 }
  916 
  917 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) Limit(limit int) Network_Application_Delivery_Controller_LoadBalancer_Service {
  918     r.Options.Limit = &limit
  919     return r
  920 }
  921 
  922 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) Offset(offset int) Network_Application_Delivery_Controller_LoadBalancer_Service {
  923     r.Options.Offset = &offset
  924     return r
  925 }
  926 
  927 // no documentation yet
  928 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) DeleteObject() (err error) {
  929     var resp datatypes.Void
  930     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service", "deleteObject", nil, &r.Options, &resp)
  931     return
  932 }
  933 
  934 // Get the graph image for a load balancer service based on the supplied graph type and metric.  The available graph types are: 'connections' and 'status', and the available metrics are: 'day', 'week' and 'month'.
  935 //
  936 // This method returns the raw binary image data.
  937 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) GetGraphImage(graphType *string, metric *string) (resp []byte, err error) {
  938     params := []interface{}{
  939         graphType,
  940         metric,
  941     }
  942     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service", "getGraphImage", params, &r.Options, &resp)
  943     return
  944 }
  945 
  946 // Retrieve
  947 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) GetGroupReferences() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_Service_Group_CrossReference, err error) {
  948     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service", "getGroupReferences", nil, &r.Options, &resp)
  949     return
  950 }
  951 
  952 // Retrieve
  953 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) GetGroups() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_Service_Group, err error) {
  954     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service", "getGroups", nil, &r.Options, &resp)
  955     return
  956 }
  957 
  958 // Retrieve
  959 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) GetHealthCheck() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Health_Check, err error) {
  960     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service", "getHealthCheck", nil, &r.Options, &resp)
  961     return
  962 }
  963 
  964 // Retrieve
  965 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) GetHealthChecks() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_Health_Check, err error) {
  966     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service", "getHealthChecks", nil, &r.Options, &resp)
  967     return
  968 }
  969 
  970 // Retrieve
  971 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) GetIpAddress() (resp datatypes.Network_Subnet_IpAddress, err error) {
  972     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service", "getIpAddress", nil, &r.Options, &resp)
  973     return
  974 }
  975 
  976 // no documentation yet
  977 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) GetObject() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Service, err error) {
  978     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service", "getObject", nil, &r.Options, &resp)
  979     return
  980 }
  981 
  982 // Retrieve
  983 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) GetServiceGroup() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Service_Group, err error) {
  984     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service", "getServiceGroup", nil, &r.Options, &resp)
  985     return
  986 }
  987 
  988 // no documentation yet
  989 func (r Network_Application_Delivery_Controller_LoadBalancer_Service) ToggleStatus() (resp bool, err error) {
  990     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service", "toggleStatus", nil, &r.Options, &resp)
  991     return
  992 }
  993 
  994 // no documentation yet
  995 type Network_Application_Delivery_Controller_LoadBalancer_Service_Group struct {
  996     Session *session.Session
  997     Options sl.Options
  998 }
  999 
 1000 // GetNetworkApplicationDeliveryControllerLoadBalancerServiceGroupService returns an instance of the Network_Application_Delivery_Controller_LoadBalancer_Service_Group SoftLayer service
 1001 func GetNetworkApplicationDeliveryControllerLoadBalancerServiceGroupService(sess *session.Session) Network_Application_Delivery_Controller_LoadBalancer_Service_Group {
 1002     return Network_Application_Delivery_Controller_LoadBalancer_Service_Group{Session: sess}
 1003 }
 1004 
 1005 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) Id(id int) Network_Application_Delivery_Controller_LoadBalancer_Service_Group {
 1006     r.Options.Id = &id
 1007     return r
 1008 }
 1009 
 1010 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) Mask(mask string) Network_Application_Delivery_Controller_LoadBalancer_Service_Group {
 1011     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 1012         mask = fmt.Sprintf("mask[%s]", mask)
 1013     }
 1014 
 1015     r.Options.Mask = mask
 1016     return r
 1017 }
 1018 
 1019 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) Filter(filter string) Network_Application_Delivery_Controller_LoadBalancer_Service_Group {
 1020     r.Options.Filter = filter
 1021     return r
 1022 }
 1023 
 1024 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) Limit(limit int) Network_Application_Delivery_Controller_LoadBalancer_Service_Group {
 1025     r.Options.Limit = &limit
 1026     return r
 1027 }
 1028 
 1029 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) Offset(offset int) Network_Application_Delivery_Controller_LoadBalancer_Service_Group {
 1030     r.Options.Offset = &offset
 1031     return r
 1032 }
 1033 
 1034 // Get the graph image for a load balancer service group based on the supplied graph type and metric.  The only available graph type currently is: 'connections', and the available metrics are: 'day', 'week' and 'month'.
 1035 //
 1036 // This method returns the raw binary image data.
 1037 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) GetGraphImage(graphType *string, metric *string) (resp []byte, err error) {
 1038     params := []interface{}{
 1039         graphType,
 1040         metric,
 1041     }
 1042     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service_Group", "getGraphImage", params, &r.Options, &resp)
 1043     return
 1044 }
 1045 
 1046 // no documentation yet
 1047 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) GetObject() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Service_Group, err error) {
 1048     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service_Group", "getObject", nil, &r.Options, &resp)
 1049     return
 1050 }
 1051 
 1052 // Retrieve
 1053 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) GetRoutingMethod() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Routing_Method, err error) {
 1054     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service_Group", "getRoutingMethod", nil, &r.Options, &resp)
 1055     return
 1056 }
 1057 
 1058 // Retrieve
 1059 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) GetRoutingType() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Routing_Type, err error) {
 1060     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service_Group", "getRoutingType", nil, &r.Options, &resp)
 1061     return
 1062 }
 1063 
 1064 // Retrieve
 1065 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) GetServiceReferences() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_Service_Group_CrossReference, err error) {
 1066     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service_Group", "getServiceReferences", nil, &r.Options, &resp)
 1067     return
 1068 }
 1069 
 1070 // Retrieve
 1071 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) GetServices() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_Service, err error) {
 1072     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service_Group", "getServices", nil, &r.Options, &resp)
 1073     return
 1074 }
 1075 
 1076 // Retrieve
 1077 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) GetVirtualServer() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_VirtualServer, err error) {
 1078     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service_Group", "getVirtualServer", nil, &r.Options, &resp)
 1079     return
 1080 }
 1081 
 1082 // Retrieve
 1083 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) GetVirtualServers() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_VirtualServer, err error) {
 1084     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service_Group", "getVirtualServers", nil, &r.Options, &resp)
 1085     return
 1086 }
 1087 
 1088 // no documentation yet
 1089 func (r Network_Application_Delivery_Controller_LoadBalancer_Service_Group) KickAllConnections() (resp bool, err error) {
 1090     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service_Group", "kickAllConnections", nil, &r.Options, &resp)
 1091     return
 1092 }
 1093 
 1094 // no documentation yet
 1095 type Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress struct {
 1096     Session *session.Session
 1097     Options sl.Options
 1098 }
 1099 
 1100 // GetNetworkApplicationDeliveryControllerLoadBalancerVirtualIpAddressService returns an instance of the Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress SoftLayer service
 1101 func GetNetworkApplicationDeliveryControllerLoadBalancerVirtualIpAddressService(sess *session.Session) Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress {
 1102     return Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress{Session: sess}
 1103 }
 1104 
 1105 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) Id(id int) Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress {
 1106     r.Options.Id = &id
 1107     return r
 1108 }
 1109 
 1110 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) Mask(mask string) Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress {
 1111     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 1112         mask = fmt.Sprintf("mask[%s]", mask)
 1113     }
 1114 
 1115     r.Options.Mask = mask
 1116     return r
 1117 }
 1118 
 1119 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) Filter(filter string) Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress {
 1120     r.Options.Filter = filter
 1121     return r
 1122 }
 1123 
 1124 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) Limit(limit int) Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress {
 1125     r.Options.Limit = &limit
 1126     return r
 1127 }
 1128 
 1129 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) Offset(offset int) Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress {
 1130     r.Options.Offset = &offset
 1131     return r
 1132 }
 1133 
 1134 // Like any other API object, the load balancers can have their exposed properties edited by passing in a modified version of the object.  The load balancer object also can modify its services in this way.  Simply request the load balancer object you wish to edit, then modify the objects in the services array and pass the modified object to this function.  WARNING:  Services cannot be deleted in this manner, you must call deleteObject() on the service to physically remove them from the load balancer.
 1135 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) EditObject(templateObject *datatypes.Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) (resp bool, err error) {
 1136     params := []interface{}{
 1137         templateObject,
 1138     }
 1139     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "editObject", params, &r.Options, &resp)
 1140     return
 1141 }
 1142 
 1143 // Retrieve
 1144 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetAccount() (resp datatypes.Account, err error) {
 1145     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getAccount", nil, &r.Options, &resp)
 1146     return
 1147 }
 1148 
 1149 // Retrieve A virtual IP address's associated application delivery controller.
 1150 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetApplicationDeliveryController() (resp datatypes.Network_Application_Delivery_Controller, err error) {
 1151     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getApplicationDeliveryController", nil, &r.Options, &resp)
 1152     return
 1153 }
 1154 
 1155 // Retrieve A virtual IP address's associated application delivery controllers.
 1156 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetApplicationDeliveryControllers() (resp []datatypes.Network_Application_Delivery_Controller, err error) {
 1157     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getApplicationDeliveryControllers", nil, &r.Options, &resp)
 1158     return
 1159 }
 1160 
 1161 // Yields a list of the SSL/TLS encryption ciphers that are currently supported on this virtual IP address instance.
 1162 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetAvailableSecureTransportCiphers() (resp []datatypes.Security_SecureTransportCipher, err error) {
 1163     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getAvailableSecureTransportCiphers", nil, &r.Options, &resp)
 1164     return
 1165 }
 1166 
 1167 // Yields a list of the secure communication protocols that are currently supported on this virtual IP address instance. The list of supported ciphers for each protocol is culled to match availability.
 1168 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetAvailableSecureTransportProtocols() (resp []datatypes.Security_SecureTransportProtocol, err error) {
 1169     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getAvailableSecureTransportProtocols", nil, &r.Options, &resp)
 1170     return
 1171 }
 1172 
 1173 // Retrieve The current billing item for the load balancer virtual IP. This is only valid when dedicatedFlag is false. This is an independent virtual IP, and if canceled, will only affect the associated virtual IP.
 1174 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetBillingItem() (resp datatypes.Billing_Item, err error) {
 1175     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getBillingItem", nil, &r.Options, &resp)
 1176     return
 1177 }
 1178 
 1179 // Retrieve The current billing item for the load balancing device housing the virtual IP. This billing item represents a device which could contain other virtual IPs. Caution should be taken when canceling. This is only valid when dedicatedFlag is true.
 1180 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetDedicatedBillingItem() (resp datatypes.Billing_Item_Network_LoadBalancer, err error) {
 1181     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getDedicatedBillingItem", nil, &r.Options, &resp)
 1182     return
 1183 }
 1184 
 1185 // Retrieve Denotes whether the virtual IP is configured within a high availability cluster.
 1186 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetHighAvailabilityFlag() (resp bool, err error) {
 1187     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getHighAvailabilityFlag", nil, &r.Options, &resp)
 1188     return
 1189 }
 1190 
 1191 // Retrieve
 1192 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetIpAddress() (resp datatypes.Network_Subnet_IpAddress, err error) {
 1193     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getIpAddress", nil, &r.Options, &resp)
 1194     return
 1195 }
 1196 
 1197 // Retrieve
 1198 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetLoadBalancerHardware() (resp []datatypes.Hardware, err error) {
 1199     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getLoadBalancerHardware", nil, &r.Options, &resp)
 1200     return
 1201 }
 1202 
 1203 // Retrieve A flag indicating that the load balancer is a managed resource.
 1204 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetManagedResourceFlag() (resp bool, err error) {
 1205     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getManagedResourceFlag", nil, &r.Options, &resp)
 1206     return
 1207 }
 1208 
 1209 // no documentation yet
 1210 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetObject() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress, err error) {
 1211     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getObject", nil, &r.Options, &resp)
 1212     return
 1213 }
 1214 
 1215 // Retrieve The list of security ciphers enabled for this virtual IP address
 1216 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetSecureTransportCiphers() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress_SecureTransportCipher, err error) {
 1217     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getSecureTransportCiphers", nil, &r.Options, &resp)
 1218     return
 1219 }
 1220 
 1221 // Retrieve The list of secure transport protocols enabled for this virtual IP address
 1222 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetSecureTransportProtocols() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress_SecureTransportProtocol, err error) {
 1223     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getSecureTransportProtocols", nil, &r.Options, &resp)
 1224     return
 1225 }
 1226 
 1227 // Retrieve The SSL certificate currently associated with the VIP.
 1228 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetSecurityCertificate() (resp datatypes.Security_Certificate, err error) {
 1229     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getSecurityCertificate", nil, &r.Options, &resp)
 1230     return
 1231 }
 1232 
 1233 // Retrieve The SSL certificate currently associated with the VIP. Provides chosen certificate visibility to unprivileged users.
 1234 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetSecurityCertificateEntry() (resp datatypes.Security_Certificate_Entry, err error) {
 1235     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getSecurityCertificateEntry", nil, &r.Options, &resp)
 1236     return
 1237 }
 1238 
 1239 // Retrieve
 1240 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) GetVirtualServers() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_VirtualServer, err error) {
 1241     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "getVirtualServers", nil, &r.Options, &resp)
 1242     return
 1243 }
 1244 
 1245 // Start SSL acceleration on all SSL virtual services (those with a type of HTTPS). This action should be taken only after configuring an SSL certificate for the virtual IP.
 1246 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) StartSsl() (resp bool, err error) {
 1247     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "startSsl", nil, &r.Options, &resp)
 1248     return
 1249 }
 1250 
 1251 // Stop SSL acceleration on all SSL virtual services (those with a type of HTTPS).
 1252 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) StopSsl() (resp bool, err error) {
 1253     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "stopSsl", nil, &r.Options, &resp)
 1254     return
 1255 }
 1256 
 1257 // Upgrades the connection limit on the Virtual IP to Address to the next, higher connection limit of the same product.
 1258 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress) UpgradeConnectionLimit() (resp bool, err error) {
 1259     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress", "upgradeConnectionLimit", nil, &r.Options, &resp)
 1260     return
 1261 }
 1262 
 1263 // no documentation yet
 1264 type Network_Application_Delivery_Controller_LoadBalancer_VirtualServer struct {
 1265     Session *session.Session
 1266     Options sl.Options
 1267 }
 1268 
 1269 // GetNetworkApplicationDeliveryControllerLoadBalancerVirtualServerService returns an instance of the Network_Application_Delivery_Controller_LoadBalancer_VirtualServer SoftLayer service
 1270 func GetNetworkApplicationDeliveryControllerLoadBalancerVirtualServerService(sess *session.Session) Network_Application_Delivery_Controller_LoadBalancer_VirtualServer {
 1271     return Network_Application_Delivery_Controller_LoadBalancer_VirtualServer{Session: sess}
 1272 }
 1273 
 1274 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualServer) Id(id int) Network_Application_Delivery_Controller_LoadBalancer_VirtualServer {
 1275     r.Options.Id = &id
 1276     return r
 1277 }
 1278 
 1279 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualServer) Mask(mask string) Network_Application_Delivery_Controller_LoadBalancer_VirtualServer {
 1280     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 1281         mask = fmt.Sprintf("mask[%s]", mask)
 1282     }
 1283 
 1284     r.Options.Mask = mask
 1285     return r
 1286 }
 1287 
 1288 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualServer) Filter(filter string) Network_Application_Delivery_Controller_LoadBalancer_VirtualServer {
 1289     r.Options.Filter = filter
 1290     return r
 1291 }
 1292 
 1293 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualServer) Limit(limit int) Network_Application_Delivery_Controller_LoadBalancer_VirtualServer {
 1294     r.Options.Limit = &limit
 1295     return r
 1296 }
 1297 
 1298 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualServer) Offset(offset int) Network_Application_Delivery_Controller_LoadBalancer_VirtualServer {
 1299     r.Options.Offset = &offset
 1300     return r
 1301 }
 1302 
 1303 // no documentation yet
 1304 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualServer) DeleteObject() (err error) {
 1305     var resp datatypes.Void
 1306     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualServer", "deleteObject", nil, &r.Options, &resp)
 1307     return
 1308 }
 1309 
 1310 // no documentation yet
 1311 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualServer) GetObject() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_VirtualServer, err error) {
 1312     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualServer", "getObject", nil, &r.Options, &resp)
 1313     return
 1314 }
 1315 
 1316 // Retrieve
 1317 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualServer) GetRoutingMethod() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_Routing_Method, err error) {
 1318     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualServer", "getRoutingMethod", nil, &r.Options, &resp)
 1319     return
 1320 }
 1321 
 1322 // Retrieve Collection of scale load balancers this virtual server applies to.
 1323 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualServer) GetScaleLoadBalancers() (resp []datatypes.Scale_LoadBalancer, err error) {
 1324     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualServer", "getScaleLoadBalancers", nil, &r.Options, &resp)
 1325     return
 1326 }
 1327 
 1328 // Retrieve
 1329 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualServer) GetServiceGroups() (resp []datatypes.Network_Application_Delivery_Controller_LoadBalancer_Service_Group, err error) {
 1330     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualServer", "getServiceGroups", nil, &r.Options, &resp)
 1331     return
 1332 }
 1333 
 1334 // Retrieve
 1335 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualServer) GetVirtualIpAddress() (resp datatypes.Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress, err error) {
 1336     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualServer", "getVirtualIpAddress", nil, &r.Options, &resp)
 1337     return
 1338 }
 1339 
 1340 // Start SSL acceleration on all SSL virtual services (those with a type of HTTPS). This action should be taken only after configuring an SSL certificate for the virtual IP.
 1341 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualServer) StartSsl() (resp bool, err error) {
 1342     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualServer", "startSsl", nil, &r.Options, &resp)
 1343     return
 1344 }
 1345 
 1346 // Stop SSL acceleration on all SSL virtual services (those with a type of HTTPS).
 1347 func (r Network_Application_Delivery_Controller_LoadBalancer_VirtualServer) StopSsl() (resp bool, err error) {
 1348     err = r.Session.DoRequest("SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualServer", "stopSsl", nil, &r.Options, &resp)
 1349     return
 1350 }
 1351 
 1352 // A SoftLayer_Network_Backbone represents a single backbone connection from SoftLayer to the public Internet, from the Internet to the SoftLayer private network, or a link that connects the private networks between SoftLayer's datacenters. The SoftLayer_Network_Backbone data type is a collection of data associated with one of those connections.
 1353 type Network_Backbone struct {
 1354     Session *session.Session
 1355     Options sl.Options
 1356 }
 1357 
 1358 // GetNetworkBackboneService returns an instance of the Network_Backbone SoftLayer service
 1359 func GetNetworkBackboneService(sess *session.Session) Network_Backbone {
 1360     return Network_Backbone{Session: sess}
 1361 }
 1362 
 1363 func (r Network_Backbone) Id(id int) Network_Backbone {
 1364     r.Options.Id = &id
 1365     return r
 1366 }
 1367 
 1368 func (r Network_Backbone) Mask(mask string) Network_Backbone {
 1369     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 1370         mask = fmt.Sprintf("mask[%s]", mask)
 1371     }
 1372 
 1373     r.Options.Mask = mask
 1374     return r
 1375 }
 1376 
 1377 func (r Network_Backbone) Filter(filter string) Network_Backbone {
 1378     r.Options.Filter = filter
 1379     return r
 1380 }
 1381 
 1382 func (r Network_Backbone) Limit(limit int) Network_Backbone {
 1383     r.Options.Limit = &limit
 1384     return r
 1385 }
 1386 
 1387 func (r Network_Backbone) Offset(offset int) Network_Backbone {
 1388     r.Options.Offset = &offset
 1389     return r
 1390 }
 1391 
 1392 // Retrieve a list of all SoftLayer backbone connections. Use this method if you need all backbones or don't know the id number of a specific backbone.
 1393 func (r Network_Backbone) GetAllBackbones() (resp []datatypes.Network_Backbone, err error) {
 1394     err = r.Session.DoRequest("SoftLayer_Network_Backbone", "getAllBackbones", nil, &r.Options, &resp)
 1395     return
 1396 }
 1397 
 1398 // Retrieve a list of all SoftLayer backbone connections for a location name.
 1399 func (r Network_Backbone) GetBackbonesForLocationName(locationName *string) (resp []datatypes.Network_Backbone, err error) {
 1400     params := []interface{}{
 1401         locationName,
 1402     }
 1403     err = r.Session.DoRequest("SoftLayer_Network_Backbone", "getBackbonesForLocationName", params, &r.Options, &resp)
 1404     return
 1405 }
 1406 
 1407 // Retrieve a graph of a SoftLayer backbone's last 24 hours of activity. getGraphImage returns a PNG image measuring 827 pixels by 293 pixels.
 1408 func (r Network_Backbone) GetGraphImage() (resp []byte, err error) {
 1409     err = r.Session.DoRequest("SoftLayer_Network_Backbone", "getGraphImage", nil, &r.Options, &resp)
 1410     return
 1411 }
 1412 
 1413 // Retrieve A backbone's status.
 1414 func (r Network_Backbone) GetHealth() (resp string, err error) {
 1415     err = r.Session.DoRequest("SoftLayer_Network_Backbone", "getHealth", nil, &r.Options, &resp)
 1416     return
 1417 }
 1418 
 1419 // Retrieve Which of the SoftLayer datacenters a backbone is connected to.
 1420 func (r Network_Backbone) GetLocation() (resp datatypes.Location, err error) {
 1421     err = r.Session.DoRequest("SoftLayer_Network_Backbone", "getLocation", nil, &r.Options, &resp)
 1422     return
 1423 }
 1424 
 1425 // Retrieve A backbone's primary network component.
 1426 func (r Network_Backbone) GetNetworkComponent() (resp datatypes.Network_Component, err error) {
 1427     err = r.Session.DoRequest("SoftLayer_Network_Backbone", "getNetworkComponent", nil, &r.Options, &resp)
 1428     return
 1429 }
 1430 
 1431 // Retrieve an individual SoftLayer_Network_Backbone record. Use the getAllBackbones() method to retrieve a list of all SoftLayer network backbones.
 1432 func (r Network_Backbone) GetObject() (resp datatypes.Network_Backbone, err error) {
 1433     err = r.Session.DoRequest("SoftLayer_Network_Backbone", "getObject", nil, &r.Options, &resp)
 1434     return
 1435 }
 1436 
 1437 // no documentation yet
 1438 type Network_Backbone_Location_Dependent struct {
 1439     Session *session.Session
 1440     Options sl.Options
 1441 }
 1442 
 1443 // GetNetworkBackboneLocationDependentService returns an instance of the Network_Backbone_Location_Dependent SoftLayer service
 1444 func GetNetworkBackboneLocationDependentService(sess *session.Session) Network_Backbone_Location_Dependent {
 1445     return Network_Backbone_Location_Dependent{Session: sess}
 1446 }
 1447 
 1448 func (r Network_Backbone_Location_Dependent) Id(id int) Network_Backbone_Location_Dependent {
 1449     r.Options.Id = &id
 1450     return r
 1451 }
 1452 
 1453 func (r Network_Backbone_Location_Dependent) Mask(mask string) Network_Backbone_Location_Dependent {
 1454     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 1455         mask = fmt.Sprintf("mask[%s]", mask)
 1456     }
 1457 
 1458     r.Options.Mask = mask
 1459     return r
 1460 }
 1461 
 1462 func (r Network_Backbone_Location_Dependent) Filter(filter string) Network_Backbone_Location_Dependent {
 1463     r.Options.Filter = filter
 1464     return r
 1465 }
 1466 
 1467 func (r Network_Backbone_Location_Dependent) Limit(limit int) Network_Backbone_Location_Dependent {
 1468     r.Options.Limit = &limit
 1469     return r
 1470 }
 1471 
 1472 func (r Network_Backbone_Location_Dependent) Offset(offset int) Network_Backbone_Location_Dependent {
 1473     r.Options.Offset = &offset
 1474     return r
 1475 }
 1476 
 1477 // no documentation yet
 1478 func (r Network_Backbone_Location_Dependent) GetAllObjects() (resp []datatypes.Network_Backbone_Location_Dependent, err error) {
 1479     err = r.Session.DoRequest("SoftLayer_Network_Backbone_Location_Dependent", "getAllObjects", nil, &r.Options, &resp)
 1480     return
 1481 }
 1482 
 1483 // Retrieve
 1484 func (r Network_Backbone_Location_Dependent) GetDependentLocation() (resp datatypes.Location, err error) {
 1485     err = r.Session.DoRequest("SoftLayer_Network_Backbone_Location_Dependent", "getDependentLocation", nil, &r.Options, &resp)
 1486     return
 1487 }
 1488 
 1489 // no documentation yet
 1490 func (r Network_Backbone_Location_Dependent) GetObject() (resp datatypes.Network_Backbone_Location_Dependent, err error) {
 1491     err = r.Session.DoRequest("SoftLayer_Network_Backbone_Location_Dependent", "getObject", nil, &r.Options, &resp)
 1492     return
 1493 }
 1494 
 1495 // no documentation yet
 1496 func (r Network_Backbone_Location_Dependent) GetSourceDependentsByName(locationName *string) (resp datatypes.Location, err error) {
 1497     params := []interface{}{
 1498         locationName,
 1499     }
 1500     err = r.Session.DoRequest("SoftLayer_Network_Backbone_Location_Dependent", "getSourceDependentsByName", params, &r.Options, &resp)
 1501     return
 1502 }
 1503 
 1504 // Retrieve
 1505 func (r Network_Backbone_Location_Dependent) GetSourceLocation() (resp datatypes.Location, err error) {
 1506     err = r.Session.DoRequest("SoftLayer_Network_Backbone_Location_Dependent", "getSourceLocation", nil, &r.Options, &resp)
 1507     return
 1508 }
 1509 
 1510 // The SoftLayer_Network_Bandwidth_Version1_Allotment class provides methods and data structures necessary to work with an array of hardware objects associated with a single Bandwidth Pooling.
 1511 type Network_Bandwidth_Version1_Allotment struct {
 1512     Session *session.Session
 1513     Options sl.Options
 1514 }
 1515 
 1516 // GetNetworkBandwidthVersion1AllotmentService returns an instance of the Network_Bandwidth_Version1_Allotment SoftLayer service
 1517 func GetNetworkBandwidthVersion1AllotmentService(sess *session.Session) Network_Bandwidth_Version1_Allotment {
 1518     return Network_Bandwidth_Version1_Allotment{Session: sess}
 1519 }
 1520 
 1521 func (r Network_Bandwidth_Version1_Allotment) Id(id int) Network_Bandwidth_Version1_Allotment {
 1522     r.Options.Id = &id
 1523     return r
 1524 }
 1525 
 1526 func (r Network_Bandwidth_Version1_Allotment) Mask(mask string) Network_Bandwidth_Version1_Allotment {
 1527     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 1528         mask = fmt.Sprintf("mask[%s]", mask)
 1529     }
 1530 
 1531     r.Options.Mask = mask
 1532     return r
 1533 }
 1534 
 1535 func (r Network_Bandwidth_Version1_Allotment) Filter(filter string) Network_Bandwidth_Version1_Allotment {
 1536     r.Options.Filter = filter
 1537     return r
 1538 }
 1539 
 1540 func (r Network_Bandwidth_Version1_Allotment) Limit(limit int) Network_Bandwidth_Version1_Allotment {
 1541     r.Options.Limit = &limit
 1542     return r
 1543 }
 1544 
 1545 func (r Network_Bandwidth_Version1_Allotment) Offset(offset int) Network_Bandwidth_Version1_Allotment {
 1546     r.Options.Offset = &offset
 1547     return r
 1548 }
 1549 
 1550 // Create a allotment for servers to pool bandwidth and avoid overages in billing if they use more than there allocated bandwidth.
 1551 func (r Network_Bandwidth_Version1_Allotment) CreateObject(templateObject *datatypes.Network_Bandwidth_Version1_Allotment) (resp datatypes.Network_Bandwidth_Version1_Allotment, err error) {
 1552     params := []interface{}{
 1553         templateObject,
 1554     }
 1555     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "createObject", params, &r.Options, &resp)
 1556     return
 1557 }
 1558 
 1559 // Edit a bandwidth allotment's local properties. Currently you may only change an allotment's name. Use the [[SoftLayer_Network_Bandwidth_Version1_Allotment::reassignServers|reassignServers()]] and [[SoftLayer_Network_Bandwidth_Version1_Allotment::unassignServers|unassignServers()]] methods to move servers in and out of your allotments.
 1560 func (r Network_Bandwidth_Version1_Allotment) EditObject(templateObject *datatypes.Network_Bandwidth_Version1_Allotment) (resp bool, err error) {
 1561     params := []interface{}{
 1562         templateObject,
 1563     }
 1564     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "editObject", params, &r.Options, &resp)
 1565     return
 1566 }
 1567 
 1568 // Retrieve The account associated with this virtual rack.
 1569 func (r Network_Bandwidth_Version1_Allotment) GetAccount() (resp datatypes.Account, err error) {
 1570     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getAccount", nil, &r.Options, &resp)
 1571     return
 1572 }
 1573 
 1574 // Retrieve The bandwidth allotment detail records associated with this virtual rack.
 1575 func (r Network_Bandwidth_Version1_Allotment) GetActiveDetails() (resp []datatypes.Network_Bandwidth_Version1_Allotment_Detail, err error) {
 1576     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getActiveDetails", nil, &r.Options, &resp)
 1577     return
 1578 }
 1579 
 1580 // Retrieve The Application Delivery Controller contained within a virtual rack.
 1581 func (r Network_Bandwidth_Version1_Allotment) GetApplicationDeliveryControllers() (resp []datatypes.Network_Application_Delivery_Controller, err error) {
 1582     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getApplicationDeliveryControllers", nil, &r.Options, &resp)
 1583     return
 1584 }
 1585 
 1586 // Retrieve The average daily public bandwidth usage for the current billing cycle.
 1587 func (r Network_Bandwidth_Version1_Allotment) GetAverageDailyPublicBandwidthUsage() (resp datatypes.Float64, err error) {
 1588     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getAverageDailyPublicBandwidthUsage", nil, &r.Options, &resp)
 1589     return
 1590 }
 1591 
 1592 // This method recurses through all servers on a Bandwidth Pool for 24 hour time span starting at a given date/time. To get the private data set for all servers on a Bandwidth Pool from midnight Feb 1st, 2008 to 23:59 on Feb 1st, you would pass a parameter of '02/01/2008 0:00'.  The ending date / time is calculated for you to prevent requesting data from the server for periods larger than 24 hours as this method requires processing a lot of data records and can get slow at times.
 1593 func (r Network_Bandwidth_Version1_Allotment) GetBackendBandwidthByHour(date *datatypes.Time) (resp []datatypes.Container_Network_Bandwidth_Version1_Usage, err error) {
 1594     params := []interface{}{
 1595         date,
 1596     }
 1597     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getBackendBandwidthByHour", params, &r.Options, &resp)
 1598     return
 1599 }
 1600 
 1601 // This method recurses through all servers on a Bandwidth Pool between the given start and end dates to retrieve public bandwidth data.
 1602 func (r Network_Bandwidth_Version1_Allotment) GetBackendBandwidthUse(startDate *datatypes.Time, endDate *datatypes.Time) (resp []datatypes.Network_Bandwidth_Version1_Usage_Detail, err error) {
 1603     params := []interface{}{
 1604         startDate,
 1605         endDate,
 1606     }
 1607     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getBackendBandwidthUse", params, &r.Options, &resp)
 1608     return
 1609 }
 1610 
 1611 // Retrieve The bandwidth allotment type of this virtual rack.
 1612 func (r Network_Bandwidth_Version1_Allotment) GetBandwidthAllotmentType() (resp datatypes.Network_Bandwidth_Version1_Allotment_Type, err error) {
 1613     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getBandwidthAllotmentType", nil, &r.Options, &resp)
 1614     return
 1615 }
 1616 
 1617 // Retrieve a collection of bandwidth data from an individual public or private network tracking object. Data is ideal if you with to employ your own traffic storage and graphing systems.
 1618 func (r Network_Bandwidth_Version1_Allotment) GetBandwidthForDateRange(startDate *datatypes.Time, endDate *datatypes.Time) (resp []datatypes.Metric_Tracking_Object_Data, err error) {
 1619     params := []interface{}{
 1620         startDate,
 1621         endDate,
 1622     }
 1623     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getBandwidthForDateRange", params, &r.Options, &resp)
 1624     return
 1625 }
 1626 
 1627 // This method recurses through all servers on a Bandwidth Pool for a given snapshot range, gathers the necessary parameters, and then calls the bandwidth graphing server.  The return result is a container that includes the min and max dates for all servers to be used in the query, as well as an image in PNG format.  This method uses the new and improved drawing routines which should return in a reasonable time frame now that the new backend data warehouse is used.
 1628 func (r Network_Bandwidth_Version1_Allotment) GetBandwidthImage(networkType *string, snapshotRange *string, draw *bool, dateSpecified *datatypes.Time, dateSpecifiedEnd *datatypes.Time) (resp datatypes.Container_Bandwidth_GraphOutputs, err error) {
 1629     params := []interface{}{
 1630         networkType,
 1631         snapshotRange,
 1632         draw,
 1633         dateSpecified,
 1634         dateSpecifiedEnd,
 1635     }
 1636     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getBandwidthImage", params, &r.Options, &resp)
 1637     return
 1638 }
 1639 
 1640 // Retrieve The bare metal server instances contained within a virtual rack.
 1641 func (r Network_Bandwidth_Version1_Allotment) GetBareMetalInstances() (resp []datatypes.Hardware, err error) {
 1642     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getBareMetalInstances", nil, &r.Options, &resp)
 1643     return
 1644 }
 1645 
 1646 // Retrieve A virtual rack's raw bandwidth usage data for an account's current billing cycle. One object is returned for each network this server is attached to.
 1647 func (r Network_Bandwidth_Version1_Allotment) GetBillingCycleBandwidthUsage() (resp []datatypes.Network_Bandwidth_Usage, err error) {
 1648     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getBillingCycleBandwidthUsage", nil, &r.Options, &resp)
 1649     return
 1650 }
 1651 
 1652 // Retrieve A virtual rack's raw private network bandwidth usage data for an account's current billing cycle.
 1653 func (r Network_Bandwidth_Version1_Allotment) GetBillingCyclePrivateBandwidthUsage() (resp datatypes.Network_Bandwidth_Usage, err error) {
 1654     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getBillingCyclePrivateBandwidthUsage", nil, &r.Options, &resp)
 1655     return
 1656 }
 1657 
 1658 // Retrieve A virtual rack's raw public network bandwidth usage data for an account's current billing cycle.
 1659 func (r Network_Bandwidth_Version1_Allotment) GetBillingCyclePublicBandwidthUsage() (resp datatypes.Network_Bandwidth_Usage, err error) {
 1660     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getBillingCyclePublicBandwidthUsage", nil, &r.Options, &resp)
 1661     return
 1662 }
 1663 
 1664 // Retrieve The total public bandwidth used in this virtual rack for an account's current billing cycle.
 1665 func (r Network_Bandwidth_Version1_Allotment) GetBillingCyclePublicUsageTotal() (resp uint, err error) {
 1666     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getBillingCyclePublicUsageTotal", nil, &r.Options, &resp)
 1667     return
 1668 }
 1669 
 1670 // Retrieve A virtual rack's billing item.
 1671 func (r Network_Bandwidth_Version1_Allotment) GetBillingItem() (resp datatypes.Billing_Item, err error) {
 1672     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getBillingItem", nil, &r.Options, &resp)
 1673     return
 1674 }
 1675 
 1676 // Retrieve An object that provides commonly used bandwidth summary components for the current billing cycle.
 1677 func (r Network_Bandwidth_Version1_Allotment) GetCurrentBandwidthSummary() (resp datatypes.Metric_Tracking_Object_Bandwidth_Summary, err error) {
 1678     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getCurrentBandwidthSummary", nil, &r.Options, &resp)
 1679     return
 1680 }
 1681 
 1682 // Retrieve bandwidth graph by date.
 1683 func (r Network_Bandwidth_Version1_Allotment) GetCustomBandwidthDataByDate(graphData *datatypes.Container_Graph) (resp datatypes.Container_Graph, err error) {
 1684     params := []interface{}{
 1685         graphData,
 1686     }
 1687     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getCustomBandwidthDataByDate", params, &r.Options, &resp)
 1688     return
 1689 }
 1690 
 1691 // Retrieve The bandwidth allotment detail records associated with this virtual rack.
 1692 func (r Network_Bandwidth_Version1_Allotment) GetDetails() (resp []datatypes.Network_Bandwidth_Version1_Allotment_Detail, err error) {
 1693     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getDetails", nil, &r.Options, &resp)
 1694     return
 1695 }
 1696 
 1697 // This method recurses through all servers on a Bandwidth Pool for 24 hour time span starting at a given date/time. To get the public data set for all servers on a Bandwidth Pool from midnight Feb 1st, 2008 to 23:59 on Feb 1st, you would pass a parameter of '02/01/2008 0:00'.  The ending date / time is calculated for you to prevent requesting data from the server for periods larger than 24 hours as this method requires processing a lot of data records and can get slow at times.
 1698 func (r Network_Bandwidth_Version1_Allotment) GetFrontendBandwidthByHour(date *datatypes.Time) (resp []datatypes.Container_Network_Bandwidth_Version1_Usage, err error) {
 1699     params := []interface{}{
 1700         date,
 1701     }
 1702     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getFrontendBandwidthByHour", params, &r.Options, &resp)
 1703     return
 1704 }
 1705 
 1706 // This method recurses through all servers on a Bandwidth Pool between the given start and end dates to retrieve private bandwidth data.
 1707 func (r Network_Bandwidth_Version1_Allotment) GetFrontendBandwidthUse(startDate *datatypes.Time, endDate *datatypes.Time) (resp []datatypes.Network_Bandwidth_Version1_Usage_Detail, err error) {
 1708     params := []interface{}{
 1709         startDate,
 1710         endDate,
 1711     }
 1712     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getFrontendBandwidthUse", params, &r.Options, &resp)
 1713     return
 1714 }
 1715 
 1716 // Retrieve The hardware contained within a virtual rack.
 1717 func (r Network_Bandwidth_Version1_Allotment) GetHardware() (resp []datatypes.Hardware, err error) {
 1718     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getHardware", nil, &r.Options, &resp)
 1719     return
 1720 }
 1721 
 1722 // Retrieve The total public inbound bandwidth used in this virtual rack for an account's current billing cycle.
 1723 func (r Network_Bandwidth_Version1_Allotment) GetInboundPublicBandwidthUsage() (resp datatypes.Float64, err error) {
 1724     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getInboundPublicBandwidthUsage", nil, &r.Options, &resp)
 1725     return
 1726 }
 1727 
 1728 // Retrieve The location group associated with this virtual rack.
 1729 func (r Network_Bandwidth_Version1_Allotment) GetLocationGroup() (resp datatypes.Location_Group, err error) {
 1730     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getLocationGroup", nil, &r.Options, &resp)
 1731     return
 1732 }
 1733 
 1734 // Retrieve The managed bare metal server instances contained within a virtual rack.
 1735 func (r Network_Bandwidth_Version1_Allotment) GetManagedBareMetalInstances() (resp []datatypes.Hardware, err error) {
 1736     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getManagedBareMetalInstances", nil, &r.Options, &resp)
 1737     return
 1738 }
 1739 
 1740 // Retrieve The managed hardware contained within a virtual rack.
 1741 func (r Network_Bandwidth_Version1_Allotment) GetManagedHardware() (resp []datatypes.Hardware, err error) {
 1742     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getManagedHardware", nil, &r.Options, &resp)
 1743     return
 1744 }
 1745 
 1746 // Retrieve The managed Virtual Server contained within a virtual rack.
 1747 func (r Network_Bandwidth_Version1_Allotment) GetManagedVirtualGuests() (resp []datatypes.Virtual_Guest, err error) {
 1748     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getManagedVirtualGuests", nil, &r.Options, &resp)
 1749     return
 1750 }
 1751 
 1752 // Retrieve A virtual rack's metric tracking object. This object records all periodic polled data available to this rack.
 1753 func (r Network_Bandwidth_Version1_Allotment) GetMetricTrackingObject() (resp datatypes.Metric_Tracking_Object_VirtualDedicatedRack, err error) {
 1754     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getMetricTrackingObject", nil, &r.Options, &resp)
 1755     return
 1756 }
 1757 
 1758 // Retrieve The metric tracking object id for this allotment.
 1759 func (r Network_Bandwidth_Version1_Allotment) GetMetricTrackingObjectId() (resp int, err error) {
 1760     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getMetricTrackingObjectId", nil, &r.Options, &resp)
 1761     return
 1762 }
 1763 
 1764 // getObject retrieves the SoftLayer_Network_Bandwidth_Version1_Allotment object whose ID number corresponds to the ID number of the init parameter passed to the SoftLayer_Hardware service. You can only retrieve an allotment associated with the account that your portal user is assigned to.
 1765 func (r Network_Bandwidth_Version1_Allotment) GetObject() (resp datatypes.Network_Bandwidth_Version1_Allotment, err error) {
 1766     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getObject", nil, &r.Options, &resp)
 1767     return
 1768 }
 1769 
 1770 // Retrieve The total public outbound bandwidth used in this virtual rack for an account's current billing cycle.
 1771 func (r Network_Bandwidth_Version1_Allotment) GetOutboundPublicBandwidthUsage() (resp datatypes.Float64, err error) {
 1772     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getOutboundPublicBandwidthUsage", nil, &r.Options, &resp)
 1773     return
 1774 }
 1775 
 1776 // Retrieve Whether the bandwidth usage for this bandwidth pool for the current billing cycle exceeds the allocation.
 1777 func (r Network_Bandwidth_Version1_Allotment) GetOverBandwidthAllocationFlag() (resp int, err error) {
 1778     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getOverBandwidthAllocationFlag", nil, &r.Options, &resp)
 1779     return
 1780 }
 1781 
 1782 // Retrieve The private network only hardware contained within a virtual rack.
 1783 func (r Network_Bandwidth_Version1_Allotment) GetPrivateNetworkOnlyHardware() (resp []datatypes.Hardware, err error) {
 1784     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getPrivateNetworkOnlyHardware", nil, &r.Options, &resp)
 1785     return
 1786 }
 1787 
 1788 // Retrieve Whether the bandwidth usage for this bandwidth pool for the current billing cycle is projected to exceed the allocation.
 1789 func (r Network_Bandwidth_Version1_Allotment) GetProjectedOverBandwidthAllocationFlag() (resp int, err error) {
 1790     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getProjectedOverBandwidthAllocationFlag", nil, &r.Options, &resp)
 1791     return
 1792 }
 1793 
 1794 // Retrieve The projected public outbound bandwidth for this virtual server for the current billing cycle.
 1795 func (r Network_Bandwidth_Version1_Allotment) GetProjectedPublicBandwidthUsage() (resp datatypes.Float64, err error) {
 1796     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getProjectedPublicBandwidthUsage", nil, &r.Options, &resp)
 1797     return
 1798 }
 1799 
 1800 // Retrieve
 1801 func (r Network_Bandwidth_Version1_Allotment) GetServiceProvider() (resp datatypes.Service_Provider, err error) {
 1802     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getServiceProvider", nil, &r.Options, &resp)
 1803     return
 1804 }
 1805 
 1806 // Retrieve The combined allocated bandwidth for all servers in a virtual rack.
 1807 func (r Network_Bandwidth_Version1_Allotment) GetTotalBandwidthAllocated() (resp uint, err error) {
 1808     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getTotalBandwidthAllocated", nil, &r.Options, &resp)
 1809     return
 1810 }
 1811 
 1812 // Gets the monthly recurring fee of a pooled server.
 1813 func (r Network_Bandwidth_Version1_Allotment) GetVdrMemberRecurringFee() (resp datatypes.Float64, err error) {
 1814     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getVdrMemberRecurringFee", nil, &r.Options, &resp)
 1815     return
 1816 }
 1817 
 1818 // Retrieve The Virtual Server contained within a virtual rack.
 1819 func (r Network_Bandwidth_Version1_Allotment) GetVirtualGuests() (resp []datatypes.Virtual_Guest, err error) {
 1820     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "getVirtualGuests", nil, &r.Options, &resp)
 1821     return
 1822 }
 1823 
 1824 // This method will reassign a collection of SoftLayer hardware to a bandwidth allotment Bandwidth Pool.
 1825 func (r Network_Bandwidth_Version1_Allotment) ReassignServers(templateObjects []datatypes.Hardware, newAllotmentId *int) (resp bool, err error) {
 1826     params := []interface{}{
 1827         templateObjects,
 1828         newAllotmentId,
 1829     }
 1830     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "reassignServers", params, &r.Options, &resp)
 1831     return
 1832 }
 1833 
 1834 // This will remove a bandwidth pooling from a customer's allotments by cancelling the billing item.  All servers in that allotment will get moved to the account's vpr.
 1835 func (r Network_Bandwidth_Version1_Allotment) RequestVdrCancellation() (resp bool, err error) {
 1836     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "requestVdrCancellation", nil, &r.Options, &resp)
 1837     return
 1838 }
 1839 
 1840 // This will move servers into a bandwidth pool, removing them from their previous bandwidth pool and optionally remove the bandwidth pool on completion.
 1841 func (r Network_Bandwidth_Version1_Allotment) RequestVdrContentUpdates(hardwareToAdd []datatypes.Hardware, hardwareToRemove []datatypes.Hardware, cloudsToAdd []datatypes.Virtual_Guest, cloudsToRemove []datatypes.Virtual_Guest, optionalAllotmentId *int, adcToAdd []datatypes.Network_Application_Delivery_Controller, adcToRemove []datatypes.Network_Application_Delivery_Controller) (resp bool, err error) {
 1842     params := []interface{}{
 1843         hardwareToAdd,
 1844         hardwareToRemove,
 1845         cloudsToAdd,
 1846         cloudsToRemove,
 1847         optionalAllotmentId,
 1848         adcToAdd,
 1849         adcToRemove,
 1850     }
 1851     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "requestVdrContentUpdates", params, &r.Options, &resp)
 1852     return
 1853 }
 1854 
 1855 // This will update the bandwidth pool to the servers provided.  Servers currently in the bandwidth pool not provided on update will be removed. Servers provided on update not currently in the bandwidth pool will be added. If all servers are removed, this removes the bandwidth pool on completion.
 1856 func (r Network_Bandwidth_Version1_Allotment) SetVdrContent(hardware []datatypes.Hardware, bareMetalServers []datatypes.Hardware, virtualServerInstance []datatypes.Virtual_Guest, adc []datatypes.Network_Application_Delivery_Controller, optionalAllotmentId *int) (resp bool, err error) {
 1857     params := []interface{}{
 1858         hardware,
 1859         bareMetalServers,
 1860         virtualServerInstance,
 1861         adc,
 1862         optionalAllotmentId,
 1863     }
 1864     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "setVdrContent", params, &r.Options, &resp)
 1865     return
 1866 }
 1867 
 1868 // This method will reassign a collection of SoftLayer hardware to the virtual private rack
 1869 func (r Network_Bandwidth_Version1_Allotment) UnassignServers(templateObjects []datatypes.Hardware) (resp bool, err error) {
 1870     params := []interface{}{
 1871         templateObjects,
 1872     }
 1873     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "unassignServers", params, &r.Options, &resp)
 1874     return
 1875 }
 1876 
 1877 // This method will void a pending server removal from this bandwidth pooling. Pass in the id of the hardware object or virtual guest you wish to update. Assuming that object is currently pending removal from the bandwidth pool at the start of the next billing cycle, the bandwidth pool member status will be restored and the pending cancellation removed.
 1878 func (r Network_Bandwidth_Version1_Allotment) VoidPendingServerMove(id *int, typ *string) (resp bool, err error) {
 1879     params := []interface{}{
 1880         id,
 1881         typ,
 1882     }
 1883     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "voidPendingServerMove", params, &r.Options, &resp)
 1884     return
 1885 }
 1886 
 1887 // This method will void a pending cancellation on a bandwidth pool. Note however any servers that belonged to the rack will have to be restored individually using the method voidPendingServerMove($id, $type).
 1888 func (r Network_Bandwidth_Version1_Allotment) VoidPendingVdrCancellation() (resp bool, err error) {
 1889     err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "voidPendingVdrCancellation", nil, &r.Options, &resp)
 1890     return
 1891 }
 1892 
 1893 // Every piece of hardware running in SoftLayer's datacenters connected to the public, private, or management networks (where applicable) have a corresponding network component. These network components are modeled by the SoftLayer_Network_Component data type. These data types reflect the servers' local ethernet and remote management interfaces.
 1894 type Network_Component struct {
 1895     Session *session.Session
 1896     Options sl.Options
 1897 }
 1898 
 1899 // GetNetworkComponentService returns an instance of the Network_Component SoftLayer service
 1900 func GetNetworkComponentService(sess *session.Session) Network_Component {
 1901     return Network_Component{Session: sess}
 1902 }
 1903 
 1904 func (r Network_Component) Id(id int) Network_Component {
 1905     r.Options.Id = &id
 1906     return r
 1907 }
 1908 
 1909 func (r Network_Component) Mask(mask string) Network_Component {
 1910     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 1911         mask = fmt.Sprintf("mask[%s]", mask)
 1912     }
 1913 
 1914     r.Options.Mask = mask
 1915     return r
 1916 }
 1917 
 1918 func (r Network_Component) Filter(filter string) Network_Component {
 1919     r.Options.Filter = filter
 1920     return r
 1921 }
 1922 
 1923 func (r Network_Component) Limit(limit int) Network_Component {
 1924     r.Options.Limit = &limit
 1925     return r
 1926 }
 1927 
 1928 func (r Network_Component) Offset(offset int) Network_Component {
 1929     r.Options.Offset = &offset
 1930     return r
 1931 }
 1932 
 1933 // Add VLANs as trunks to a network component. The VLANs given must be assigned to your account, and on the router to which this network component is connected. The current native VLAN (networkVlanId/networkVlan) cannot be added as a trunk. This method should be called on a network component attached directly to customer assigned hardware, though all trunking operations will occur on the uplinkComponent. A current list of VLAN trunks for a network component on a customer server can be found at 'uplinkComponent->networkVlanTrunks'.
 1934 //
 1935 // This method returns an array of SoftLayer_Network_Vlans which were added as trunks. Any requested trunks which are already trunked will be silently ignored, and will not be returned.
 1936 //
 1937 // Configuration of network hardware is done asynchronously, do not depend on the return of this call as an indication that the newly trunked VLANs will be accessible.
 1938 func (r Network_Component) AddNetworkVlanTrunks(networkVlans []datatypes.Network_Vlan) (resp []datatypes.Network_Vlan, err error) {
 1939     params := []interface{}{
 1940         networkVlans,
 1941     }
 1942     err = r.Session.DoRequest("SoftLayer_Network_Component", "addNetworkVlanTrunks", params, &r.Options, &resp)
 1943     return
 1944 }
 1945 
 1946 // This method will remove all VLANs trunked to this network component. The native VLAN (networkVlanId/networkVlan) will remain active, and cannot be removed via the API. Returns a list of SoftLayer_Network_Vlan objects for which the trunks were removed.
 1947 func (r Network_Component) ClearNetworkVlanTrunks() (resp []datatypes.Network_Vlan, err error) {
 1948     err = r.Session.DoRequest("SoftLayer_Network_Component", "clearNetworkVlanTrunks", nil, &r.Options, &resp)
 1949     return
 1950 }
 1951 
 1952 // Retrieve Reboot/power (rebootDefault, rebootSoft, rebootHard, powerOn, powerOff and powerCycle) command currently executing by the server's remote management card.
 1953 func (r Network_Component) GetActiveCommand() (resp datatypes.Hardware_Component_RemoteManagement_Command_Request, err error) {
 1954     err = r.Session.DoRequest("SoftLayer_Network_Component", "getActiveCommand", nil, &r.Options, &resp)
 1955     return
 1956 }
 1957 
 1958 // Retrieve bandwidth graph by date.
 1959 func (r Network_Component) GetCustomBandwidthDataByDate(graphData *datatypes.Container_Graph) (resp datatypes.Container_Graph, err error) {
 1960     params := []interface{}{
 1961         graphData,
 1962     }
 1963     err = r.Session.DoRequest("SoftLayer_Network_Component", "getCustomBandwidthDataByDate", params, &r.Options, &resp)
 1964     return
 1965 }
 1966 
 1967 // Retrieve The network component linking this object to a child device
 1968 func (r Network_Component) GetDownlinkComponent() (resp datatypes.Network_Component, err error) {
 1969     err = r.Session.DoRequest("SoftLayer_Network_Component", "getDownlinkComponent", nil, &r.Options, &resp)
 1970     return
 1971 }
 1972 
 1973 // Retrieve The duplex mode of a network component.
 1974 func (r Network_Component) GetDuplexMode() (resp datatypes.Network_Component_Duplex_Mode, err error) {
 1975     err = r.Session.DoRequest("SoftLayer_Network_Component", "getDuplexMode", nil, &r.Options, &resp)
 1976     return
 1977 }
 1978 
 1979 // Retrieve The hardware that a network component resides in.
 1980 func (r Network_Component) GetHardware() (resp datatypes.Hardware, err error) {
 1981     err = r.Session.DoRequest("SoftLayer_Network_Component", "getHardware", nil, &r.Options, &resp)
 1982     return
 1983 }
 1984 
 1985 // Retrieve
 1986 func (r Network_Component) GetHighAvailabilityFirewallFlag() (resp bool, err error) {
 1987     err = r.Session.DoRequest("SoftLayer_Network_Component", "getHighAvailabilityFirewallFlag", nil, &r.Options, &resp)
 1988     return
 1989 }
 1990 
 1991 // Retrieve A hardware switch's interface to the bandwidth pod.
 1992 func (r Network_Component) GetInterface() (resp datatypes.Network_Bandwidth_Version1_Interface, err error) {
 1993     err = r.Session.DoRequest("SoftLayer_Network_Component", "getInterface", nil, &r.Options, &resp)
 1994     return
 1995 }
 1996 
 1997 // Retrieve The records of all IP addresses bound to a network component.
 1998 func (r Network_Component) GetIpAddressBindings() (resp []datatypes.Network_Component_IpAddress, err error) {
 1999     err = r.Session.DoRequest("SoftLayer_Network_Component", "getIpAddressBindings", nil, &r.Options, &resp)
 2000     return
 2001 }
 2002 
 2003 // Retrieve
 2004 func (r Network_Component) GetIpAddresses() (resp []datatypes.Network_Subnet_IpAddress, err error) {
 2005     err = r.Session.DoRequest("SoftLayer_Network_Component", "getIpAddresses", nil, &r.Options, &resp)
 2006     return
 2007 }
 2008 
 2009 // Retrieve Last reboot/power (rebootDefault, rebootSoft, rebootHard, powerOn, powerOff and powerCycle) command issued to the server's remote management card.
 2010 func (r Network_Component) GetLastCommand() (resp datatypes.Hardware_Component_RemoteManagement_Command_Request, err error) {
 2011     err = r.Session.DoRequest("SoftLayer_Network_Component", "getLastCommand", nil, &r.Options, &resp)
 2012     return
 2013 }
 2014 
 2015 // Retrieve The metric tracking object for this network component.
 2016 func (r Network_Component) GetMetricTrackingObject() (resp datatypes.Metric_Tracking_Object, err error) {
 2017     err = r.Session.DoRequest("SoftLayer_Network_Component", "getMetricTrackingObject", nil, &r.Options, &resp)
 2018     return
 2019 }
 2020 
 2021 // Retrieve The upstream network component firewall.
 2022 func (r Network_Component) GetNetworkComponentFirewall() (resp datatypes.Network_Component_Firewall, err error) {
 2023     err = r.Session.DoRequest("SoftLayer_Network_Component", "getNetworkComponentFirewall", nil, &r.Options, &resp)
 2024     return
 2025 }
 2026 
 2027 // Retrieve A network component's associated group.
 2028 func (r Network_Component) GetNetworkComponentGroup() (resp datatypes.Network_Component_Group, err error) {
 2029     err = r.Session.DoRequest("SoftLayer_Network_Component", "getNetworkComponentGroup", nil, &r.Options, &resp)
 2030     return
 2031 }
 2032 
 2033 // Retrieve All network devices in SoftLayer's network hierarchy that this device is connected to.
 2034 func (r Network_Component) GetNetworkHardware() (resp []datatypes.Hardware, err error) {
 2035     err = r.Session.DoRequest("SoftLayer_Network_Component", "getNetworkHardware", nil, &r.Options, &resp)
 2036     return
 2037 }
 2038 
 2039 // Retrieve The VLAN that a network component's subnet is associated with.
 2040 func (r Network_Component) GetNetworkVlan() (resp datatypes.Network_Vlan, err error) {
 2041     err = r.Session.DoRequest("SoftLayer_Network_Component", "getNetworkVlan", nil, &r.Options, &resp)
 2042     return
 2043 }
 2044 
 2045 // Retrieve The VLANs that are trunked to this network component.
 2046 func (r Network_Component) GetNetworkVlanTrunks() (resp []datatypes.Network_Component_Network_Vlan_Trunk, err error) {
 2047     err = r.Session.DoRequest("SoftLayer_Network_Component", "getNetworkVlanTrunks", nil, &r.Options, &resp)
 2048     return
 2049 }
 2050 
 2051 // no documentation yet
 2052 func (r Network_Component) GetObject() (resp datatypes.Network_Component, err error) {
 2053     err = r.Session.DoRequest("SoftLayer_Network_Component", "getObject", nil, &r.Options, &resp)
 2054     return
 2055 }
 2056 
 2057 //
 2058 // **DEPRECATED - This operation will cease to function after April 4th, 2016 and will be removed from v3.2**
 2059 // Retrieve various network statistics.  The network statistics are retrieved from the network device using snmpget. Below is a list of statistics retrieved:
 2060 // * Administrative Status
 2061 // * Operational Status
 2062 // * Maximum Transmission Unit
 2063 // * In Octets
 2064 // * Out Octets
 2065 // * In Unicast Packets
 2066 // * Out Unicast Packets
 2067 // * In Multicast Packets
 2068 // * Out Multicast Packets
 2069 func (r Network_Component) GetPortStatistics() (resp datatypes.Container_Network_Port_Statistic, err error) {
 2070     err = r.Session.DoRequest("SoftLayer_Network_Component", "getPortStatistics", nil, &r.Options, &resp)
 2071     return
 2072 }
 2073 
 2074 // Retrieve The primary IPv4 Address record for a network component.
 2075 func (r Network_Component) GetPrimaryIpAddressRecord() (resp datatypes.Network_Subnet_IpAddress, err error) {
 2076     err = r.Session.DoRequest("SoftLayer_Network_Component", "getPrimaryIpAddressRecord", nil, &r.Options, &resp)
 2077     return
 2078 }
 2079 
 2080 // Retrieve The subnet of the primary IP address assigned to this network component.
 2081 func (r Network_Component) GetPrimarySubnet() (resp datatypes.Network_Subnet, err error) {
 2082     err = r.Session.DoRequest("SoftLayer_Network_Component", "getPrimarySubnet", nil, &r.Options, &resp)
 2083     return
 2084 }
 2085 
 2086 // Retrieve The primary IPv6 Address record for a network component.
 2087 func (r Network_Component) GetPrimaryVersion6IpAddressRecord() (resp datatypes.Network_Subnet_IpAddress, err error) {
 2088     err = r.Session.DoRequest("SoftLayer_Network_Component", "getPrimaryVersion6IpAddressRecord", nil, &r.Options, &resp)
 2089     return
 2090 }
 2091 
 2092 // Retrieve The last five reboot/power (rebootDefault, rebootSoft, rebootHard, powerOn, powerOff and powerCycle) commands issued to the server's remote management card.
 2093 func (r Network_Component) GetRecentCommands() (resp []datatypes.Hardware_Component_RemoteManagement_Command_Request, err error) {
 2094     err = r.Session.DoRequest("SoftLayer_Network_Component", "getRecentCommands", nil, &r.Options, &resp)
 2095     return
 2096 }
 2097 
 2098 // Retrieve Indicates whether the network component is participating in a group of two or more components capable of being operationally redundant, if enabled.
 2099 func (r Network_Component) GetRedundancyCapableFlag() (resp bool, err error) {
 2100     err = r.Session.DoRequest("SoftLayer_Network_Component", "getRedundancyCapableFlag", nil, &r.Options, &resp)
 2101     return
 2102 }
 2103 
 2104 // Retrieve Indicates whether the network component is participating in a group of two or more components which is actively providing link redundancy.
 2105 func (r Network_Component) GetRedundancyEnabledFlag() (resp bool, err error) {
 2106     err = r.Session.DoRequest("SoftLayer_Network_Component", "getRedundancyEnabledFlag", nil, &r.Options, &resp)
 2107     return
 2108 }
 2109 
 2110 // Retrieve User(s) credentials to issue commands and/or interact with the server's remote management card.
 2111 func (r Network_Component) GetRemoteManagementUsers() (resp []datatypes.Hardware_Component_RemoteManagement_User, err error) {
 2112     err = r.Session.DoRequest("SoftLayer_Network_Component", "getRemoteManagementUsers", nil, &r.Options, &resp)
 2113     return
 2114 }
 2115 
 2116 // Retrieve A network component's routers.
 2117 func (r Network_Component) GetRouter() (resp datatypes.Hardware, err error) {
 2118     err = r.Session.DoRequest("SoftLayer_Network_Component", "getRouter", nil, &r.Options, &resp)
 2119     return
 2120 }
 2121 
 2122 // Retrieve Whether a network component's primary ip address is from a storage network subnet or not.
 2123 func (r Network_Component) GetStorageNetworkFlag() (resp bool, err error) {
 2124     err = r.Session.DoRequest("SoftLayer_Network_Component", "getStorageNetworkFlag", nil, &r.Options, &resp)
 2125     return
 2126 }
 2127 
 2128 // Retrieve A network component's subnets. A subnet is a group of IP addresses
 2129 func (r Network_Component) GetSubnets() (resp []datatypes.Network_Subnet, err error) {
 2130     err = r.Session.DoRequest("SoftLayer_Network_Component", "getSubnets", nil, &r.Options, &resp)
 2131     return
 2132 }
 2133 
 2134 // Retrieve The network component linking this object to parent
 2135 func (r Network_Component) GetUplinkComponent() (resp datatypes.Network_Component, err error) {
 2136     err = r.Session.DoRequest("SoftLayer_Network_Component", "getUplinkComponent", nil, &r.Options, &resp)
 2137     return
 2138 }
 2139 
 2140 // Retrieve The duplex mode of the uplink network component linking to this object
 2141 func (r Network_Component) GetUplinkDuplexMode() (resp datatypes.Network_Component_Duplex_Mode, err error) {
 2142     err = r.Session.DoRequest("SoftLayer_Network_Component", "getUplinkDuplexMode", nil, &r.Options, &resp)
 2143     return
 2144 }
 2145 
 2146 // Remove one or more VLANs currently attached to the uplinkComponent of this networkComponent. The VLANs given must be assigned to your account, and on the router the network component is connected to. If any VLANs not currently trunked are given, they will be silently ignored.
 2147 //
 2148 // This method should be called on a network component attached directly to customer assigned hardware, though all trunking operations will occur on the uplinkComponent. A current list of VLAN trunks for a network component on a customer server can be found at 'uplinkComponent->networkVlanTrunks'.
 2149 //
 2150 // Configuration of network hardware is done asynchronously, do not depend on the return of this call as an indication that the removed VLANs will be inaccessible.
 2151 func (r Network_Component) RemoveNetworkVlanTrunks(networkVlans []datatypes.Network_Vlan) (resp []datatypes.Network_Vlan, err error) {
 2152     params := []interface{}{
 2153         networkVlans,
 2154     }
 2155     err = r.Session.DoRequest("SoftLayer_Network_Component", "removeNetworkVlanTrunks", params, &r.Options, &resp)
 2156     return
 2157 }
 2158 
 2159 // The SoftLayer_Network_Component_Firewall data type contains general information relating to a single SoftLayer network component firewall. This is the object which ties the running rules to a specific downstream server. Use the [[SoftLayer Network Firewall Template]] service to pull SoftLayer recommended rule set templates. Use the [[SoftLayer Network Firewall Update Request]] service to submit a firewall update request.
 2160 type Network_Component_Firewall struct {
 2161     Session *session.Session
 2162     Options sl.Options
 2163 }
 2164 
 2165 // GetNetworkComponentFirewallService returns an instance of the Network_Component_Firewall SoftLayer service
 2166 func GetNetworkComponentFirewallService(sess *session.Session) Network_Component_Firewall {
 2167     return Network_Component_Firewall{Session: sess}
 2168 }
 2169 
 2170 func (r Network_Component_Firewall) Id(id int) Network_Component_Firewall {
 2171     r.Options.Id = &id
 2172     return r
 2173 }
 2174 
 2175 func (r Network_Component_Firewall) Mask(mask string) Network_Component_Firewall {
 2176     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 2177         mask = fmt.Sprintf("mask[%s]", mask)
 2178     }
 2179 
 2180     r.Options.Mask = mask
 2181     return r
 2182 }
 2183 
 2184 func (r Network_Component_Firewall) Filter(filter string) Network_Component_Firewall {
 2185     r.Options.Filter = filter
 2186     return r
 2187 }
 2188 
 2189 func (r Network_Component_Firewall) Limit(limit int) Network_Component_Firewall {
 2190     r.Options.Limit = &limit
 2191     return r
 2192 }
 2193 
 2194 func (r Network_Component_Firewall) Offset(offset int) Network_Component_Firewall {
 2195     r.Options.Offset = &offset
 2196     return r
 2197 }
 2198 
 2199 // Retrieve The additional subnets linked to this network component firewall, that inherit rules from the host that the context slot is attached to.
 2200 func (r Network_Component_Firewall) GetApplyServerRuleSubnets() (resp []datatypes.Network_Subnet, err error) {
 2201     err = r.Session.DoRequest("SoftLayer_Network_Component_Firewall", "getApplyServerRuleSubnets", nil, &r.Options, &resp)
 2202     return
 2203 }
 2204 
 2205 // Retrieve The billing item for a Hardware Firewall (Dedicated).
 2206 func (r Network_Component_Firewall) GetBillingItem() (resp datatypes.Billing_Item, err error) {
 2207     err = r.Session.DoRequest("SoftLayer_Network_Component_Firewall", "getBillingItem", nil, &r.Options, &resp)
 2208     return
 2209 }
 2210 
 2211 // Retrieve The network component of the guest virtual server that this network component firewall belongs to.
 2212 func (r Network_Component_Firewall) GetGuestNetworkComponent() (resp datatypes.Virtual_Guest_Network_Component, err error) {
 2213     err = r.Session.DoRequest("SoftLayer_Network_Component_Firewall", "getGuestNetworkComponent", nil, &r.Options, &resp)
 2214     return
 2215 }
 2216 
 2217 // Retrieve The network component of the switch interface that this network component firewall belongs to.
 2218 func (r Network_Component_Firewall) GetNetworkComponent() (resp datatypes.Network_Component, err error) {
 2219     err = r.Session.DoRequest("SoftLayer_Network_Component_Firewall", "getNetworkComponent", nil, &r.Options, &resp)
 2220     return
 2221 }
 2222 
 2223 // Retrieve The update requests made for this firewall.
 2224 func (r Network_Component_Firewall) GetNetworkFirewallUpdateRequest() (resp []datatypes.Network_Firewall_Update_Request, err error) {
 2225     err = r.Session.DoRequest("SoftLayer_Network_Component_Firewall", "getNetworkFirewallUpdateRequest", nil, &r.Options, &resp)
 2226     return
 2227 }
 2228 
 2229 // getObject returns a SoftLayer_Network_Firewall_Module_Context_Interface_AccessControlList_Network_Component object. You can only get objects for servers attached to your account that have a network firewall enabled.
 2230 func (r Network_Component_Firewall) GetObject() (resp datatypes.Network_Component_Firewall, err error) {
 2231     err = r.Session.DoRequest("SoftLayer_Network_Component_Firewall", "getObject", nil, &r.Options, &resp)
 2232     return
 2233 }
 2234 
 2235 // Retrieve The currently running rule set of this network component firewall.
 2236 func (r Network_Component_Firewall) GetRules() (resp []datatypes.Network_Component_Firewall_Rule, err error) {
 2237     err = r.Session.DoRequest("SoftLayer_Network_Component_Firewall", "getRules", nil, &r.Options, &resp)
 2238     return
 2239 }
 2240 
 2241 // Retrieve The additional subnets linked to this network component firewall.
 2242 func (r Network_Component_Firewall) GetSubnets() (resp []datatypes.Network_Subnet, err error) {
 2243     err = r.Session.DoRequest("SoftLayer_Network_Component_Firewall", "getSubnets", nil, &r.Options, &resp)
 2244     return
 2245 }
 2246 
 2247 // The SoftLayer_Network_ContentDelivery_Account data type models an individual CDN account. CDN accounts contain references to the SoftLayer customer account they belong to, login credentials for upload services, and a CDN account's status. Please contact SoftLayer sales to purchase or cancel a CDN account
 2248 type Network_ContentDelivery_Account struct {
 2249     Session *session.Session
 2250     Options sl.Options
 2251 }
 2252 
 2253 // GetNetworkContentDeliveryAccountService returns an instance of the Network_ContentDelivery_Account SoftLayer service
 2254 func GetNetworkContentDeliveryAccountService(sess *session.Session) Network_ContentDelivery_Account {
 2255     return Network_ContentDelivery_Account{Session: sess}
 2256 }
 2257 
 2258 func (r Network_ContentDelivery_Account) Id(id int) Network_ContentDelivery_Account {
 2259     r.Options.Id = &id
 2260     return r
 2261 }
 2262 
 2263 func (r Network_ContentDelivery_Account) Mask(mask string) Network_ContentDelivery_Account {
 2264     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 2265         mask = fmt.Sprintf("mask[%s]", mask)
 2266     }
 2267 
 2268     r.Options.Mask = mask
 2269     return r
 2270 }
 2271 
 2272 func (r Network_ContentDelivery_Account) Filter(filter string) Network_ContentDelivery_Account {
 2273     r.Options.Filter = filter
 2274     return r
 2275 }
 2276 
 2277 func (r Network_ContentDelivery_Account) Limit(limit int) Network_ContentDelivery_Account {
 2278     r.Options.Limit = &limit
 2279     return r
 2280 }
 2281 
 2282 func (r Network_ContentDelivery_Account) Offset(offset int) Network_ContentDelivery_Account {
 2283     r.Options.Offset = &offset
 2284     return r
 2285 }
 2286 
 2287 // Internap servers attempts to validate a token before serving a protected content. SoftLayer customer does not need to invoke this method.  Please refer to [[SoftLayer_Network_ContentDelivery_Authentication_Token|Authentication Token]] object for more details on Content Authentication Service.
 2288 func (r Network_ContentDelivery_Account) AuthenticateResourceRequest(parameter *datatypes.Container_Network_ContentDelivery_Authentication_Parameter) (resp bool, err error) {
 2289     params := []interface{}{
 2290         parameter,
 2291     }
 2292     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "authenticateResourceRequest", params, &r.Options, &resp)
 2293     return
 2294 }
 2295 
 2296 // You can further organize your contents on the CDN FTP server by creating sub directories.  This method creates a directory on the CDN FTP server. A user must have CDN_FILE_MANAGE privilege to use this method. A directory name must be an absolute path and you can only create sub directories in /media folder.
 2297 func (r Network_ContentDelivery_Account) CreateDirectory(directoryName *string) (resp bool, err error) {
 2298     params := []interface{}{
 2299         directoryName,
 2300     }
 2301     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "createDirectory", params, &r.Options, &resp)
 2302     return
 2303 }
 2304 
 2305 // This method allows you to create a default CDN FTP user record on the ftp.cdnlayer.service.softlayer.com server. As with a CDN FTP user account, you can upload contents to the CDN host server through the SoftLayer private network.  SoftLayer currently allows only one FTP user for each CDN account. Your default CDN FTP user record is created upon successful creation of a CDN account.  You may not need to use this method at all. This is provided in support of the previous CDN customers. SoftLayer may offer multiple CDN FTP users for a single CDN account in the future.
 2306 //
 2307 // Optionally, you can provide a new password when invoking this method and a new password must follow the rules below:
 2308 // * ...must be between 8 and 20 characters long
 2309 // * ...must be an alphanumeric value
 2310 // * ...can contain these characters: - _ ! % # $ ^ & *
 2311 func (r Network_ContentDelivery_Account) CreateFtpUser(newPassword *string) (resp bool, err error) {
 2312     params := []interface{}{
 2313         newPassword,
 2314     }
 2315     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "createFtpUser", params, &r.Options, &resp)
 2316     return
 2317 }
 2318 
 2319 // With Origin Pull, content is pulled from your origin server as needed and then delivered to visitors. You do not need to upload your files to the CDN FTP: you can utilize the files that currently exist on your origin server. It will take 10 to 15 minutes for this to take effect after you create an Origin Pull rule. Origin Pull is only supported for HTTP protocol and you would continue to use the CDN FTP for Flash and Windows Media streaming services.
 2320 //
 2321 // A valid origin host can include a directory information.  You may include an authentication username and password along with an origin host. If you set an authentication username and password, CDN servers will include "Authorization:" header in every request. You may use the "Authorization:" header to grant access to CDN servers or you may use it to distinguish CDN servers from normal visitors. Here is a list of valid origin hosts:
 2322 // * www.website.com
 2323 // * www.website.com/cdn_content
 2324 // * cdn_user:password@www.website.com
 2325 // * cdn_user:password@www.website.com/images
 2326 //
 2327 //
 2328 // An authentication username should be an alphanumeric string and allowed special characters are . - _<br /> An authentication password should be an alphanumeric string and allowed special characters are . - _ ! # $ % ^ & *<br /> Both username and password must be between 3 to 10 characters long.
 2329 //
 2330 // CDN nodes will cache your contents and you can control cache lifetime by modifying your web server's configuration. This method also creates a FTP directory restriction upon successful Origin Pull set up. You will not be able to access /media/http directory since contents will be pulled from your origin server. An origin domain must be a valid domain name and it can contain path information. This can help you organize contents on your origin server. For example, you could set an origin domain as: mydomain.com/cdn_contents
 2331 //
 2332 // A CNAME record allows you to have a customized URL. You can get rid of your CDN account name from the URL. A valid CNAME for the Origin Pull method must point to <CDN_AcccountName>.http.cdn.softlayer.net.
 2333 //
 2334 // There are 2 types of origin pull mappings.  The one with a CNAME record or the one without a CNAME record and they work very differently.
 2335 //
 2336 // gzip is supported if your web server sends a proper gzip header. For more details, visit our [http://knowledgelayer.softlayer.com/topic/cdn KnowledgeLayer]
 2337 func (r Network_ContentDelivery_Account) CreateOriginPullMapping(mappingObject *datatypes.Container_Network_ContentDelivery_OriginPull_Mapping) (resp bool, err error) {
 2338     params := []interface{}{
 2339         mappingObject,
 2340     }
 2341     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "createOriginPullMapping", params, &r.Options, &resp)
 2342     return
 2343 }
 2344 
 2345 // This method is deprecated, please use [[[[SoftLayer_Network_ContentDelivery_Account::createOriginPullMapping|createOriginPullMapping]] method instead.
 2346 func (r Network_ContentDelivery_Account) CreateOriginPullRule(originDomain *string, cnameRecord *string) (resp bool, err error) {
 2347     params := []interface{}{
 2348         originDomain,
 2349         cnameRecord,
 2350     }
 2351     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "createOriginPullRule", params, &r.Options, &resp)
 2352     return
 2353 }
 2354 
 2355 // You need to specify a directory on your CDN FTP or on your origin host in which your secure content resides to enable the token authentication . It will take about about 30 minutes for a newly configured token authentication directory to take effect.
 2356 func (r Network_ContentDelivery_Account) CreateTokenAuthenticationDirectory(directory *string, mediaType *string) (resp bool, err error) {
 2357     params := []interface{}{
 2358         directory,
 2359         mediaType,
 2360     }
 2361     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "createTokenAuthenticationDirectory", params, &r.Options, &resp)
 2362     return
 2363 }
 2364 
 2365 // This method deletes your FTP user record on the ftp.cdnlayer.service.softlayer.com server. Refer to the service overview of [[SoftLayer_Network_ContentDelivery_Account::createFtpUser|createFtpUser]] method for more information on the CDN FTP server.
 2366 func (r Network_ContentDelivery_Account) DeleteFtpUser() (resp bool, err error) {
 2367     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "deleteFtpUser", nil, &r.Options, &resp)
 2368     return
 2369 }
 2370 
 2371 // This method removes an Origin Pull domain rule.  Once an Origin Pull rule is removed, you will be able to access the /media/http directory. It will take 10 to 15 minutes for this to take effect after you remove your Origin Pull rule.  Cached contents on CDN POPs may live longer than 15 minutes.
 2372 func (r Network_ContentDelivery_Account) DeleteOriginPullRule(originMappingId *string) (resp bool, err error) {
 2373     params := []interface{}{
 2374         originMappingId,
 2375     }
 2376     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "deleteOriginPullRule", params, &r.Options, &resp)
 2377     return
 2378 }
 2379 
 2380 // This method disables CDN access log.
 2381 func (r Network_ContentDelivery_Account) DisableLogging() (resp bool, err error) {
 2382     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "disableLogging", nil, &r.Options, &resp)
 2383     return
 2384 }
 2385 
 2386 // This method enables CDN access log.
 2387 func (r Network_ContentDelivery_Account) EnableLogging() (resp bool, err error) {
 2388     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "enableLogging", nil, &r.Options, &resp)
 2389     return
 2390 }
 2391 
 2392 // Retrieve The customer account that a CDN account belongs to.
 2393 func (r Network_ContentDelivery_Account) GetAccount() (resp datatypes.Account, err error) {
 2394     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getAccount", nil, &r.Options, &resp)
 2395     return
 2396 }
 2397 
 2398 // This method returns bandwidth data for each POP. [[SoftLayer_Container_Network_ContentDelivery_Bandwidth_PointsOfPresence_Summary|POP Bandwidth]] object contains a starting time, ending time, total bytes, POP name and bandwidth unit.
 2399 //
 2400 // POP bandwidth data is updated everyday at 22:50 CST (or CDT). It queries and stores POP data from the day before. It is a more resource intensive process than a regular CDN bandwidth update thus we run this once a day. Since the POP bandwidth data is delayed for a day, there is no correction process for POP data. The POP bandwidth is not associated with any billing process and is mainly used to generate a POP bandwidth graph.
 2401 func (r Network_ContentDelivery_Account) GetAllPopsBandwidthData(beginDateTime *datatypes.Time, endDateTime *datatypes.Time) (resp []datatypes.Container_Network_ContentDelivery_Bandwidth_PointsOfPresence_Summary, err error) {
 2402     params := []interface{}{
 2403         beginDateTime,
 2404         endDateTime,
 2405     }
 2406     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getAllPopsBandwidthData", params, &r.Options, &resp)
 2407     return
 2408 }
 2409 
 2410 // This method returns a bandwidth graph for every POP wrapped in [[SoftLayer_Container_Bandwidth_GraphOutputsExtended|Bandwidth Graph]] object. A POP bandwidth graph shows bandwidth consumption per each POP in a bar graph. [[SoftLayer_Container_Bandwidth_GraphOutputsExtended|Bandwidth Graph]] object contains a begin time, end time, title of the graph, binary date, in and outbound total bandwidth in bytes
 2411 func (r Network_ContentDelivery_Account) GetAllPopsBandwidthImage(title *string, beginDateTime *datatypes.Time, endDateTime *datatypes.Time, unit *string) (resp datatypes.Container_Bandwidth_GraphOutputsExtended, err error) {
 2412     params := []interface{}{
 2413         title,
 2414         beginDateTime,
 2415         endDateTime,
 2416         unit,
 2417     }
 2418     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getAllPopsBandwidthImage", params, &r.Options, &resp)
 2419     return
 2420 }
 2421 
 2422 // Retrieve The CDN account id that this CDN account is associated with.
 2423 func (r Network_ContentDelivery_Account) GetAssociatedCdnAccountId() (resp string, err error) {
 2424     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getAssociatedCdnAccountId", nil, &r.Options, &resp)
 2425     return
 2426 }
 2427 
 2428 // Retrieve The IP addresses that are used for the content authentication service.
 2429 func (r Network_ContentDelivery_Account) GetAuthenticationIpAddresses() (resp []datatypes.Network_ContentDelivery_Authentication_Address, err error) {
 2430     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getAuthenticationIpAddresses", nil, &r.Options, &resp)
 2431     return
 2432 }
 2433 
 2434 // CDN servers will invoke a Web Service method to validate a content authentication token. This method returns all token validation web service endpoints set for a CDN account. You can override the default web service by calling [[SoftLayer_Network_ContentDelivery_Authentication_Token|setContentAuthenticationWsdl setContentAuthenticationWsdl]] method.
 2435 func (r Network_ContentDelivery_Account) GetAuthenticationServiceEndpoints() (resp []datatypes.Container_Network_ContentDelivery_Authentication_ServiceEndpoint, err error) {
 2436     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getAuthenticationServiceEndpoints", nil, &r.Options, &resp)
 2437     return
 2438 }
 2439 
 2440 // This method returns bandwidth data for a given time range.  It returns an array of [[SoftLayer_Container_Network_ContentDelivery_Bandwidth_Summary|bandwidth summary]] objects. [[SoftLayer_Container_Network_ContentDelivery_Bandwidth_Summary|Bandwidth summary]] object contains a beginning time, ending time, and bandwidth in bytes.
 2441 //
 2442 // A Beginning and ending date parameters have to be a timestamp in "yyyy-mm-dd HH24:mi:ss" format and it assumes the time is in Central Standard Time (CST) or Central Daylight Time (CDT) time zone. CDN bandwidth data is stored in Greenwich Mean Time (GMT) internally and converts a beginning and ending time to GMT before querying.
 2443 //
 2444 // Unlike server bandwidth, CDN bandwidth returns total bytes consumed within an hour. For example, if you pass "2008-10-10 00:00:00" for a beginning time and "2008-10-10 05:00:00" for an ending time, your return value will have 6 elements of bandwidth summary objects. The first bandwidth summary object will have the total bytes consumed between 2008-10-10 00:00:00 and 2008-10-10 05:00:00. And the last object will have the bandwidth consumed between 2008-10-10 05:00:00 and 2008-10-10 00:59:59. The bandwidth data is updated at 10 minutes after every hour.  The queried data is on a two hour time delay. The two hour delay is required to gather bandwidth data from each POP and that is the minimum delay required to create a feasible graph. It usually takes about 8 hours to reconcile all the data from every CDN POP. This hourly data is corrected after 24 hours if necessary.  If you consume a large amount of bandwidth, your bandwidth data will be updated the next day.
 2445 func (r Network_ContentDelivery_Account) GetBandwidthData(beginDateTime *datatypes.Time, endDateTime *datatypes.Time) (resp []datatypes.Container_Network_ContentDelivery_Bandwidth_Summary, err error) {
 2446     params := []interface{}{
 2447         beginDateTime,
 2448         endDateTime,
 2449     }
 2450     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getBandwidthData", params, &r.Options, &resp)
 2451     return
 2452 }
 2453 
 2454 // This method returns bandwidth data for a given time range.  It returns an array of [[SoftLayer_Container_Network_ContentDelivery_Report_Usage|bandwidth usage report]] objects.
 2455 //
 2456 // These will be first sorted by timestamp, and there will be one entry with that timestamp for each enabled region. The region type 'NONE' is provided only when non-region-specific data is returned. [[SoftLayer_Container_Network_ContentDelivery_Report_Usage|bandwidth usage report]] objects with a region will never contain non-region-specific data. Non-region-specific values are standardTotal and sslTotal; standardTotal is computed by adding the HTTP Large, Windows Media, Flash and Application Delivery Network bandwidth. The sslTotal is computed by adding the HTTP Large SSL bandwidth and the Application Delivery Network SSL bandwidth.
 2457 //
 2458 // A Beginning and ending date parameters have to be a timestamp in "yyyy-mm-dd HH24:mi:ss" format and it assumes the time is in Central Standard Time (CST) or Central Daylight Time (CDT) time zone. CDN bandwidth data is stored in Greenwich Mean Time (GMT) internally and converts a beginning and ending time to GMT before querying.
 2459 //
 2460 // Unlike server bandwidth, CDN bandwidth returns total bytes consumed within an hour. For example, if you pass "2008-10-10 00:00:00" for a beginning time and "2008-10-10 05:00:00" for an ending time, your return value will have 6 elements of bandwidth summary objects. The first bandwidth summary object will have the total bytes consumed between 2008-10-10 00:00:00 and 2008-10-10 05:00:00. And the last object will have the bandwidth consumed between 2008-10-10 05:00:00 and 2008-10-10 00:59:59. The bandwidth data is updated at 10 minutes after every hour.  The queried data is on a two hour time delay. The two hour delay is required to gather bandwidth data from each POP and that is the minimum delay required to create a feasible graph. It usually takes about 8 hours to reconcile all the data from every CDN POP. This hourly data is corrected after 24 hours if necessary.  If you consume a large amount of bandwidth, your bandwidth data will be updated the next day.
 2461 func (r Network_ContentDelivery_Account) GetBandwidthDataWithTypes(beginDateTime *datatypes.Time, endDateTime *datatypes.Time, period *string) (resp []datatypes.Container_Network_ContentDelivery_Report_Usage, err error) {
 2462     params := []interface{}{
 2463         beginDateTime,
 2464         endDateTime,
 2465         period,
 2466     }
 2467     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getBandwidthDataWithTypes", params, &r.Options, &resp)
 2468     return
 2469 }
 2470 
 2471 // This method returns a bandwidth graph wrapped in [[SoftLayer_Container_Bandwidth_GraphOutputsExtended|Bandwidth Graph]] object. [[SoftLayer_Container_Bandwidth_GraphOutputsExtended|Bandwidth Graph]] object contains a starting time, ending time, graph title, graph binary data, and in and outbound total bytes.
 2472 func (r Network_ContentDelivery_Account) GetBandwidthImage(title *string, beginDateTime *datatypes.Time, endDateTime *datatypes.Time) (resp datatypes.Container_Bandwidth_GraphOutputsExtended, err error) {
 2473     params := []interface{}{
 2474         title,
 2475         beginDateTime,
 2476         endDateTime,
 2477     }
 2478     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getBandwidthImage", params, &r.Options, &resp)
 2479     return
 2480 }
 2481 
 2482 // Retrieve The current billing item for a CDN account.
 2483 func (r Network_ContentDelivery_Account) GetBillingItem() (resp datatypes.Billing_Item, err error) {
 2484     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getBillingItem", nil, &r.Options, &resp)
 2485     return
 2486 }
 2487 
 2488 // Retrieve The name of a CDN account.
 2489 func (r Network_ContentDelivery_Account) GetCdnAccountName() (resp string, err error) {
 2490     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getCdnAccountName", nil, &r.Options, &resp)
 2491     return
 2492 }
 2493 
 2494 // Retrieve A brief note on a CDN account.
 2495 func (r Network_ContentDelivery_Account) GetCdnAccountNote() (resp string, err error) {
 2496     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getCdnAccountNote", nil, &r.Options, &resp)
 2497     return
 2498 }
 2499 
 2500 // Retrieve The solution type of a CDN account.
 2501 func (r Network_ContentDelivery_Account) GetCdnSolutionName() (resp string, err error) {
 2502     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getCdnSolutionName", nil, &r.Options, &resp)
 2503     return
 2504 }
 2505 
 2506 // An origin pull mapping is a combination of your customer origin record and a CNAME (optional) record. You can now keep track of your customer origin records separate from your CNAME records. This service returns your customer origin records.
 2507 func (r Network_ContentDelivery_Account) GetCustomerOrigins(mediaType *string) (resp []datatypes.Container_Network_ContentDelivery_OriginPull_Mapping, err error) {
 2508     params := []interface{}{
 2509         mediaType,
 2510     }
 2511     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getCustomerOrigins", params, &r.Options, &resp)
 2512     return
 2513 }
 2514 
 2515 // Retrieve Indicates if CDN account is dependent on other service. If set, this CDN account is limited to these services: createOriginPullMapping, deleteOriginPullRule, getOriginPullMappingInformation, getCdnUrls, purgeCache, loadContent, manageHttpCompression
 2516 func (r Network_ContentDelivery_Account) GetDependantServiceFlag() (resp bool, err error) {
 2517     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getDependantServiceFlag", nil, &r.Options, &resp)
 2518     return
 2519 }
 2520 
 2521 // This method returns an array of [[SoftLayer_Container_Network_Directory_Listing|Directory Listing]] objects. You must have CDN_FILE_MANAGE privilege and you can only retrieve directory information within <b>/media</b> directory. A [[SoftLayer_Container_Network_Directory_Listing|Directory Listing]] object contains type (indicating whether it is a file or a directory), name and file count if it is a directory.
 2522 func (r Network_ContentDelivery_Account) GetDirectoryInformation(directoryName *string) (resp []datatypes.Container_Network_Directory_Listing, err error) {
 2523     params := []interface{}{
 2524         directoryName,
 2525     }
 2526     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getDirectoryInformation", params, &r.Options, &resp)
 2527     return
 2528 }
 2529 
 2530 // This method returns disk space usage data for your CDN FTP.
 2531 func (r Network_ContentDelivery_Account) GetDiskSpaceUsageDataByDate(beginDateTime *datatypes.Time, endDateTime *datatypes.Time) (resp []datatypes.Metric_Tracking_Object_Data, err error) {
 2532     params := []interface{}{
 2533         beginDateTime,
 2534         endDateTime,
 2535     }
 2536     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getDiskSpaceUsageDataByDate", params, &r.Options, &resp)
 2537     return
 2538 }
 2539 
 2540 // This method returns a disk usage graph wrapped in [[SoftLayer_Container_Bandwidth_GraphOutputsExtended|Bandwidth Graph]] object. [[SoftLayer_Container_Bandwidth_GraphOutputsExtended|Bandwidth Graph]] object contains a starting time, ending time, graph title, graph binary data, and in and outbound total bytes.
 2541 func (r Network_ContentDelivery_Account) GetDiskSpaceUsageImageByDate(beginDateTime *datatypes.Time, endDateTime *datatypes.Time) (resp datatypes.Container_Bandwidth_GraphOutputs, err error) {
 2542     params := []interface{}{
 2543         beginDateTime,
 2544         endDateTime,
 2545     }
 2546     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getDiskSpaceUsageImageByDate", params, &r.Options, &resp)
 2547     return
 2548 }
 2549 
 2550 // This method returns your login credentials to the CDN FTP server (ftp.cdnlayer.service.softlayer.com server). You must have CDN_FILE_MANAGE privilege. Refer to the service overview of [[SoftLayer_Network_ContentDelivery_Account::createFtpUser|createFtpUser]] method for more information on the CDN FTP server.
 2551 //
 2552 // If you want to download raw log files, prefix the username with "LOGS-" (without quotes) when logging in. SoftLayer designed CDN accounts so they can have multiple CDN FTP users. However, this method returns the default CDN FTP user information: multi user support may be implemented in the future.
 2553 func (r Network_ContentDelivery_Account) GetFtpAttributes() (resp datatypes.Container_Network_Authentication_Data, err error) {
 2554     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getFtpAttributes", nil, &r.Options, &resp)
 2555     return
 2556 }
 2557 
 2558 // Retrieve Indicates if it is a legacy CDN or not
 2559 func (r Network_ContentDelivery_Account) GetLegacyCdnFlag() (resp bool, err error) {
 2560     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getLegacyCdnFlag", nil, &r.Options, &resp)
 2561     return
 2562 }
 2563 
 2564 // Retrieve Indicates if CDN logging is enabled.
 2565 func (r Network_ContentDelivery_Account) GetLogEnabledFlag() (resp string, err error) {
 2566     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getLogEnabledFlag", nil, &r.Options, &resp)
 2567     return
 2568 }
 2569 
 2570 // This method returns CDN URLs for static file (http), Flash streaming (rtmp) and Window Media (mms) streaming services. You can generate your CDN URLs based on the information retrieved by this method.
 2571 func (r Network_ContentDelivery_Account) GetMediaUrls() (resp []datatypes.Container_Network_ContentDelivery_SupportedProtocol, err error) {
 2572     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getMediaUrls", nil, &r.Options, &resp)
 2573     return
 2574 }
 2575 
 2576 // getObject retrieves the SoftLayer_Network_ContentDelivery_Account object whose ID number corresponds to the ID number of the initial parameter passed to the SoftLayer_Network_ContentDelivery_Account service. You can only retrieve CDN accounts assigned to your SoftLayer customer account.
 2577 func (r Network_ContentDelivery_Account) GetObject() (resp datatypes.Network_ContentDelivery_Account, err error) {
 2578     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getObject", nil, &r.Options, &resp)
 2579     return
 2580 }
 2581 
 2582 // This method returns a list of origin pull configuration data.
 2583 func (r Network_ContentDelivery_Account) GetOriginPullMappingInformation() (resp []datatypes.Container_Network_ContentDelivery_OriginPull_Mapping, err error) {
 2584     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getOriginPullMappingInformation", nil, &r.Options, &resp)
 2585     return
 2586 }
 2587 
 2588 // This method returns CDN URLs that supports Origin Pull mappings.
 2589 func (r Network_ContentDelivery_Account) GetOriginPullSupportedMediaUrls() (resp []datatypes.Container_Network_ContentDelivery_SupportedProtocol, err error) {
 2590     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getOriginPullSupportedMediaUrls", nil, &r.Options, &resp)
 2591     return
 2592 }
 2593 
 2594 // This method returns the domain name of your Origin Pull rule.  It assumes you have already setup an Origin Pull rule.  Otherwise, it will throw an exception. A returning value is the value of the first parameter (origin pull domain) you provided to [[SoftLayer_Network_ContentDelivery_Account::createOriginPullRule|createOriginPullRule]] method. See Error Handling section below for possible errors.
 2595 func (r Network_ContentDelivery_Account) GetOriginPullUrl() (resp string, err error) {
 2596     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getOriginPullUrl", nil, &r.Options, &resp)
 2597     return
 2598 }
 2599 
 2600 // This method returns an array of CDN POPs (Points of Presence) object. [[SoftLayer_Container_Network_ContentDelivery_PointsOfPresence|POP object]] object contains the POP id and name.
 2601 func (r Network_ContentDelivery_Account) GetPopNames() (resp []datatypes.Container_Network_ContentDelivery_PointsOfPresence, err error) {
 2602     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getPopNames", nil, &r.Options, &resp)
 2603     return
 2604 }
 2605 
 2606 // Retrieve Indicates if customer is allowed to access the CDN provider's management portal.
 2607 func (r Network_ContentDelivery_Account) GetProviderPortalAccessFlag() (resp bool, err error) {
 2608     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getProviderPortalAccessFlag", nil, &r.Options, &resp)
 2609     return
 2610 }
 2611 
 2612 // This method returns your login credentials to the CDN provider portal.
 2613 func (r Network_ContentDelivery_Account) GetProviderPortalCredentials() (resp datatypes.Container_Network_Authentication_Data, err error) {
 2614     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getProviderPortalCredentials", nil, &r.Options, &resp)
 2615     return
 2616 }
 2617 
 2618 // Retrieve A CDN account's status presented in a more detailed data type.
 2619 func (r Network_ContentDelivery_Account) GetStatus() (resp datatypes.Network_ContentDelivery_Account_Status, err error) {
 2620     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getStatus", nil, &r.Options, &resp)
 2621     return
 2622 }
 2623 
 2624 // This method returns all token authentication directories.
 2625 func (r Network_ContentDelivery_Account) GetTokenAuthenticationDirectories() (resp []datatypes.Container_Network_Directory_Listing, err error) {
 2626     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getTokenAuthenticationDirectories", nil, &r.Options, &resp)
 2627     return
 2628 }
 2629 
 2630 // Retrieve Indicates if the token authentication service is enabled or not.
 2631 func (r Network_ContentDelivery_Account) GetTokenAuthenticationEnabledFlag() (resp bool, err error) {
 2632     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getTokenAuthenticationEnabledFlag", nil, &r.Options, &resp)
 2633     return
 2634 }
 2635 
 2636 // This method returns your login credentials to the public CDN FTP.
 2637 func (r Network_ContentDelivery_Account) GetVendorFtpAttributes() (resp datatypes.Container_Network_Authentication_Data, err error) {
 2638     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "getVendorFtpAttributes", nil, &r.Options, &resp)
 2639     return
 2640 }
 2641 
 2642 // Whether you are using Origin Pull or POP Pull, your content will be transferred and cached on CDN POP (node) on the initial request. If you wish to load your content to all CDN POPs, you may use this service to accomplish that. Please keep in mind, it will take about 10 to 15 minutes to load content to all CDN POPs depending on the load.
 2643 //
 2644 // You can only specify 5 URLs at a time.
 2645 func (r Network_ContentDelivery_Account) LoadContent(objectUrls []string) (resp bool, err error) {
 2646     params := []interface{}{
 2647         objectUrls,
 2648     }
 2649     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "loadContent", params, &r.Options, &resp)
 2650     return
 2651 }
 2652 
 2653 // HTTP Compression is used to reduce the bandwidth used to deliver an object. You can specify list of content types that needs to be compressed. If you omit the content type parameter, these values will be used by default:
 2654 // * text/plain
 2655 // * text/html
 2656 // * text/css
 2657 // * application/x-javascript
 2658 // * text/javascript
 2659 //
 2660 //
 2661 // Note that files larger than 1MB will never be served with compression regardless of whether their content-type is enabled for compression.
 2662 func (r Network_ContentDelivery_Account) ManageHttpCompression(enableFlag *bool, mimeTypes []string) (resp bool, err error) {
 2663     params := []interface{}{
 2664         enableFlag,
 2665         mimeTypes,
 2666     }
 2667     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "manageHttpCompression", params, &r.Options, &resp)
 2668     return
 2669 }
 2670 
 2671 // CDN's cache mechanism works similar to that of web browsers. When CDN pulls a file from your origin server or from your CDN FTP directory for the first time, it creates a cache file on itself. CDN re-uses cache files to save trips to the origin server and thus it speeds up delivering content to visitors. This method removes cached objects on every server in the CDN network. If you see a stale content or a file that send an incorrect header, purging cache will correct the issue. CDN will pull a fresh content from your origin server or your CDN FTP.
 2672 //
 2673 // This method takes an array of URLs. A URL must be exact as it is being requested by clients. An example URLs may look like this:
 2674 // * http://<your CDN username>.http.cdn.softlayer.net/mycdnname/some_file.txt
 2675 //
 2676 //
 2677 // If you created a CNAME that points to CDN host, use your CNAME URL instead.
 2678 // * http://image.mydomain.com/some_file.txt
 2679 //
 2680 //
 2681 // It takes approximately 3-5 minutes for the system to delete the requested object on every CDN server from submission .
 2682 func (r Network_ContentDelivery_Account) PurgeCache(objectUrls []string) (resp []datatypes.Container_Network_ContentDelivery_PurgeService_Response, err error) {
 2683     params := []interface{}{
 2684         objectUrls,
 2685     }
 2686     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "purgeCache", params, &r.Options, &resp)
 2687     return
 2688 }
 2689 
 2690 // If you want to turn off the token authentication, use this method to remove a directory from the token authentication directory.
 2691 func (r Network_ContentDelivery_Account) RemoveAuthenticationDirectory(directory *string, mediaType *string) (resp bool, err error) {
 2692     params := []interface{}{
 2693         directory,
 2694         mediaType,
 2695     }
 2696     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "removeAuthenticationDirectory", params, &r.Options, &resp)
 2697     return
 2698 }
 2699 
 2700 // With this method you can remove a file or a directory on the CDN FTP server. If a source name ends with a slash (/), this method assumes it is a directory.  A source name must be an absolute path. It does not check to see if a file or directory exists before deletion. You can only remove files and directories that are in /media folder. Be sure to catch an exception for the detail on an error.
 2701 func (r Network_ContentDelivery_Account) RemoveFile(source *string) (resp bool, err error) {
 2702     params := []interface{}{
 2703         source,
 2704     }
 2705     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "removeFile", params, &r.Options, &resp)
 2706     return
 2707 }
 2708 
 2709 // CDN servers will invoke a Web Service method to validate a content authentication token. CDN uses the default Web Service provided by SoftLayer to validate a token. A customer can use their own implementation of the token authentication Web Service. A valid SOAP WSDL will look similar [https://manage.softlayer.com/CdnService/authenticationWsdlExample/wsdl this].
 2710 func (r Network_ContentDelivery_Account) SetAuthenticationServiceEndpoint(webserviceEndpoint *string, protocol *string) (resp bool, err error) {
 2711     params := []interface{}{
 2712         webserviceEndpoint,
 2713         protocol,
 2714     }
 2715     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "setAuthenticationServiceEndpoint", params, &r.Options, &resp)
 2716     return
 2717 }
 2718 
 2719 // With a CDN FTP, you can upload contents to CDN host server. Once you uploaded contents, your contents will be fetched by the CDN POP (Points of Presence) servers as needed.
 2720 //
 2721 // CDN supports three protocols: Flash streaming (rtmp), Window Media streaming (mms) and HTTP. Once you log in to the CDN FTP server, you will see three directories under /media directory.  You have to upload your contents to a proper directory to use the different services. Refer to [[SoftLayer_Network_ContentDelivery_Account|CDN Account]] service overview for details on the CDN FTP server. "gzip" is supported if you compress your content before uploading and you have to change its extension to ".gz".  [SoftLayer_Network_ContentDelivery_Account::createOriginPullRule|Origin Pull] also supports "gzip" contents and you don't have to modify file extension with Origin Pull. Once uploaded, your contents should be available almost immediately to visitors.  However, it may take about 30 minutes to propagate files to the entire CDN network after uploading. For more details, visit our [hhttp://knowledgelayer.softlayer.com/topic/cdn KnowledgeLayer]
 2722 //
 2723 // This method updates the password for your CDN FTP account on the ftp.cdnlayer.service.softlayer.com server. You must provide an alphanumeric value for a new password.  - _ ! % # $ ^ & * characters are allowed beside an alphanumeric string.
 2724 func (r Network_ContentDelivery_Account) SetFtpPassword(newPassword *string) (resp bool, err error) {
 2725     params := []interface{}{
 2726         newPassword,
 2727     }
 2728     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "setFtpPassword", params, &r.Options, &resp)
 2729     return
 2730 }
 2731 
 2732 // This method allows you to edit CDN account note. The maximum length for CDN account note is 30 characters.
 2733 func (r Network_ContentDelivery_Account) UpdateNote(note *string) (resp bool, err error) {
 2734     params := []interface{}{
 2735         note,
 2736     }
 2737     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "updateNote", params, &r.Options, &resp)
 2738     return
 2739 }
 2740 
 2741 // With this method, you can upload binary data to the CDN FTP server.  This method supports files up to 20 Mega Bytes. You need to use the CDN FTP (ftp.cdnlayer.service.softlayer.com) to upload files larger than 20 MB.  This method takes [[SoftLayer_Container_Utility_File_Attachment]] a first parameter. A target name must be an absolute path and you can only upload a file to a directory that is in /media folder.
 2742 func (r Network_ContentDelivery_Account) UploadStream(source *datatypes.Container_Utility_File_Attachment, target *string) (resp bool, err error) {
 2743     params := []interface{}{
 2744         source,
 2745         target,
 2746     }
 2747     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Account", "uploadStream", params, &r.Options, &resp)
 2748     return
 2749 }
 2750 
 2751 // The SoftLayer_Network_ContentDelivery_Authentication_Address data type models an individual IP address that CDN allow or deny access from.
 2752 type Network_ContentDelivery_Authentication_Address struct {
 2753     Session *session.Session
 2754     Options sl.Options
 2755 }
 2756 
 2757 // GetNetworkContentDeliveryAuthenticationAddressService returns an instance of the Network_ContentDelivery_Authentication_Address SoftLayer service
 2758 func GetNetworkContentDeliveryAuthenticationAddressService(sess *session.Session) Network_ContentDelivery_Authentication_Address {
 2759     return Network_ContentDelivery_Authentication_Address{Session: sess}
 2760 }
 2761 
 2762 func (r Network_ContentDelivery_Authentication_Address) Id(id int) Network_ContentDelivery_Authentication_Address {
 2763     r.Options.Id = &id
 2764     return r
 2765 }
 2766 
 2767 func (r Network_ContentDelivery_Authentication_Address) Mask(mask string) Network_ContentDelivery_Authentication_Address {
 2768     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 2769         mask = fmt.Sprintf("mask[%s]", mask)
 2770     }
 2771 
 2772     r.Options.Mask = mask
 2773     return r
 2774 }
 2775 
 2776 func (r Network_ContentDelivery_Authentication_Address) Filter(filter string) Network_ContentDelivery_Authentication_Address {
 2777     r.Options.Filter = filter
 2778     return r
 2779 }
 2780 
 2781 func (r Network_ContentDelivery_Authentication_Address) Limit(limit int) Network_ContentDelivery_Authentication_Address {
 2782     r.Options.Limit = &limit
 2783     return r
 2784 }
 2785 
 2786 func (r Network_ContentDelivery_Authentication_Address) Offset(offset int) Network_ContentDelivery_Authentication_Address {
 2787     r.Options.Offset = &offset
 2788     return r
 2789 }
 2790 
 2791 // This method creates an authentication IP record.  Required parameters are
 2792 //
 2793 //
 2794 // * cdnAccountId - A CDN account id that belongs to your SoftLayer Account
 2795 // * ipAddress - An IP address or a IP range
 2796 // * accessType- It can be "ALLOW" or "DENY"
 2797 func (r Network_ContentDelivery_Authentication_Address) CreateObject(templateObject *datatypes.Network_ContentDelivery_Authentication_Address) (resp datatypes.Network_ContentDelivery_Authentication_Address, err error) {
 2798     params := []interface{}{
 2799         templateObject,
 2800     }
 2801     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Authentication_Address", "createObject", params, &r.Options, &resp)
 2802     return
 2803 }
 2804 
 2805 // This method deletes an authentication IP address.
 2806 func (r Network_ContentDelivery_Authentication_Address) DeleteObject() (resp bool, err error) {
 2807     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Authentication_Address", "deleteObject", nil, &r.Options, &resp)
 2808     return
 2809 }
 2810 
 2811 // This method let you edit an authentication IP object by passing a modified object.
 2812 func (r Network_ContentDelivery_Authentication_Address) EditObject(templateObject *datatypes.Network_ContentDelivery_Authentication_Address) (resp bool, err error) {
 2813     params := []interface{}{
 2814         templateObject,
 2815     }
 2816     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Authentication_Address", "editObject", params, &r.Options, &resp)
 2817     return
 2818 }
 2819 
 2820 // getObject retrieves the SoftLayer_Network_ContentDelivery_Authentication_Address object whose ID number corresponds to the ID number of the initial parameter passed to the SoftLayer_Network_ContentDelivery_Authentication_Address service. You can only retrieve authentication IP addresses assigned to one of your CDN account.
 2821 func (r Network_ContentDelivery_Authentication_Address) GetObject() (resp datatypes.Network_ContentDelivery_Authentication_Address, err error) {
 2822     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Authentication_Address", "getObject", nil, &r.Options, &resp)
 2823     return
 2824 }
 2825 
 2826 // The authentication IP address match occurs from the higher priority IP to the lower. This method will be helpful if you want to modify the order (priority) of the authentication IP addresses. You can use this method instead of editing individual authentication IP addresses.
 2827 //
 2828 // You can retrieve authentication IP address using [[SoftLayer_Network_ContentDelivery_Account::getAuthenticationIpAddresses|getAuthenticationIpAddresses]] method. Then, rearrange the authentication IP addresses and pass them to this method. When creating template objects as parameter, make sure to include the id of each authentication IP addresses. You must provide every authentication IP address.  New priorities will be assigned to each authentication IP addresses in the order of they are passed.
 2829 func (r Network_ContentDelivery_Authentication_Address) RearrangeAuthenticationIp(cdnAccountId *int, templateObjects []datatypes.Network_ContentDelivery_Authentication_Address) (resp bool, err error) {
 2830     params := []interface{}{
 2831         cdnAccountId,
 2832         templateObjects,
 2833     }
 2834     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Authentication_Address", "rearrangeAuthenticationIp", params, &r.Options, &resp)
 2835     return
 2836 }
 2837 
 2838 // The SoftLayer_Network_ContentDelivery_Authentication_Address data type models an individual IP address that CDN allow or deny access from.
 2839 type Network_ContentDelivery_Authentication_Token struct {
 2840     Session *session.Session
 2841     Options sl.Options
 2842 }
 2843 
 2844 // GetNetworkContentDeliveryAuthenticationTokenService returns an instance of the Network_ContentDelivery_Authentication_Token SoftLayer service
 2845 func GetNetworkContentDeliveryAuthenticationTokenService(sess *session.Session) Network_ContentDelivery_Authentication_Token {
 2846     return Network_ContentDelivery_Authentication_Token{Session: sess}
 2847 }
 2848 
 2849 func (r Network_ContentDelivery_Authentication_Token) Id(id int) Network_ContentDelivery_Authentication_Token {
 2850     r.Options.Id = &id
 2851     return r
 2852 }
 2853 
 2854 func (r Network_ContentDelivery_Authentication_Token) Mask(mask string) Network_ContentDelivery_Authentication_Token {
 2855     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 2856         mask = fmt.Sprintf("mask[%s]", mask)
 2857     }
 2858 
 2859     r.Options.Mask = mask
 2860     return r
 2861 }
 2862 
 2863 func (r Network_ContentDelivery_Authentication_Token) Filter(filter string) Network_ContentDelivery_Authentication_Token {
 2864     r.Options.Filter = filter
 2865     return r
 2866 }
 2867 
 2868 func (r Network_ContentDelivery_Authentication_Token) Limit(limit int) Network_ContentDelivery_Authentication_Token {
 2869     r.Options.Limit = &limit
 2870     return r
 2871 }
 2872 
 2873 func (r Network_ContentDelivery_Authentication_Token) Offset(offset int) Network_ContentDelivery_Authentication_Token {
 2874     r.Options.Offset = &offset
 2875     return r
 2876 }
 2877 
 2878 // This method is deprecated! Use the [[SoftLayer_Network_ContentDelivery_Authentication_Token::getTimedToken|getTimedToken]] method.
 2879 //
 2880 // This method creates a managed authentication token. When passing a parameter, the only required value is your CDN account id which can be obtained from the [[SoftLayer_Account::getCdnAccounts|getCdnAccounts]] method. There are 3 optional parameters you can pass:
 2881 //
 2882 //
 2883 // * name - This helps you keep track of managed tokens.
 2884 // * referrer - If set, the token validation will check the client's referrer. Keep in mind, if a client doesn't have the referrer information, the token validation will fail.
 2885 // * clientIp - If set, the token validation will check the client's IP address.
 2886 //
 2887 //
 2888 func (r Network_ContentDelivery_Authentication_Token) CreateObject(templateObject *datatypes.Network_ContentDelivery_Authentication_Token) (resp datatypes.Network_ContentDelivery_Authentication_Token, err error) {
 2889     params := []interface{}{
 2890         templateObject,
 2891     }
 2892     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Authentication_Token", "createObject", params, &r.Options, &resp)
 2893     return
 2894 }
 2895 
 2896 // This method is deprecated!
 2897 //
 2898 // This method returns all managed tokens for a CDN account.
 2899 func (r Network_ContentDelivery_Authentication_Token) GetAllManagedTokens(cdnAccountId *int) (resp []datatypes.Network_ContentDelivery_Authentication_Token, err error) {
 2900     params := []interface{}{
 2901         cdnAccountId,
 2902     }
 2903     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Authentication_Token", "getAllManagedTokens", params, &r.Options, &resp)
 2904     return
 2905 }
 2906 
 2907 // This method is deprecated!
 2908 //
 2909 // getObject retrieves the SoftLayer_Network_ContentDelivery_Authentication_Token object whose ID number corresponds to the ID number of the initial parameter passed to the SoftLayer_Network_ContentDelivery_Authentication_Token service. You can only retrieve managed tokens assigned to one of your CDN account.
 2910 func (r Network_ContentDelivery_Authentication_Token) GetObject() (resp datatypes.Network_ContentDelivery_Authentication_Token, err error) {
 2911     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Authentication_Token", "getObject", nil, &r.Options, &resp)
 2912     return
 2913 }
 2914 
 2915 // This method returns an authentication token that expires after the seconds you specify. You can provide number of seconds to manage the token life.  This parameter sets the expiration time for a token. A valid life time must be an integer between 60 and 604800 (1 week). A customer can also provide client ip and (or) referrer information.  If used, a client from the same IP and referrer can view the protected contents.
 2916 //
 2917 // A valid IP address must be an IPv4 format or an IP block. if you want to block access from IP 211.37.0.0/16, you can enter "211.37." instead. IP blocks can be specified in the manner of "8bit times n".
 2918 //
 2919 // The referrer is the URL of the previous webpage from which a link was followed.  A referrer should not include "http://" prefix and it can be maximum of 30 characters.
 2920 func (r Network_ContentDelivery_Authentication_Token) GetTimedToken(cdnAccountId *int, tokenLife *int, clientIp *string, referrer *string, mediaType *string) (resp string, err error) {
 2921     params := []interface{}{
 2922         cdnAccountId,
 2923         tokenLife,
 2924         clientIp,
 2925         referrer,
 2926         mediaType,
 2927     }
 2928     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Authentication_Token", "getTimedToken", params, &r.Options, &resp)
 2929     return
 2930 }
 2931 
 2932 // This method is deprecated!
 2933 //
 2934 // This method revokes all managed tokens belong to a CDN account.
 2935 func (r Network_ContentDelivery_Authentication_Token) RevokeAllManagedTokens(cdnAccountId *int) (resp bool, err error) {
 2936     params := []interface{}{
 2937         cdnAccountId,
 2938     }
 2939     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Authentication_Token", "revokeAllManagedTokens", params, &r.Options, &resp)
 2940     return
 2941 }
 2942 
 2943 // This method revokes all tokens belong to a CDN account.  Valid media types are "HTTP", "FLASH" and "WM".
 2944 func (r Network_ContentDelivery_Authentication_Token) RevokeAllTokens(cdnAccountId *int, mediaType *string) (resp bool, err error) {
 2945     params := []interface{}{
 2946         cdnAccountId,
 2947         mediaType,
 2948     }
 2949     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Authentication_Token", "revokeAllTokens", params, &r.Options, &resp)
 2950     return
 2951 }
 2952 
 2953 // This method is deprecated!
 2954 //
 2955 // Revokes a managed token. If you revoke a token, the token will be removed from SoftLayer's system but it will not remove your content on CDN FTP. The content that requires token validation will not be available to the visitor who is using a revoked token.
 2956 func (r Network_ContentDelivery_Authentication_Token) RevokeManagedToken(cdnAccountId *int, token *string) (resp bool, err error) {
 2957     params := []interface{}{
 2958         cdnAccountId,
 2959         token,
 2960     }
 2961     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Authentication_Token", "revokeManagedToken", params, &r.Options, &resp)
 2962     return
 2963 }
 2964 
 2965 // This method is deprecated!
 2966 //
 2967 // Deletes multiple managed tokens
 2968 func (r Network_ContentDelivery_Authentication_Token) RevokeManagedTokens(templateObjects []datatypes.Network_ContentDelivery_Authentication_Token) (resp bool, err error) {
 2969     params := []interface{}{
 2970         templateObjects,
 2971     }
 2972     err = r.Session.DoRequest("SoftLayer_Network_ContentDelivery_Authentication_Token", "revokeManagedTokens", params, &r.Options, &resp)
 2973     return
 2974 }
 2975 
 2976 // The SoftLayer_Network_Customer_Subnet data type contains general information relating to a single customer subnet (remote).
 2977 type Network_Customer_Subnet struct {
 2978     Session *session.Session
 2979     Options sl.Options
 2980 }
 2981 
 2982 // GetNetworkCustomerSubnetService returns an instance of the Network_Customer_Subnet SoftLayer service
 2983 func GetNetworkCustomerSubnetService(sess *session.Session) Network_Customer_Subnet {
 2984     return Network_Customer_Subnet{Session: sess}
 2985 }
 2986 
 2987 func (r Network_Customer_Subnet) Id(id int) Network_Customer_Subnet {
 2988     r.Options.Id = &id
 2989     return r
 2990 }
 2991 
 2992 func (r Network_Customer_Subnet) Mask(mask string) Network_Customer_Subnet {
 2993     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 2994         mask = fmt.Sprintf("mask[%s]", mask)
 2995     }
 2996 
 2997     r.Options.Mask = mask
 2998     return r
 2999 }
 3000 
 3001 func (r Network_Customer_Subnet) Filter(filter string) Network_Customer_Subnet {
 3002     r.Options.Filter = filter
 3003     return r
 3004 }
 3005 
 3006 func (r Network_Customer_Subnet) Limit(limit int) Network_Customer_Subnet {
 3007     r.Options.Limit = &limit
 3008     return r
 3009 }
 3010 
 3011 func (r Network_Customer_Subnet) Offset(offset int) Network_Customer_Subnet {
 3012     r.Options.Offset = &offset
 3013     return r
 3014 }
 3015 
 3016 // For IPSec network tunnels, customers can create their local subnets using this method.  After the customer is created successfully, the customer subnet can then be added to the IPSec network tunnel.
 3017 func (r Network_Customer_Subnet) CreateObject(templateObject *datatypes.Network_Customer_Subnet) (resp datatypes.Network_Customer_Subnet, err error) {
 3018     params := []interface{}{
 3019         templateObject,
 3020     }
 3021     err = r.Session.DoRequest("SoftLayer_Network_Customer_Subnet", "createObject", params, &r.Options, &resp)
 3022     return
 3023 }
 3024 
 3025 // Retrieve All ip addresses associated with a subnet.
 3026 func (r Network_Customer_Subnet) GetIpAddresses() (resp []datatypes.Network_Customer_Subnet_IpAddress, err error) {
 3027     err = r.Session.DoRequest("SoftLayer_Network_Customer_Subnet", "getIpAddresses", nil, &r.Options, &resp)
 3028     return
 3029 }
 3030 
 3031 // getObject retrieves the SoftLayer_Network_Customer_Subnet object whose ID number corresponds to the ID number of the init parameter passed to the SoftLayer_Network_Customer_Subnet service. You can only retrieve the subnet whose account matches the account that your portal user is assigned to.
 3032 func (r Network_Customer_Subnet) GetObject() (resp datatypes.Network_Customer_Subnet, err error) {
 3033     err = r.Session.DoRequest("SoftLayer_Network_Customer_Subnet", "getObject", nil, &r.Options, &resp)
 3034     return
 3035 }
 3036 
 3037 // The SoftLayer_Network_Firewall_AccessControlList data type contains general information relating to a single SoftLayer firewall access to controll list. This is the object which ties the running rules to a specific context. Use the [[SoftLayer Network Firewall Template]] service to pull SoftLayer recommended rule set templates. Use the [[SoftLayer Network Firewall Update Request]] service to submit a firewall update request.
 3038 type Network_Firewall_AccessControlList struct {
 3039     Session *session.Session
 3040     Options sl.Options
 3041 }
 3042 
 3043 // GetNetworkFirewallAccessControlListService returns an instance of the Network_Firewall_AccessControlList SoftLayer service
 3044 func GetNetworkFirewallAccessControlListService(sess *session.Session) Network_Firewall_AccessControlList {
 3045     return Network_Firewall_AccessControlList{Session: sess}
 3046 }
 3047 
 3048 func (r Network_Firewall_AccessControlList) Id(id int) Network_Firewall_AccessControlList {
 3049     r.Options.Id = &id
 3050     return r
 3051 }
 3052 
 3053 func (r Network_Firewall_AccessControlList) Mask(mask string) Network_Firewall_AccessControlList {
 3054     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 3055         mask = fmt.Sprintf("mask[%s]", mask)
 3056     }
 3057 
 3058     r.Options.Mask = mask
 3059     return r
 3060 }
 3061 
 3062 func (r Network_Firewall_AccessControlList) Filter(filter string) Network_Firewall_AccessControlList {
 3063     r.Options.Filter = filter
 3064     return r
 3065 }
 3066 
 3067 func (r Network_Firewall_AccessControlList) Limit(limit int) Network_Firewall_AccessControlList {
 3068     r.Options.Limit = &limit
 3069     return r
 3070 }
 3071 
 3072 func (r Network_Firewall_AccessControlList) Offset(offset int) Network_Firewall_AccessControlList {
 3073     r.Options.Offset = &offset
 3074     return r
 3075 }
 3076 
 3077 // Retrieve The update requests made for this firewall.
 3078 func (r Network_Firewall_AccessControlList) GetNetworkFirewallUpdateRequests() (resp []datatypes.Network_Firewall_Update_Request, err error) {
 3079     err = r.Session.DoRequest("SoftLayer_Network_Firewall_AccessControlList", "getNetworkFirewallUpdateRequests", nil, &r.Options, &resp)
 3080     return
 3081 }
 3082 
 3083 // Retrieve
 3084 func (r Network_Firewall_AccessControlList) GetNetworkVlan() (resp datatypes.Network_Vlan, err error) {
 3085     err = r.Session.DoRequest("SoftLayer_Network_Firewall_AccessControlList", "getNetworkVlan", nil, &r.Options, &resp)
 3086     return
 3087 }
 3088 
 3089 // getObject returns a SoftLayer_Network_Firewall_AccessControlList object. You can only get objects for servers attached to your account that have a network firewall enabled.
 3090 func (r Network_Firewall_AccessControlList) GetObject() (resp datatypes.Network_Firewall_AccessControlList, err error) {
 3091     err = r.Session.DoRequest("SoftLayer_Network_Firewall_AccessControlList", "getObject", nil, &r.Options, &resp)
 3092     return
 3093 }
 3094 
 3095 // Retrieve The currently running rule set of this context access control list firewall.
 3096 func (r Network_Firewall_AccessControlList) GetRules() (resp []datatypes.Network_Vlan_Firewall_Rule, err error) {
 3097     err = r.Session.DoRequest("SoftLayer_Network_Firewall_AccessControlList", "getRules", nil, &r.Options, &resp)
 3098     return
 3099 }
 3100 
 3101 // The SoftLayer_Network_Firewall_Interface data type contains general information relating to a single SoftLayer firewall interface. This is the object which ties the firewall context access control list to a firewall. Use the [[SoftLayer Network Firewall Template]] service to pull SoftLayer recommended rule set templates. Use the [[SoftLayer Network Firewall Update Request]] service to submit a firewall update request.
 3102 type Network_Firewall_Interface struct {
 3103     Session *session.Session
 3104     Options sl.Options
 3105 }
 3106 
 3107 // GetNetworkFirewallInterfaceService returns an instance of the Network_Firewall_Interface SoftLayer service
 3108 func GetNetworkFirewallInterfaceService(sess *session.Session) Network_Firewall_Interface {
 3109     return Network_Firewall_Interface{Session: sess}
 3110 }
 3111 
 3112 func (r Network_Firewall_Interface) Id(id int) Network_Firewall_Interface {
 3113     r.Options.Id = &id
 3114     return r
 3115 }
 3116 
 3117 func (r Network_Firewall_Interface) Mask(mask string) Network_Firewall_Interface {
 3118     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 3119         mask = fmt.Sprintf("mask[%s]", mask)
 3120     }
 3121 
 3122     r.Options.Mask = mask
 3123     return r
 3124 }
 3125 
 3126 func (r Network_Firewall_Interface) Filter(filter string) Network_Firewall_Interface {
 3127     r.Options.Filter = filter
 3128     return r
 3129 }
 3130 
 3131 func (r Network_Firewall_Interface) Limit(limit int) Network_Firewall_Interface {
 3132     r.Options.Limit = &limit
 3133     return r
 3134 }
 3135 
 3136 func (r Network_Firewall_Interface) Offset(offset int) Network_Firewall_Interface {
 3137     r.Options.Offset = &offset
 3138     return r
 3139 }
 3140 
 3141 // Retrieve
 3142 func (r Network_Firewall_Interface) GetFirewallContextAccessControlLists() (resp []datatypes.Network_Firewall_AccessControlList, err error) {
 3143     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Interface", "getFirewallContextAccessControlLists", nil, &r.Options, &resp)
 3144     return
 3145 }
 3146 
 3147 // Retrieve
 3148 func (r Network_Firewall_Interface) GetNetworkVlan() (resp datatypes.Network_Vlan, err error) {
 3149     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Interface", "getNetworkVlan", nil, &r.Options, &resp)
 3150     return
 3151 }
 3152 
 3153 // getObject returns a SoftLayer_Network_Firewall_Interface object. You can only get objects for servers attached to your account that have a network firewall enabled.
 3154 func (r Network_Firewall_Interface) GetObject() (resp datatypes.Network_Firewall_Interface, err error) {
 3155     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Interface", "getObject", nil, &r.Options, &resp)
 3156     return
 3157 }
 3158 
 3159 // no documentation yet
 3160 type Network_Firewall_Module_Context_Interface struct {
 3161     Session *session.Session
 3162     Options sl.Options
 3163 }
 3164 
 3165 // GetNetworkFirewallModuleContextInterfaceService returns an instance of the Network_Firewall_Module_Context_Interface SoftLayer service
 3166 func GetNetworkFirewallModuleContextInterfaceService(sess *session.Session) Network_Firewall_Module_Context_Interface {
 3167     return Network_Firewall_Module_Context_Interface{Session: sess}
 3168 }
 3169 
 3170 func (r Network_Firewall_Module_Context_Interface) Id(id int) Network_Firewall_Module_Context_Interface {
 3171     r.Options.Id = &id
 3172     return r
 3173 }
 3174 
 3175 func (r Network_Firewall_Module_Context_Interface) Mask(mask string) Network_Firewall_Module_Context_Interface {
 3176     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 3177         mask = fmt.Sprintf("mask[%s]", mask)
 3178     }
 3179 
 3180     r.Options.Mask = mask
 3181     return r
 3182 }
 3183 
 3184 func (r Network_Firewall_Module_Context_Interface) Filter(filter string) Network_Firewall_Module_Context_Interface {
 3185     r.Options.Filter = filter
 3186     return r
 3187 }
 3188 
 3189 func (r Network_Firewall_Module_Context_Interface) Limit(limit int) Network_Firewall_Module_Context_Interface {
 3190     r.Options.Limit = &limit
 3191     return r
 3192 }
 3193 
 3194 func (r Network_Firewall_Module_Context_Interface) Offset(offset int) Network_Firewall_Module_Context_Interface {
 3195     r.Options.Offset = &offset
 3196     return r
 3197 }
 3198 
 3199 // Retrieve
 3200 func (r Network_Firewall_Module_Context_Interface) GetFirewallContextAccessControlLists() (resp []datatypes.Network_Firewall_AccessControlList, err error) {
 3201     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Module_Context_Interface", "getFirewallContextAccessControlLists", nil, &r.Options, &resp)
 3202     return
 3203 }
 3204 
 3205 // Retrieve
 3206 func (r Network_Firewall_Module_Context_Interface) GetNetworkVlan() (resp datatypes.Network_Vlan, err error) {
 3207     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Module_Context_Interface", "getNetworkVlan", nil, &r.Options, &resp)
 3208     return
 3209 }
 3210 
 3211 // no documentation yet
 3212 func (r Network_Firewall_Module_Context_Interface) GetObject() (resp datatypes.Network_Firewall_Module_Context_Interface, err error) {
 3213     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Module_Context_Interface", "getObject", nil, &r.Options, &resp)
 3214     return
 3215 }
 3216 
 3217 // The SoftLayer_Network_Firewall_Template type contains general information for a SoftLayer network firewall template.
 3218 //
 3219 // Firewall templates are recommend rule sets for use with SoftLayer Hardware Firewall (Dedicated).  These optimized templates are designed to balance security restriction with application availability.  The templates given may be altered to provide custom network security, or may be used as-is for basic security. At least one rule set MUST be applied for the firewall to block traffic. Use the [[SoftLayer Network Component Firewall]] service to view current rules. Use the [[SoftLayer Network Firewall Update Request]] service to submit a firewall update request.
 3220 type Network_Firewall_Template struct {
 3221     Session *session.Session
 3222     Options sl.Options
 3223 }
 3224 
 3225 // GetNetworkFirewallTemplateService returns an instance of the Network_Firewall_Template SoftLayer service
 3226 func GetNetworkFirewallTemplateService(sess *session.Session) Network_Firewall_Template {
 3227     return Network_Firewall_Template{Session: sess}
 3228 }
 3229 
 3230 func (r Network_Firewall_Template) Id(id int) Network_Firewall_Template {
 3231     r.Options.Id = &id
 3232     return r
 3233 }
 3234 
 3235 func (r Network_Firewall_Template) Mask(mask string) Network_Firewall_Template {
 3236     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 3237         mask = fmt.Sprintf("mask[%s]", mask)
 3238     }
 3239 
 3240     r.Options.Mask = mask
 3241     return r
 3242 }
 3243 
 3244 func (r Network_Firewall_Template) Filter(filter string) Network_Firewall_Template {
 3245     r.Options.Filter = filter
 3246     return r
 3247 }
 3248 
 3249 func (r Network_Firewall_Template) Limit(limit int) Network_Firewall_Template {
 3250     r.Options.Limit = &limit
 3251     return r
 3252 }
 3253 
 3254 func (r Network_Firewall_Template) Offset(offset int) Network_Firewall_Template {
 3255     r.Options.Offset = &offset
 3256     return r
 3257 }
 3258 
 3259 // Get all available firewall template objects.
 3260 //
 3261 // ''getAllObjects'' returns an array of SoftLayer_Network_Firewall_Template objects upon success.
 3262 func (r Network_Firewall_Template) GetAllObjects() (resp []datatypes.Network_Firewall_Template, err error) {
 3263     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Template", "getAllObjects", nil, &r.Options, &resp)
 3264     return
 3265 }
 3266 
 3267 // getObject returns a SoftLayer_Network_Firewall_Template object. You can retrieve all available firewall templates. getAllObjects returns an array of all available SoftLayer_Network_Firewall_Template objects. You can use these templates to generate a [[SoftLayer Network Firewall Update Request]].
 3268 //
 3269 // @SLDNDocumentation Service See Also SoftLayer_Network_Firewall_Update_Request
 3270 func (r Network_Firewall_Template) GetObject() (resp datatypes.Network_Firewall_Template, err error) {
 3271     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Template", "getObject", nil, &r.Options, &resp)
 3272     return
 3273 }
 3274 
 3275 // Retrieve The rule set that belongs to this firewall rules template.
 3276 func (r Network_Firewall_Template) GetRules() (resp []datatypes.Network_Firewall_Template_Rule, err error) {
 3277     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Template", "getRules", nil, &r.Options, &resp)
 3278     return
 3279 }
 3280 
 3281 // The SoftLayer_Network_Firewall_Update_Request data type contains information relating to a SoftLayer network firewall update request. Use the [[SoftLayer Network Component Firewall]] service to view current rules. Use the [[SoftLayer Network Firewall Template]] service to pull SoftLayer recommended rule set templates.
 3282 type Network_Firewall_Update_Request struct {
 3283     Session *session.Session
 3284     Options sl.Options
 3285 }
 3286 
 3287 // GetNetworkFirewallUpdateRequestService returns an instance of the Network_Firewall_Update_Request SoftLayer service
 3288 func GetNetworkFirewallUpdateRequestService(sess *session.Session) Network_Firewall_Update_Request {
 3289     return Network_Firewall_Update_Request{Session: sess}
 3290 }
 3291 
 3292 func (r Network_Firewall_Update_Request) Id(id int) Network_Firewall_Update_Request {
 3293     r.Options.Id = &id
 3294     return r
 3295 }
 3296 
 3297 func (r Network_Firewall_Update_Request) Mask(mask string) Network_Firewall_Update_Request {
 3298     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 3299         mask = fmt.Sprintf("mask[%s]", mask)
 3300     }
 3301 
 3302     r.Options.Mask = mask
 3303     return r
 3304 }
 3305 
 3306 func (r Network_Firewall_Update_Request) Filter(filter string) Network_Firewall_Update_Request {
 3307     r.Options.Filter = filter
 3308     return r
 3309 }
 3310 
 3311 func (r Network_Firewall_Update_Request) Limit(limit int) Network_Firewall_Update_Request {
 3312     r.Options.Limit = &limit
 3313     return r
 3314 }
 3315 
 3316 func (r Network_Firewall_Update_Request) Offset(offset int) Network_Firewall_Update_Request {
 3317     r.Options.Offset = &offset
 3318     return r
 3319 }
 3320 
 3321 // Create a new firewall update request. The SoftLayer_Network_Firewall_Update_Request object passed to this function must have at least one rule.
 3322 //
 3323 // ''createObject'' returns a Boolean ''true'' on successful object creation or ''false'' if your firewall update request was unable to be created.
 3324 func (r Network_Firewall_Update_Request) CreateObject(templateObject *datatypes.Network_Firewall_Update_Request) (resp datatypes.Network_Firewall_Update_Request, err error) {
 3325     params := []interface{}{
 3326         templateObject,
 3327     }
 3328     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Update_Request", "createObject", params, &r.Options, &resp)
 3329     return
 3330 }
 3331 
 3332 // Retrieve The user that authorized this firewall update request.
 3333 func (r Network_Firewall_Update_Request) GetAuthorizingUser() (resp datatypes.User_Interface, err error) {
 3334     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Update_Request", "getAuthorizingUser", nil, &r.Options, &resp)
 3335     return
 3336 }
 3337 
 3338 // Get the possible attribute values for a firewall update request rule.  These are the valid values which may be submitted as rule parameters for a firewall update request.
 3339 //
 3340 // ''getFirewallUpdateRequestRuleAttributes'' returns a SoftLayer_Container_Utility_Network_Firewall_Rule_Attribute object upon success.
 3341 func (r Network_Firewall_Update_Request) GetFirewallUpdateRequestRuleAttributes() (resp datatypes.Container_Utility_Network_Firewall_Rule_Attribute, err error) {
 3342     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Update_Request", "getFirewallUpdateRequestRuleAttributes", nil, &r.Options, &resp)
 3343     return
 3344 }
 3345 
 3346 // Retrieve The downstream virtual server that the rule set will be applied to.
 3347 func (r Network_Firewall_Update_Request) GetGuest() (resp datatypes.Virtual_Guest, err error) {
 3348     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Update_Request", "getGuest", nil, &r.Options, &resp)
 3349     return
 3350 }
 3351 
 3352 // Retrieve The downstream server that the rule set will be applied to.
 3353 func (r Network_Firewall_Update_Request) GetHardware() (resp datatypes.Hardware, err error) {
 3354     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Update_Request", "getHardware", nil, &r.Options, &resp)
 3355     return
 3356 }
 3357 
 3358 // Retrieve The network component firewall that the rule set will be applied to.
 3359 func (r Network_Firewall_Update_Request) GetNetworkComponentFirewall() (resp datatypes.Network_Component_Firewall, err error) {
 3360     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Update_Request", "getNetworkComponentFirewall", nil, &r.Options, &resp)
 3361     return
 3362 }
 3363 
 3364 // ''getObject'' returns a SoftLayer_Network_Firewall_Update_Request object. You can only get historical objects for servers attached to your account that have a network firewall enabled. ''createObject'' inserts a new SoftLayer_Network_Firewall_Update_Request object. You can only insert requests for servers attached to your account that have a network firewall enabled. ''getFirewallUpdateRequestRuleAttributes'' Get the possible attribute values for a firewall update request rule.
 3365 func (r Network_Firewall_Update_Request) GetObject() (resp datatypes.Network_Firewall_Update_Request, err error) {
 3366     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Update_Request", "getObject", nil, &r.Options, &resp)
 3367     return
 3368 }
 3369 
 3370 // Retrieve The group of rules contained within the update request.
 3371 func (r Network_Firewall_Update_Request) GetRules() (resp []datatypes.Network_Firewall_Update_Request_Rule, err error) {
 3372     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Update_Request", "getRules", nil, &r.Options, &resp)
 3373     return
 3374 }
 3375 
 3376 // no documentation yet
 3377 func (r Network_Firewall_Update_Request) UpdateRuleNote(fwRule *datatypes.Network_Component_Firewall_Rule, note *string) (resp bool, err error) {
 3378     params := []interface{}{
 3379         fwRule,
 3380         note,
 3381     }
 3382     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Update_Request", "updateRuleNote", params, &r.Options, &resp)
 3383     return
 3384 }
 3385 
 3386 // The SoftLayer_Network_Firewall_Update_Request_Rule type contains information relating to a SoftLayer network firewall update request rule. This rule is a member of a [[SoftLayer Network Firewall Update Request]]. Use the [[SoftLayer Network Component Firewall]] service to view current rules. Use the [[SoftLayer Network Firewall Template]] service to pull SoftLayer recommended rule set templates.
 3387 type Network_Firewall_Update_Request_Rule struct {
 3388     Session *session.Session
 3389     Options sl.Options
 3390 }
 3391 
 3392 // GetNetworkFirewallUpdateRequestRuleService returns an instance of the Network_Firewall_Update_Request_Rule SoftLayer service
 3393 func GetNetworkFirewallUpdateRequestRuleService(sess *session.Session) Network_Firewall_Update_Request_Rule {
 3394     return Network_Firewall_Update_Request_Rule{Session: sess}
 3395 }
 3396 
 3397 func (r Network_Firewall_Update_Request_Rule) Id(id int) Network_Firewall_Update_Request_Rule {
 3398     r.Options.Id = &id
 3399     return r
 3400 }
 3401 
 3402 func (r Network_Firewall_Update_Request_Rule) Mask(mask string) Network_Firewall_Update_Request_Rule {
 3403     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 3404         mask = fmt.Sprintf("mask[%s]", mask)
 3405     }
 3406 
 3407     r.Options.Mask = mask
 3408     return r
 3409 }
 3410 
 3411 func (r Network_Firewall_Update_Request_Rule) Filter(filter string) Network_Firewall_Update_Request_Rule {
 3412     r.Options.Filter = filter
 3413     return r
 3414 }
 3415 
 3416 func (r Network_Firewall_Update_Request_Rule) Limit(limit int) Network_Firewall_Update_Request_Rule {
 3417     r.Options.Limit = &limit
 3418     return r
 3419 }
 3420 
 3421 func (r Network_Firewall_Update_Request_Rule) Offset(offset int) Network_Firewall_Update_Request_Rule {
 3422     r.Options.Offset = &offset
 3423     return r
 3424 }
 3425 
 3426 // Create a new firewall update request. The SoftLayer_Network_Firewall_Update_Request object passed to this function must have at least one rule.
 3427 //
 3428 // ''createObject'' returns a Boolean ''true'' on successful object creation or ''false'' if your firewall update request was unable to be created..
 3429 func (r Network_Firewall_Update_Request_Rule) CreateObject(templateObject *datatypes.Network_Firewall_Update_Request_Rule) (resp datatypes.Network_Firewall_Update_Request_Rule, err error) {
 3430     params := []interface{}{
 3431         templateObject,
 3432     }
 3433     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Update_Request_Rule", "createObject", params, &r.Options, &resp)
 3434     return
 3435 }
 3436 
 3437 // Retrieve The update request that this rule belongs to.
 3438 func (r Network_Firewall_Update_Request_Rule) GetFirewallUpdateRequest() (resp datatypes.Network_Firewall_Update_Request, err error) {
 3439     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Update_Request_Rule", "getFirewallUpdateRequest", nil, &r.Options, &resp)
 3440     return
 3441 }
 3442 
 3443 // getObject returns a SoftLayer_Network_Firewall_Update_Request_Rule object. You can only get historical objects for servers attached to your account that have a network firewall enabled. createObject inserts a new SoftLayer_Network_Firewall_Update_Request_Rule object. Use the SoftLayer_Network_Firewall_Update_Request to create groups of rules for an update request.
 3444 func (r Network_Firewall_Update_Request_Rule) GetObject() (resp datatypes.Network_Firewall_Update_Request_Rule, err error) {
 3445     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Update_Request_Rule", "getObject", nil, &r.Options, &resp)
 3446     return
 3447 }
 3448 
 3449 // Validate the supplied firewall request rule against the object it will apply to. For IPv4 rules, pass in an instance of SoftLayer_Network_Firewall_Update_Request_Rule. for IPv6 rules, pass in an instance of SoftLayer_Network_Firewall_Update_Request_Rule_Version6. The ID of the applied to object can either be applyToComponentId (an ID of a SoftLayer_Network_Component_Firewall) or applyToAclId (an ID of a SoftLayer_Network_Firewall_Module_Context_Interface_AccessControlList). One, and only one, of applyToComponentId and applyToAclId can be specified.
 3450 //
 3451 // If validation is successful, nothing is returned. If validation is unsuccessful, an exception is thrown explaining the nature of the validation error.
 3452 func (r Network_Firewall_Update_Request_Rule) ValidateRule(rule *datatypes.Network_Firewall_Update_Request_Rule, applyToComponentId *int, applyToAclId *int) (err error) {
 3453     var resp datatypes.Void
 3454     params := []interface{}{
 3455         rule,
 3456         applyToComponentId,
 3457         applyToAclId,
 3458     }
 3459     err = r.Session.DoRequest("SoftLayer_Network_Firewall_Update_Request_Rule", "validateRule", params, &r.Options, &resp)
 3460     return
 3461 }
 3462 
 3463 // no documentation yet
 3464 type Network_Gateway struct {
 3465     Session *session.Session
 3466     Options sl.Options
 3467 }
 3468 
 3469 // GetNetworkGatewayService returns an instance of the Network_Gateway SoftLayer service
 3470 func GetNetworkGatewayService(sess *session.Session) Network_Gateway {
 3471     return Network_Gateway{Session: sess}
 3472 }
 3473 
 3474 func (r Network_Gateway) Id(id int) Network_Gateway {
 3475     r.Options.Id = &id
 3476     return r
 3477 }
 3478 
 3479 func (r Network_Gateway) Mask(mask string) Network_Gateway {
 3480     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 3481         mask = fmt.Sprintf("mask[%s]", mask)
 3482     }
 3483 
 3484     r.Options.Mask = mask
 3485     return r
 3486 }
 3487 
 3488 func (r Network_Gateway) Filter(filter string) Network_Gateway {
 3489     r.Options.Filter = filter
 3490     return r
 3491 }
 3492 
 3493 func (r Network_Gateway) Limit(limit int) Network_Gateway {
 3494     r.Options.Limit = &limit
 3495     return r
 3496 }
 3497 
 3498 func (r Network_Gateway) Offset(offset int) Network_Gateway {
 3499     r.Options.Offset = &offset
 3500     return r
 3501 }
 3502 
 3503 // Start the asynchronous process to bypass all VLANs. Any VLANs that are already bypassed will be ignored. The status field can be checked for progress.
 3504 func (r Network_Gateway) BypassAllVlans() (err error) {
 3505     var resp datatypes.Void
 3506     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "bypassAllVlans", nil, &r.Options, &resp)
 3507     return
 3508 }
 3509 
 3510 // Start the asynchronous process to bypass the provided VLANs. The VLANs must already be attached. Any VLANs that are already bypassed will be ignored. The status field can be checked for progress.
 3511 func (r Network_Gateway) BypassVlans(vlans []datatypes.Network_Gateway_Vlan) (err error) {
 3512     var resp datatypes.Void
 3513     params := []interface{}{
 3514         vlans,
 3515     }
 3516     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "bypassVlans", params, &r.Options, &resp)
 3517     return
 3518 }
 3519 
 3520 // Create and return a new gateway. This object can be created with any number of members or VLANs, but they all must be in the same pod. By creating a gateway with members and/or VLANs attached, it is the equivalent of individually calling their createObject methods except this will start a single asynchronous process to setup the gateway. The status of this process can be checked using the status field.
 3521 func (r Network_Gateway) CreateObject(templateObject *datatypes.Network_Gateway) (resp datatypes.Network_Gateway, err error) {
 3522     params := []interface{}{
 3523         templateObject,
 3524     }
 3525     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "createObject", params, &r.Options, &resp)
 3526     return
 3527 }
 3528 
 3529 // Edit this gateway. Currently, the only value that can be edited is the name.
 3530 func (r Network_Gateway) EditObject(templateObject *datatypes.Network_Gateway) (resp bool, err error) {
 3531     params := []interface{}{
 3532         templateObject,
 3533     }
 3534     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "editObject", params, &r.Options, &resp)
 3535     return
 3536 }
 3537 
 3538 // Retrieve The account for this gateway.
 3539 func (r Network_Gateway) GetAccount() (resp datatypes.Account, err error) {
 3540     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "getAccount", nil, &r.Options, &resp)
 3541     return
 3542 }
 3543 
 3544 // Retrieve All VLANs trunked to this gateway.
 3545 func (r Network_Gateway) GetInsideVlans() (resp []datatypes.Network_Gateway_Vlan, err error) {
 3546     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "getInsideVlans", nil, &r.Options, &resp)
 3547     return
 3548 }
 3549 
 3550 // Retrieve The members for this gateway.
 3551 func (r Network_Gateway) GetMembers() (resp []datatypes.Network_Gateway_Member, err error) {
 3552     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "getMembers", nil, &r.Options, &resp)
 3553     return
 3554 }
 3555 
 3556 // no documentation yet
 3557 func (r Network_Gateway) GetObject() (resp datatypes.Network_Gateway, err error) {
 3558     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "getObject", nil, &r.Options, &resp)
 3559     return
 3560 }
 3561 
 3562 // Get all VLANs that can become inside VLANs on this gateway. This means the VLAN must not already be an inside VLAN, on the same router as this gateway, not a gateway transit VLAN, and not firewalled.
 3563 func (r Network_Gateway) GetPossibleInsideVlans() (resp []datatypes.Network_Vlan, err error) {
 3564     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "getPossibleInsideVlans", nil, &r.Options, &resp)
 3565     return
 3566 }
 3567 
 3568 // Retrieve The private gateway IP address.
 3569 func (r Network_Gateway) GetPrivateIpAddress() (resp datatypes.Network_Subnet_IpAddress, err error) {
 3570     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "getPrivateIpAddress", nil, &r.Options, &resp)
 3571     return
 3572 }
 3573 
 3574 // Retrieve The private VLAN for accessing this gateway.
 3575 func (r Network_Gateway) GetPrivateVlan() (resp datatypes.Network_Vlan, err error) {
 3576     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "getPrivateVlan", nil, &r.Options, &resp)
 3577     return
 3578 }
 3579 
 3580 // Retrieve The public gateway IP address.
 3581 func (r Network_Gateway) GetPublicIpAddress() (resp datatypes.Network_Subnet_IpAddress, err error) {
 3582     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "getPublicIpAddress", nil, &r.Options, &resp)
 3583     return
 3584 }
 3585 
 3586 // Retrieve The public gateway IPv6 address.
 3587 func (r Network_Gateway) GetPublicIpv6Address() (resp datatypes.Network_Subnet_IpAddress, err error) {
 3588     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "getPublicIpv6Address", nil, &r.Options, &resp)
 3589     return
 3590 }
 3591 
 3592 // Retrieve The public VLAN for accessing this gateway.
 3593 func (r Network_Gateway) GetPublicVlan() (resp datatypes.Network_Vlan, err error) {
 3594     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "getPublicVlan", nil, &r.Options, &resp)
 3595     return
 3596 }
 3597 
 3598 // Retrieve The current status of the gateway.
 3599 func (r Network_Gateway) GetStatus() (resp datatypes.Network_Gateway_Status, err error) {
 3600     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "getStatus", nil, &r.Options, &resp)
 3601     return
 3602 }
 3603 
 3604 // Start the asynchronous process to unbypass all VLANs. Any VLANs that are already unbypassed will be ignored. The status field can be checked for progress.
 3605 func (r Network_Gateway) UnbypassAllVlans() (err error) {
 3606     var resp datatypes.Void
 3607     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "unbypassAllVlans", nil, &r.Options, &resp)
 3608     return
 3609 }
 3610 
 3611 // Start the asynchronous process to unbypass the provided VLANs. The VLANs must already be attached. Any VLANs that are already unbypassed will be ignored. The status field can be checked for progress.
 3612 func (r Network_Gateway) UnbypassVlans(vlans []datatypes.Network_Gateway_Vlan) (err error) {
 3613     var resp datatypes.Void
 3614     params := []interface{}{
 3615         vlans,
 3616     }
 3617     err = r.Session.DoRequest("SoftLayer_Network_Gateway", "unbypassVlans", params, &r.Options, &resp)
 3618     return
 3619 }
 3620 
 3621 // no documentation yet
 3622 type Network_Gateway_Member struct {
 3623     Session *session.Session
 3624     Options sl.Options
 3625 }
 3626 
 3627 // GetNetworkGatewayMemberService returns an instance of the Network_Gateway_Member SoftLayer service
 3628 func GetNetworkGatewayMemberService(sess *session.Session) Network_Gateway_Member {
 3629     return Network_Gateway_Member{Session: sess}
 3630 }
 3631 
 3632 func (r Network_Gateway_Member) Id(id int) Network_Gateway_Member {
 3633     r.Options.Id = &id
 3634     return r
 3635 }
 3636 
 3637 func (r Network_Gateway_Member) Mask(mask string) Network_Gateway_Member {
 3638     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 3639         mask = fmt.Sprintf("mask[%s]", mask)
 3640     }
 3641 
 3642     r.Options.Mask = mask
 3643     return r
 3644 }
 3645 
 3646 func (r Network_Gateway_Member) Filter(filter string) Network_Gateway_Member {
 3647     r.Options.Filter = filter
 3648     return r
 3649 }
 3650 
 3651 func (r Network_Gateway_Member) Limit(limit int) Network_Gateway_Member {
 3652     r.Options.Limit = &limit
 3653     return r
 3654 }
 3655 
 3656 func (r Network_Gateway_Member) Offset(offset int) Network_Gateway_Member {
 3657     r.Options.Offset = &offset
 3658     return r
 3659 }
 3660 
 3661 // Create a new hardware member on the gateway. This also asynchronously sets up the network for this member. Progress of this process can be monitored via the gateway status. All members created with this object must have no VLANs attached.
 3662 func (r Network_Gateway_Member) CreateObject(templateObject *datatypes.Network_Gateway_Member) (resp datatypes.Network_Gateway_Member, err error) {
 3663     params := []interface{}{
 3664         templateObject,
 3665     }
 3666     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Member", "createObject", params, &r.Options, &resp)
 3667     return
 3668 }
 3669 
 3670 // Create multiple new hardware members on the gateway. This also asynchronously sets up the network for the members. Progress of this process can be monitored via the gateway status. All members created with this object must have no VLANs attached.
 3671 func (r Network_Gateway_Member) CreateObjects(templateObjects []datatypes.Network_Gateway_Member) (resp []datatypes.Network_Gateway_Member, err error) {
 3672     params := []interface{}{
 3673         templateObjects,
 3674     }
 3675     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Member", "createObjects", params, &r.Options, &resp)
 3676     return
 3677 }
 3678 
 3679 // Retrieve The device for this member.
 3680 func (r Network_Gateway_Member) GetHardware() (resp datatypes.Hardware, err error) {
 3681     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Member", "getHardware", nil, &r.Options, &resp)
 3682     return
 3683 }
 3684 
 3685 // Retrieve The gateway this member belongs to.
 3686 func (r Network_Gateway_Member) GetNetworkGateway() (resp datatypes.Network_Gateway, err error) {
 3687     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Member", "getNetworkGateway", nil, &r.Options, &resp)
 3688     return
 3689 }
 3690 
 3691 // no documentation yet
 3692 func (r Network_Gateway_Member) GetObject() (resp datatypes.Network_Gateway_Member, err error) {
 3693     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Member", "getObject", nil, &r.Options, &resp)
 3694     return
 3695 }
 3696 
 3697 // no documentation yet
 3698 type Network_Gateway_Status struct {
 3699     Session *session.Session
 3700     Options sl.Options
 3701 }
 3702 
 3703 // GetNetworkGatewayStatusService returns an instance of the Network_Gateway_Status SoftLayer service
 3704 func GetNetworkGatewayStatusService(sess *session.Session) Network_Gateway_Status {
 3705     return Network_Gateway_Status{Session: sess}
 3706 }
 3707 
 3708 func (r Network_Gateway_Status) Id(id int) Network_Gateway_Status {
 3709     r.Options.Id = &id
 3710     return r
 3711 }
 3712 
 3713 func (r Network_Gateway_Status) Mask(mask string) Network_Gateway_Status {
 3714     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 3715         mask = fmt.Sprintf("mask[%s]", mask)
 3716     }
 3717 
 3718     r.Options.Mask = mask
 3719     return r
 3720 }
 3721 
 3722 func (r Network_Gateway_Status) Filter(filter string) Network_Gateway_Status {
 3723     r.Options.Filter = filter
 3724     return r
 3725 }
 3726 
 3727 func (r Network_Gateway_Status) Limit(limit int) Network_Gateway_Status {
 3728     r.Options.Limit = &limit
 3729     return r
 3730 }
 3731 
 3732 func (r Network_Gateway_Status) Offset(offset int) Network_Gateway_Status {
 3733     r.Options.Offset = &offset
 3734     return r
 3735 }
 3736 
 3737 // no documentation yet
 3738 func (r Network_Gateway_Status) GetObject() (resp datatypes.Network_Gateway_Status, err error) {
 3739     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Status", "getObject", nil, &r.Options, &resp)
 3740     return
 3741 }
 3742 
 3743 // no documentation yet
 3744 type Network_Gateway_Vlan struct {
 3745     Session *session.Session
 3746     Options sl.Options
 3747 }
 3748 
 3749 // GetNetworkGatewayVlanService returns an instance of the Network_Gateway_Vlan SoftLayer service
 3750 func GetNetworkGatewayVlanService(sess *session.Session) Network_Gateway_Vlan {
 3751     return Network_Gateway_Vlan{Session: sess}
 3752 }
 3753 
 3754 func (r Network_Gateway_Vlan) Id(id int) Network_Gateway_Vlan {
 3755     r.Options.Id = &id
 3756     return r
 3757 }
 3758 
 3759 func (r Network_Gateway_Vlan) Mask(mask string) Network_Gateway_Vlan {
 3760     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 3761         mask = fmt.Sprintf("mask[%s]", mask)
 3762     }
 3763 
 3764     r.Options.Mask = mask
 3765     return r
 3766 }
 3767 
 3768 func (r Network_Gateway_Vlan) Filter(filter string) Network_Gateway_Vlan {
 3769     r.Options.Filter = filter
 3770     return r
 3771 }
 3772 
 3773 func (r Network_Gateway_Vlan) Limit(limit int) Network_Gateway_Vlan {
 3774     r.Options.Limit = &limit
 3775     return r
 3776 }
 3777 
 3778 func (r Network_Gateway_Vlan) Offset(offset int) Network_Gateway_Vlan {
 3779     r.Options.Offset = &offset
 3780     return r
 3781 }
 3782 
 3783 // Start the asynchronous process to bypass/unroute the VLAN from this gateway.
 3784 func (r Network_Gateway_Vlan) Bypass() (err error) {
 3785     var resp datatypes.Void
 3786     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Vlan", "bypass", nil, &r.Options, &resp)
 3787     return
 3788 }
 3789 
 3790 // Create a new VLAN attachment. If the bypassFlag is false, this will also create an asynchronous process to route the VLAN through the gateway.
 3791 func (r Network_Gateway_Vlan) CreateObject(templateObject *datatypes.Network_Gateway_Vlan) (resp datatypes.Network_Gateway_Vlan, err error) {
 3792     params := []interface{}{
 3793         templateObject,
 3794     }
 3795     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Vlan", "createObject", params, &r.Options, &resp)
 3796     return
 3797 }
 3798 
 3799 // Create multiple new VLAN attachments. If the bypassFlag is false, this will also create an asynchronous process to route the VLANs through the gateway.
 3800 func (r Network_Gateway_Vlan) CreateObjects(templateObjects []datatypes.Network_Gateway_Vlan) (resp []datatypes.Network_Gateway_Vlan, err error) {
 3801     params := []interface{}{
 3802         templateObjects,
 3803     }
 3804     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Vlan", "createObjects", params, &r.Options, &resp)
 3805     return
 3806 }
 3807 
 3808 // Start the asynchronous process to detach this VLANs from the gateway.
 3809 func (r Network_Gateway_Vlan) DeleteObject() (err error) {
 3810     var resp datatypes.Void
 3811     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Vlan", "deleteObject", nil, &r.Options, &resp)
 3812     return
 3813 }
 3814 
 3815 // Detach several VLANs. This will not detach them right away, but rather start an asynchronous process to detach.
 3816 func (r Network_Gateway_Vlan) DeleteObjects(templateObjects []datatypes.Network_Gateway_Vlan) (resp bool, err error) {
 3817     params := []interface{}{
 3818         templateObjects,
 3819     }
 3820     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Vlan", "deleteObjects", params, &r.Options, &resp)
 3821     return
 3822 }
 3823 
 3824 // Retrieve The gateway this VLAN is attached to.
 3825 func (r Network_Gateway_Vlan) GetNetworkGateway() (resp datatypes.Network_Gateway, err error) {
 3826     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Vlan", "getNetworkGateway", nil, &r.Options, &resp)
 3827     return
 3828 }
 3829 
 3830 // Retrieve The network VLAN record.
 3831 func (r Network_Gateway_Vlan) GetNetworkVlan() (resp datatypes.Network_Vlan, err error) {
 3832     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Vlan", "getNetworkVlan", nil, &r.Options, &resp)
 3833     return
 3834 }
 3835 
 3836 // no documentation yet
 3837 func (r Network_Gateway_Vlan) GetObject() (resp datatypes.Network_Gateway_Vlan, err error) {
 3838     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Vlan", "getObject", nil, &r.Options, &resp)
 3839     return
 3840 }
 3841 
 3842 // Start the asynchronous process to route the VLAN to this gateway.
 3843 func (r Network_Gateway_Vlan) Unbypass() (err error) {
 3844     var resp datatypes.Void
 3845     err = r.Session.DoRequest("SoftLayer_Network_Gateway_Vlan", "unbypass", nil, &r.Options, &resp)
 3846     return
 3847 }
 3848 
 3849 // The SoftLayer_Network_LBaaS_Listener type presents a data structure for a load balancers listener, also called frontend.
 3850 type Network_LBaaS_Listener struct {
 3851     Session *session.Session
 3852     Options sl.Options
 3853 }
 3854 
 3855 // GetNetworkLBaaSListenerService returns an instance of the Network_LBaaS_Listener SoftLayer service
 3856 func GetNetworkLBaaSListenerService(sess *session.Session) Network_LBaaS_Listener {
 3857     return Network_LBaaS_Listener{Session: sess}
 3858 }
 3859 
 3860 func (r Network_LBaaS_Listener) Id(id int) Network_LBaaS_Listener {
 3861     r.Options.Id = &id
 3862     return r
 3863 }
 3864 
 3865 func (r Network_LBaaS_Listener) Mask(mask string) Network_LBaaS_Listener {
 3866     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 3867         mask = fmt.Sprintf("mask[%s]", mask)
 3868     }
 3869 
 3870     r.Options.Mask = mask
 3871     return r
 3872 }
 3873 
 3874 func (r Network_LBaaS_Listener) Filter(filter string) Network_LBaaS_Listener {
 3875     r.Options.Filter = filter
 3876     return r
 3877 }
 3878 
 3879 func (r Network_LBaaS_Listener) Limit(limit int) Network_LBaaS_Listener {
 3880     r.Options.Limit = &limit
 3881     return r
 3882 }
 3883 
 3884 func (r Network_LBaaS_Listener) Offset(offset int) Network_LBaaS_Listener {
 3885     r.Options.Offset = &offset
 3886     return r
 3887 }
 3888 
 3889 // Delete load balancers front- and backend protocols and return load balancer object with listeners (frontend), pools (backend), server instances (members) and datacenter populated.
 3890 func (r Network_LBaaS_Listener) DeleteLoadBalancerProtocols(loadBalancerUuid *string, listenerUuids []string) (resp datatypes.Network_LBaaS_LoadBalancer, err error) {
 3891     params := []interface{}{
 3892         loadBalancerUuid,
 3893         listenerUuids,
 3894     }
 3895     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_Listener", "deleteLoadBalancerProtocols", params, &r.Options, &resp)
 3896     return
 3897 }
 3898 
 3899 // Retrieve
 3900 func (r Network_LBaaS_Listener) GetDefaultPool() (resp datatypes.Network_LBaaS_Pool, err error) {
 3901     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_Listener", "getDefaultPool", nil, &r.Options, &resp)
 3902     return
 3903 }
 3904 
 3905 // Retrieve
 3906 func (r Network_LBaaS_Listener) GetLoadBalancer() (resp datatypes.Network_LBaaS_LoadBalancer, err error) {
 3907     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_Listener", "getLoadBalancer", nil, &r.Options, &resp)
 3908     return
 3909 }
 3910 
 3911 // no documentation yet
 3912 func (r Network_LBaaS_Listener) GetObject() (resp datatypes.Network_LBaaS_Listener, err error) {
 3913     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_Listener", "getObject", nil, &r.Options, &resp)
 3914     return
 3915 }
 3916 
 3917 // Update (create) load balancers front- and backend protocols and return load balancer object with listeners (frontend), pools (backend), server instances (members) and datacenter populated. Note if a protocolConfiguration has no listenerUuid set, this function will create the specified front- and backend accordingly. Otherwise the given front- and backend will be updated with the new protocol and port.
 3918 func (r Network_LBaaS_Listener) UpdateLoadBalancerProtocols(loadBalancerUuid *string, protocolConfigurations []datatypes.Network_LBaaS_LoadBalancerProtocolConfiguration) (resp datatypes.Network_LBaaS_LoadBalancer, err error) {
 3919     params := []interface{}{
 3920         loadBalancerUuid,
 3921         protocolConfigurations,
 3922     }
 3923     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_Listener", "updateLoadBalancerProtocols", params, &r.Options, &resp)
 3924     return
 3925 }
 3926 
 3927 // The SoftLayer_Network_LBaaS_LoadBalancer type presents a structure containing attributes of a load balancer, and its related objects including listeners, pools and members.
 3928 type Network_LBaaS_LoadBalancer struct {
 3929     Session *session.Session
 3930     Options sl.Options
 3931 }
 3932 
 3933 // GetNetworkLBaaSLoadBalancerService returns an instance of the Network_LBaaS_LoadBalancer SoftLayer service
 3934 func GetNetworkLBaaSLoadBalancerService(sess *session.Session) Network_LBaaS_LoadBalancer {
 3935     return Network_LBaaS_LoadBalancer{Session: sess}
 3936 }
 3937 
 3938 func (r Network_LBaaS_LoadBalancer) Id(id int) Network_LBaaS_LoadBalancer {
 3939     r.Options.Id = &id
 3940     return r
 3941 }
 3942 
 3943 func (r Network_LBaaS_LoadBalancer) Mask(mask string) Network_LBaaS_LoadBalancer {
 3944     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 3945         mask = fmt.Sprintf("mask[%s]", mask)
 3946     }
 3947 
 3948     r.Options.Mask = mask
 3949     return r
 3950 }
 3951 
 3952 func (r Network_LBaaS_LoadBalancer) Filter(filter string) Network_LBaaS_LoadBalancer {
 3953     r.Options.Filter = filter
 3954     return r
 3955 }
 3956 
 3957 func (r Network_LBaaS_LoadBalancer) Limit(limit int) Network_LBaaS_LoadBalancer {
 3958     r.Options.Limit = &limit
 3959     return r
 3960 }
 3961 
 3962 func (r Network_LBaaS_LoadBalancer) Offset(offset int) Network_LBaaS_LoadBalancer {
 3963     r.Options.Offset = &offset
 3964     return r
 3965 }
 3966 
 3967 // Cancel a load balancer with the given uuid. The billing system will execute the deletion of load balancer and all objects associated with it such as load balancer appliances, listeners, pools and members in the background.
 3968 func (r Network_LBaaS_LoadBalancer) CancelLoadBalancer(uuid *string) (resp bool, err error) {
 3969     params := []interface{}{
 3970         uuid,
 3971     }
 3972     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_LoadBalancer", "cancelLoadBalancer", params, &r.Options, &resp)
 3973     return
 3974 }
 3975 
 3976 // Return all existing load balancers
 3977 func (r Network_LBaaS_LoadBalancer) GetAllObjects() (resp []datatypes.Network_LBaaS_LoadBalancer, err error) {
 3978     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_LoadBalancer", "getAllObjects", nil, &r.Options, &resp)
 3979     return
 3980 }
 3981 
 3982 // Retrieve Datacenter, where load balancer is located.
 3983 func (r Network_LBaaS_LoadBalancer) GetDatacenter() (resp datatypes.Location, err error) {
 3984     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_LoadBalancer", "getDatacenter", nil, &r.Options, &resp)
 3985     return
 3986 }
 3987 
 3988 // Retrieve
 3989 func (r Network_LBaaS_LoadBalancer) GetIpAddress() (resp datatypes.Network_Subnet_IpAddress, err error) {
 3990     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_LoadBalancer", "getIpAddress", nil, &r.Options, &resp)
 3991     return
 3992 }
 3993 
 3994 // Retrieve Listeners assigned to load balancer.
 3995 func (r Network_LBaaS_LoadBalancer) GetListeners() (resp []datatypes.Network_LBaaS_Listener, err error) {
 3996     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_LoadBalancer", "getListeners", nil, &r.Options, &resp)
 3997     return
 3998 }
 3999 
 4000 // Get the load balancer object with given uuid.
 4001 func (r Network_LBaaS_LoadBalancer) GetLoadBalancer(uuid *string) (resp datatypes.Network_LBaaS_LoadBalancer, err error) {
 4002     params := []interface{}{
 4003         uuid,
 4004     }
 4005     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_LoadBalancer", "getLoadBalancer", params, &r.Options, &resp)
 4006     return
 4007 }
 4008 
 4009 // Return load balancer members health
 4010 func (r Network_LBaaS_LoadBalancer) GetLoadBalancerMemberHealth(uuid *string) (resp []datatypes.Network_LBaaS_PoolMembersHealth, err error) {
 4011     params := []interface{}{
 4012         uuid,
 4013     }
 4014     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_LoadBalancer", "getLoadBalancerMemberHealth", params, &r.Options, &resp)
 4015     return
 4016 }
 4017 
 4018 // Return load balancers statistics such as total number of current sessions and total number of accumulated connections.
 4019 func (r Network_LBaaS_LoadBalancer) GetLoadBalancerStatistics(uuid *string) (resp datatypes.Network_LBaaS_LoadBalancerStatistics, err error) {
 4020     params := []interface{}{
 4021         uuid,
 4022     }
 4023     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_LoadBalancer", "getLoadBalancerStatistics", params, &r.Options, &resp)
 4024     return
 4025 }
 4026 
 4027 // Retrieve Members assigned to load balancer.
 4028 func (r Network_LBaaS_LoadBalancer) GetMembers() (resp []datatypes.Network_LBaaS_Member, err error) {
 4029     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_LoadBalancer", "getMembers", nil, &r.Options, &resp)
 4030     return
 4031 }
 4032 
 4033 // no documentation yet
 4034 func (r Network_LBaaS_LoadBalancer) GetObject() (resp datatypes.Network_LBaaS_LoadBalancer, err error) {
 4035     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_LoadBalancer", "getObject", nil, &r.Options, &resp)
 4036     return
 4037 }
 4038 
 4039 // Update load balancer's description, and return the load balancer object containing all listeners, pools, members and datacenter.
 4040 func (r Network_LBaaS_LoadBalancer) UpdateLoadBalancer(uuid *string, newDescription *string) (resp datatypes.Network_LBaaS_LoadBalancer, err error) {
 4041     params := []interface{}{
 4042         uuid,
 4043         newDescription,
 4044     }
 4045     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_LoadBalancer", "updateLoadBalancer", params, &r.Options, &resp)
 4046     return
 4047 }
 4048 
 4049 // The SoftLayer_Network_LBaaS_Member represents the backend member for a load balancer. It can be either a virtual server or a bare metal machine.
 4050 type Network_LBaaS_Member struct {
 4051     Session *session.Session
 4052     Options sl.Options
 4053 }
 4054 
 4055 // GetNetworkLBaaSMemberService returns an instance of the Network_LBaaS_Member SoftLayer service
 4056 func GetNetworkLBaaSMemberService(sess *session.Session) Network_LBaaS_Member {
 4057     return Network_LBaaS_Member{Session: sess}
 4058 }
 4059 
 4060 func (r Network_LBaaS_Member) Id(id int) Network_LBaaS_Member {
 4061     r.Options.Id = &id
 4062     return r
 4063 }
 4064 
 4065 func (r Network_LBaaS_Member) Mask(mask string) Network_LBaaS_Member {
 4066     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 4067         mask = fmt.Sprintf("mask[%s]", mask)
 4068     }
 4069 
 4070     r.Options.Mask = mask
 4071     return r
 4072 }
 4073 
 4074 func (r Network_LBaaS_Member) Filter(filter string) Network_LBaaS_Member {
 4075     r.Options.Filter = filter
 4076     return r
 4077 }
 4078 
 4079 func (r Network_LBaaS_Member) Limit(limit int) Network_LBaaS_Member {
 4080     r.Options.Limit = &limit
 4081     return r
 4082 }
 4083 
 4084 func (r Network_LBaaS_Member) Offset(offset int) Network_LBaaS_Member {
 4085     r.Options.Offset = &offset
 4086     return r
 4087 }
 4088 
 4089 // Add server instances as members to load balancer and return it with listeners, pools and members populated
 4090 func (r Network_LBaaS_Member) AddLoadBalancerMembers(loadBalancerUuid *string, serverInstances []datatypes.Network_LBaaS_LoadBalancerServerInstanceInfo) (resp datatypes.Network_LBaaS_LoadBalancer, err error) {
 4091     params := []interface{}{
 4092         loadBalancerUuid,
 4093         serverInstances,
 4094     }
 4095     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_Member", "addLoadBalancerMembers", params, &r.Options, &resp)
 4096     return
 4097 }
 4098 
 4099 // Delete given members from load balancer and return load balancer object with listeners, pools and members populated
 4100 func (r Network_LBaaS_Member) DeleteLoadBalancerMembers(loadBalancerUuid *string, memberUuids []string) (resp datatypes.Network_LBaaS_LoadBalancer, err error) {
 4101     params := []interface{}{
 4102         loadBalancerUuid,
 4103         memberUuids,
 4104     }
 4105     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_Member", "deleteLoadBalancerMembers", params, &r.Options, &resp)
 4106     return
 4107 }
 4108 
 4109 // Retrieve
 4110 func (r Network_LBaaS_Member) GetLoadBalancer() (resp datatypes.Network_LBaaS_LoadBalancer, err error) {
 4111     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_Member", "getLoadBalancer", nil, &r.Options, &resp)
 4112     return
 4113 }
 4114 
 4115 // no documentation yet
 4116 func (r Network_LBaaS_Member) GetObject() (resp datatypes.Network_LBaaS_Member, err error) {
 4117     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_Member", "getObject", nil, &r.Options, &resp)
 4118     return
 4119 }
 4120 
 4121 // Update members weight and return load balancer object with listeners, pools and members populated
 4122 func (r Network_LBaaS_Member) UpdateLoadBalancerMembers(loadBalancerUuid *string, members []datatypes.Network_LBaaS_Member) (resp datatypes.Network_LBaaS_LoadBalancer, err error) {
 4123     params := []interface{}{
 4124         loadBalancerUuid,
 4125         members,
 4126     }
 4127     err = r.Session.DoRequest("SoftLayer_Network_LBaaS_Member", "updateLoadBalancerMembers", params, &r.Options, &resp)
 4128     return
 4129 }
 4130 
 4131 // The SoftLayer_Network_LoadBalancer_Global_Account data type contains the properties for a single global load balancer account.  The properties you are able to edit are fallbackIp, loadBalanceTypeId, and notes. The hosts relational property can be used for creating and editing hosts that belong to the global load balancer account.  The [[SoftLayer_Network_LoadBalancer_Global_Account::editObject|editObject]] method contains details on creating and edited hosts through the hosts relational property.
 4132 type Network_LoadBalancer_Global_Account struct {
 4133     Session *session.Session
 4134     Options sl.Options
 4135 }
 4136 
 4137 // GetNetworkLoadBalancerGlobalAccountService returns an instance of the Network_LoadBalancer_Global_Account SoftLayer service
 4138 func GetNetworkLoadBalancerGlobalAccountService(sess *session.Session) Network_LoadBalancer_Global_Account {
 4139     return Network_LoadBalancer_Global_Account{Session: sess}
 4140 }
 4141 
 4142 func (r Network_LoadBalancer_Global_Account) Id(id int) Network_LoadBalancer_Global_Account {
 4143     r.Options.Id = &id
 4144     return r
 4145 }
 4146 
 4147 func (r Network_LoadBalancer_Global_Account) Mask(mask string) Network_LoadBalancer_Global_Account {
 4148     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 4149         mask = fmt.Sprintf("mask[%s]", mask)
 4150     }
 4151 
 4152     r.Options.Mask = mask
 4153     return r
 4154 }
 4155 
 4156 func (r Network_LoadBalancer_Global_Account) Filter(filter string) Network_LoadBalancer_Global_Account {
 4157     r.Options.Filter = filter
 4158     return r
 4159 }
 4160 
 4161 func (r Network_LoadBalancer_Global_Account) Limit(limit int) Network_LoadBalancer_Global_Account {
 4162     r.Options.Limit = &limit
 4163     return r
 4164 }
 4165 
 4166 func (r Network_LoadBalancer_Global_Account) Offset(offset int) Network_LoadBalancer_Global_Account {
 4167     r.Options.Offset = &offset
 4168     return r
 4169 }
 4170 
 4171 // If your globally load balanced domain is hosted on the SoftLayer nameservers this method will add the required NS resource record to your DNS zone file and remove any A records that match the host portion of a global load balancer account hostname.  A NS resource record is required to be able to use your SoftLayer global load balancer account. Please make sure the zone file for the hostname listed on your SoftLayer global load balancer account is setup prior to using this method.  If your globally load balanced domain is hosted on any other nameservers this method will not be able to add the required NS record.
 4172 func (r Network_LoadBalancer_Global_Account) AddNsRecord() (resp bool, err error) {
 4173     err = r.Session.DoRequest("SoftLayer_Network_LoadBalancer_Global_Account", "addNsRecord", nil, &r.Options, &resp)
 4174     return
 4175 }
 4176 
 4177 // Edit the properties of a global load balancer account by passing in a modified instance of the object. The global load balancer account properties you are able to edit are: fallback ip, load balance type id, and notes. Hosts that belong to your SoftLayer global load balancer account are created and modified through this method. An example templateObject that updates global load balancer account properties, updates the properties of a host, and adds a new host is shown below:
 4178 //
 4179 //
 4180 // * id: 2
 4181 // * loadBalanceTypeId: 2
 4182 // * notes: Notes updated
 4183 // * fallbackIp: 1.1.1.1
 4184 // * hosts:
 4185 // ** id: 19
 4186 // ** destinationIp: 2.2.2.2
 4187 // ** weight: 25
 4188 // ** healthCheck: http
 4189 // ** destinationPort: 80
 4190 // ** enabled: 1<br /><br />
 4191 // ** destinationIp: 3.3.3.3
 4192 // ** weight: 25
 4193 // ** healthCheck: http
 4194 // ** destinationPort: 80
 4195 // ** enabled: 1
 4196 //
 4197 //
 4198 //
 4199 //
 4200 // The first section contains the properties of the global load balancer account that will be updated, while the second section contains the elements of the 'hosts' property of the global load balancer account.  The first host listed will have its properties updated because the 'id' property of the host is set, meaning the global load balancer host with an id of 19 will be updated. The second host listed will be created because it lacks the 'id' property.
 4201 //
 4202 // There is a limit to the maximum number of hosts that you are allowed to add, and is defined by the allowedNumberOfHosts property on the global load balancer account.  The destination IP address of a host must be an IP address that belongs to your SoftLayer Account, or a local load balancer virtual IP address that belongs to your account.  The destination IP address and destination port are required and must be provided when creating a host.
 4203 func (r Network_LoadBalancer_Global_Account) EditObject(templateObject *datatypes.Network_LoadBalancer_Global_Account) (resp bool, err error) {
 4204     params := []interface{}{
 4205         templateObject,
 4206     }
 4207     err = r.Session.DoRequest("SoftLayer_Network_LoadBalancer_Global_Account", "editObject", params, &r.Options, &resp)
 4208     return
 4209 }
 4210 
 4211 // Retrieve Your SoftLayer customer account.
 4212 func (r Network_LoadBalancer_Global_Account) GetAccount() (resp datatypes.Account, err error) {
 4213     err = r.Session.DoRequest("SoftLayer_Network_LoadBalancer_Global_Account", "getAccount", nil, &r.Options, &resp)
 4214     return
 4215 }
 4216 
 4217 // Retrieve The current billing item for a Global Load Balancer account.
 4218 func (r Network_LoadBalancer_Global_Account) GetBillingItem() (resp datatypes.Billing_Item, err error) {
 4219     err = r.Session.DoRequest("SoftLayer_Network_LoadBalancer_Global_Account", "getBillingItem", nil, &r.Options, &resp)
 4220     return
 4221 }
 4222 
 4223 // Retrieve The hosts in the load balancing pool for a global load balancer account.
 4224 func (r Network_LoadBalancer_Global_Account) GetHosts() (resp []datatypes.Network_LoadBalancer_Global_Host, err error) {
 4225     err = r.Session.DoRequest("SoftLayer_Network_LoadBalancer_Global_Account", "getHosts", nil, &r.Options, &resp)
 4226     return
 4227 }
 4228 
 4229 // Retrieve The load balance method of a global load balancer account
 4230 func (r Network_LoadBalancer_Global_Account) GetLoadBalanceType() (resp datatypes.Network_LoadBalancer_Global_Type, err error) {
 4231     err = r.Session.DoRequest("SoftLayer_Network_LoadBalancer_Global_Account", "getLoadBalanceType", nil, &r.Options, &resp)
 4232     return
 4233 }
 4234 
 4235 // Retrieve A flag indicating that the global load balancer is a managed resource.
 4236 func (r Network_LoadBalancer_Global_Account) GetManagedResourceFlag() (resp bool, err error) {
 4237     err = r.Session.DoRequest("SoftLayer_Network_LoadBalancer_Global_Account", "getManagedResourceFlag", nil, &r.Options, &resp)
 4238     return
 4239 }
 4240 
 4241 // getObject retrieves the SoftLayer_Network_LoadBalancer_Global_Account object whose ID number corresponds to the ID number of the init paramater passed to the SoftLayer_Network_LoadBalancer_Global_Account service. You can only retrieve a global load balancer account that is assigned to your SoftLayer customer account.
 4242 func (r Network_LoadBalancer_Global_Account) GetObject() (resp datatypes.Network_LoadBalancer_Global_Account, err error) {
 4243     err = r.Session.DoRequest("SoftLayer_Network_LoadBalancer_Global_Account", "getObject", nil, &r.Options, &resp)
 4244     return
 4245 }
 4246 
 4247 // If your globally load balanced domain is hosted on the SoftLayer nameservers this method will remove the NS resource record from your DNS zone file. Removing the NS resource record will basically disable your global load balancer account since no DNS requests will be forwarded to the global load balancers. Any A records that were removed when the NS resource record was added will not be created for you.  If your globally load balanced domain is hosted on any other nameservers this method will not be able to remove the required NS record.
 4248 func (r Network_LoadBalancer_Global_Account) RemoveNsRecord() (resp bool, err error) {
 4249     err = r.Session.DoRequest("SoftLayer_Network_LoadBalancer_Global_Account", "removeNsRecord", nil, &r.Options, &resp)
 4250     return
 4251 }
 4252 
 4253 // The SoftLayer_Network_LoadBalancer_Global_Host data type represents a single host that belongs to a global load balancer account's load balancing pool.
 4254 //
 4255 // The destination IP address of a host must be one that belongs to your SoftLayer customer account, or to a datacenter load balancer virtual ip that belongs to your SoftLayer customer account.  The destination IP address and port of a global load balancer host is a required field and must exist during creation and can not be removed.  The acceptable values for the health check type are 'none', 'http', and 'tcp'. The status property is updated in 5 minute intervals and the hits property is updated in 10 minute intervals.
 4256 //
 4257 // The order of the host is only important if you are using the 'failover' load balance method, and the weight is only important if you are using the 'weighted round robin' load balance method.
 4258 type Network_LoadBalancer_Global_Host struct {
 4259     Session *session.Session
 4260     Options sl.Options
 4261 }
 4262 
 4263 // GetNetworkLoadBalancerGlobalHostService returns an instance of the Network_LoadBalancer_Global_Host SoftLayer service
 4264 func GetNetworkLoadBalancerGlobalHostService(sess *session.Session) Network_LoadBalancer_Global_Host {
 4265     return Network_LoadBalancer_Global_Host{Session: sess}
 4266 }
 4267 
 4268 func (r Network_LoadBalancer_Global_Host) Id(id int) Network_LoadBalancer_Global_Host {
 4269     r.Options.Id = &id
 4270     return r
 4271 }
 4272 
 4273 func (r Network_LoadBalancer_Global_Host) Mask(mask string) Network_LoadBalancer_Global_Host {
 4274     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 4275         mask = fmt.Sprintf("mask[%s]", mask)
 4276     }
 4277 
 4278     r.Options.Mask = mask
 4279     return r
 4280 }
 4281 
 4282 func (r Network_LoadBalancer_Global_Host) Filter(filter string) Network_LoadBalancer_Global_Host {
 4283     r.Options.Filter = filter
 4284     return r
 4285 }
 4286 
 4287 func (r Network_LoadBalancer_Global_Host) Limit(limit int) Network_LoadBalancer_Global_Host {
 4288     r.Options.Limit = &limit
 4289     return r
 4290 }
 4291 
 4292 func (r Network_LoadBalancer_Global_Host) Offset(offset int) Network_LoadBalancer_Global_Host {
 4293     r.Options.Offset = &offset
 4294     return r
 4295 }
 4296 
 4297 // Remove a host from the load balancing pool of a global load balancer account.
 4298 func (r Network_LoadBalancer_Global_Host) DeleteObject() (resp bool, err error) {
 4299     err = r.Session.DoRequest("SoftLayer_Network_LoadBalancer_Global_Host", "deleteObject", nil, &r.Options, &resp)
 4300     return
 4301 }
 4302 
 4303 // Retrieve The global load balancer account a host belongs to.
 4304 func (r Network_LoadBalancer_Global_Host) GetLoadBalancerAccount() (resp datatypes.Network_LoadBalancer_Global_Account, err error) {
 4305     err = r.Session.DoRequest("SoftLayer_Network_LoadBalancer_Global_Host", "getLoadBalancerAccount", nil, &r.Options, &resp)
 4306     return
 4307 }
 4308 
 4309 // getObject retrieves the SoftLayer_Network_LoadBalancer_Global_Host object whose ID number corresponds to the ID number of the init paramater passed to the SoftLayer_Network_LoadBalancer_Global_Host service. You can only retrieve a global load balancer host that is assigned to your SoftLayer global load balancer account.
 4310 func (r Network_LoadBalancer_Global_Host) GetObject() (resp datatypes.Network_LoadBalancer_Global_Host, err error) {
 4311     err = r.Session.DoRequest("SoftLayer_Network_LoadBalancer_Global_Host", "getObject", nil, &r.Options, &resp)
 4312     return
 4313 }
 4314 
 4315 // The SoftLayer_Network_LoadBalancer_Service data type contains all the information relating to a specific service (destination) on a particular load balancer.
 4316 //
 4317 // Information retained on the object itself is the the source and destination of the service, routing type, weight, and whether or not the service is currently enabled.
 4318 type Network_LoadBalancer_Service struct {
 4319     Session *session.Session
 4320     Options sl.Options
 4321 }
 4322 
 4323 // GetNetworkLoadBalancerServiceService returns an instance of the Network_LoadBalancer_Service SoftLayer service
 4324 func GetNetworkLoadBalancerServiceService(sess *session.Session) Network_LoadBalancer_Service {
 4325     return Network_LoadBalancer_Service{Session: sess}
 4326 }
 4327 
 4328 func (r Network_LoadBalancer_Service) Id(id int) Network_LoadBalancer_Service {
 4329     r.Options.Id = &id
 4330     return r
 4331 }
 4332 
 4333 func (r Network_LoadBalancer_Service) Mask(mask string) Network_LoadBalancer_Service {
 4334     if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
 4335         mask = fmt.Sprintf("mask[%s]", mask)
 4336     }
 4337 
 4338     r.Options.Mask = mask
 4339     return r
 4340 }
 4341 
 4342 func (r Network_LoadBalancer_Service) Filter(filter string) Network_LoadBalancer_Service {
 4343     r.Options.Filter = filter
 4344     return r
 4345 }
 4346 
 4347 func (r Network_LoadBalancer_Service) Limit(limit int) Network_LoadBalancer_Service {
 4348     r.Options.Limit = &limit
 4349     return r
 4350 }
 4351 
 4352 func (r Network_LoadBalancer_Service) Offset(offset int) Network_LoadBalancer_Service {
 4353     r.Options.Offset = &offset
 4354     return r