Use this API to add vrid.
439631
public static base_response add(nitro_service client, vrid resource) throws Exception {
		vrid addresource = new vrid();
		addresource.id = resource.id;
		addresource.priority = resource.priority;
		addresource.preemption = resource.preemption;
		addresource.sharing = resource.sharing;
		addresource.tracking = resource.tracking;
		return addresource.add_resource(client);
	}
795580
def _add_request_entry(self, entry=()):
        
        if not self._lookup_request_entry(entry):
            self.request_entry.append(entry)
384857
public static base_response update(nitro_service client, vrid resource) throws Exception {
		vrid updateresource = new vrid();
		updateresource.id = resource.id;
		updateresource.priority = resource.priority;
		updateresource.preemption = resource.preemption;
		updateresource.sharing = resource.sharing;
		updateresource.tracking = resource.tracking;
		return updateresource.update_resource(client);
	}
185576
def create_api_vrf(self):
        """"""
        return ApiVrf(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
179306
def add_vrf(arg, opts, shell_opts):
    

    v = VRF()
    v.rt = opts.get('rt')
    v.name = opts.get('name')
    v.description = opts.get('description')
    v.tags = list(csv.reader([opts.get('tags', '')], escapechar='\\'))[0]

    for avp in opts.get('extra-attribute', []):
        try:
            key, value = avp.split('=', 1)
        except ValueError:
            print("ERROR: Incorrect extra-attribute: %s. Accepted form: 'key=value'\n" % avp, file=sys.stderr)
            return
        v.avps[key] = value

    try:
        v.save()
    except pynipap.NipapError as exc:
        print("Could not add VRF to NIPAP: %s" % str(exc), file=sys.stderr)
        sys.exit(1)

    print("Added %s" % (vrf_format(v)))
438148
def _add_details(self, info):
        """"""
        for (key, val) in six.iteritems(info):
            if key == "nodes":
                val = [Node(parent=self, **nd) for nd in val]
            elif key == "sessionPersistence":
                val = val['persistenceType']
            elif key == "cluster":
                val = val['name']
            elif key == "virtualIps":
                key = "virtual_ips"
                val = [VirtualIP(parent=self, **vip) for vip in val]
            setattr(self, key, val)
611634
private void addClient(String id, IClient client) {
        // check to see if the id already exists first
        if (!hasClient(id)) {
            clients.put(id, client);
        } else {
            log.debug("Client id: {} already registered", id);
        }
    }
478396
function addVariable() {
            variableService.addOrUpdate(vm.variable, function () {
                vm.variables[vm.variable.key] = vm.variable.value;
                vm.variable = {
                    key: undefined,
                    value: undefined
                };
            });
        }
542750
public static base_responses update(nitro_service client, vrid resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			vrid updateresources[] = new vrid[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new vrid();
				updateresources[i].id = resources[i].id;
				updateresources[i].priority = resources[i].priority;
				updateresources[i].preemption = resources[i].preemption;
				updateresources[i].sharing = resources[i].sharing;
				updateresources[i].tracking = resources[i].tracking;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
592595
public static base_response add(nitro_service client, aaakcdaccount resource) throws Exception {
		aaakcdaccount addresource = new aaakcdaccount();
		addresource.kcdaccount = resource.kcdaccount;
		addresource.keytab = resource.keytab;
		addresource.realmstr = resource.realmstr;
		addresource.delegateduser = resource.delegateduser;
		addresource.kcdpassword = resource.kcdpassword;
		addresource.usercert = resource.usercert;
		addresource.cacert = resource.cacert;
		return addresource.add_resource(client);
	}
779160
def add_lambda_integration(self):
        """"""
        lambda_uri = self.generate_uris()['lambda_uri']
        self.client.put_integration(
            restApiId=self.api_id,
            resourceId=self.resource_id,
            httpMethod=self.trigger_settings['method'],
            integrationHttpMethod='POST',
            uri=lambda_uri,
            type='AWS')
        self.add_integration_response()
        self.log.info("Successfully added Lambda intergration to API")
11114
def add_oid(self,oid,value,label=None):
		""""""
		self.add_oid_entry(oid,'OBJECTID',value,label=label)
313558
public static base_response add(nitro_service client, autoscaleaction resource) throws Exception {
		autoscaleaction addresource = new autoscaleaction();
		addresource.name = resource.name;
		addresource.type = resource.type;
		addresource.profilename = resource.profilename;
		addresource.parameters = resource.parameters;
		addresource.vmdestroygraceperiod = resource.vmdestroygraceperiod;
		addresource.quiettime = resource.quiettime;
		addresource.vserver = resource.vserver;
		return addresource.add_resource(client);
	}
696690
def _add_interface(self, interface_id, mgt=None, **kw):
        
        _kw = copy.deepcopy(kw) # Preserve original kw, especially lists
        mgt = mgt if mgt else {}
        
        if 'cvi_mode' in _kw:
            self.data.update(cvi_mode=_kw.pop('cvi_mode'))
        
        if 'macaddress' in _kw:
            self.data.update(
                macaddress=_kw.pop('macaddress'))
            if 'cvi_mode' not in self.data:
                self.data.update(cvi_mode='packetdispatch')
        
        if 'zone_ref' in _kw:
            zone_ref = _kw.pop('zone_ref')
            self.data.update(zone_ref=zone_helper(zone_ref) if zone_ref else None)
        
        if 'comment' in _kw:
            self.data.update(comment=_kw.pop('comment'))

        interfaces = _kw.pop('interfaces', [])
        for interface in interfaces:
            vlan_id = interface.pop('vlan_id', None)
            if vlan_id:
                _interface_id = '{}.{}'.format(interface_id, vlan_id)
            else:
                _interface_id = interface_id
    
            _interface = []
            if_mgt = {k: str(v) == str(_interface_id) for k, v in mgt.items()}
            
            if 'cluster_virtual' in interface and 'network_value' in interface:
                cluster_virtual = interface.pop('cluster_virtual')
                network_value = interface.pop('network_value')
                if cluster_virtual and network_value:
                    cvi = ClusterVirtualInterface.create(
                        _interface_id, cluster_virtual, network_value,
                        auth_request=True if if_mgt.get('primary_mgt') else False)
                      
                    _interface.append({cvi.typeof: cvi.data})
    
            for node in interface.pop('nodes', []):
                _node = if_mgt.copy()
                _node.update(outgoing=True if if_mgt.get('primary_mgt') else False)
                # Add node specific key/value pairs set on the node. This can
                # also be used to override management settings
                _node.update(node)
                ndi = NodeInterface.create(
                    interface_id=_interface_id, **_node)
                _interface.append({ndi.typeof: ndi.data})

            if vlan_id:
                vlan_interface = {
                    'interface_id': _interface_id,
                    'zone_ref': zone_helper(interface.pop('zone_ref', None)),
                    'comment': interface.pop('comment', None),
                    'interfaces': _interface}
                # Add remaining kwargs on vlan level to VLAN physical interface
                for name, value in interface.items():
                    vlan_interface[name] = value
                self.data.setdefault('vlanInterfaces', []).append(
                    vlan_interface)
            else:
                self.data.setdefault('interfaces', []).extend(
                    _interface)

        # Remaining kw go to base level interface
        for name, value in _kw.items():
            self.data[name] = value
100553
def add_to_virtualbox(self):
        
        # VirtualBox Image
        if 'vmname' not in self.node['properties']:
            self.node['properties']['vmname'] = \
                self.hypervisor['VBoxDevice']['image']
        # Number of adapters
        if 'adapters' not in self.node['properties']:
            self.node['properties']['adapters'] = \
                self.hypervisor['VBoxDevice']['nics']
        # Console Port
        if 'console' not in self.node['properties']:
            self.node['properties']['console'] = \
                self.base_ports['vbox_console'] + self.node['vbox_id'] - 1
707673
def add(self, ipaddr=None, proto=None, port=None, fields=None):
        
        return self.send.service_add(ipaddr, proto, port, fields)
1037372
public static vrid6 get(nitro_service service, Long id) throws Exception{
		vrid6 obj = new vrid6();
		obj.set_id(id);
		vrid6 response = (vrid6) obj.get_resource(service);
		return response;
	}