Release a given option

REST: DELETE /vps/{serviceName}/option/{option}
@param serviceName [required] The internal name of your VPS offer
@param option [required] The option name
339388
public void serviceName_option_option_DELETE(String serviceName, net.minidev.ovh.api.vps.OvhVpsOptionEnum option) throws IOException {
		String qPath = "/vps/{serviceName}/option/{option}";
		StringBuilder sb = path(qPath, serviceName, option);
		exec(qPath, "DELETE", sb.toString(), null);
	}
1050828
def delete(options = {})
      options = options.merge(
        user_name: @user_name,
        certificate_id: @id
      )
      resp = @client.delete_signing_certificate(options)
      resp.data
    end
427308
def remove_release(self, username, package_name, version):
        '''
        
        '''
        url = '%s/release/%s/%s/%s' % (self.domain, username, package_name, version)
        res = self.session.delete(url)
        self._check_response(res, [201])
        return
1181012
public static base_response delete(nitro_service client, String servicename) throws Exception {
		gslbservice deleteresource = new gslbservice();
		deleteresource.servicename = servicename;
		return deleteresource.delete_resource(client);
	}
864556
def delete(options = {})
      options = options.merge(subscription_name: @name)
      resp = @client.delete_event_subscription(options)
      EventSubscription.new(
        name: resp.data.event_subscription.cust_subscription_id,
        data: resp.data.event_subscription,
        client: @client
      )
    end
377917
def delete(options = {})
      options = options.merge(
        vault_name: @name,
        account_id: @account_id
      )
      resp = @client.delete_vault(options)
      resp.data
    end
758328
def del_option(self, section, option):
        
        if self.config.has_section(section):
            if self.config.has_option(section, option):
                self.config.remove_option(section, option)
                return (True, self.config.options(section))
            return (False, 'Option: ' + option + ' does not exist')
        return (False, 'Section: ' + section + ' does not exist')
233618
public OptionGroup removeOption(Option option) {
        if (option == null) {
            throw new IllegalArgumentException("Option cannot be null");
        }

        options.remove(option.getValue());
        return this;
    }
728672
def delete(options = {})
      options = options.merge(server_certificate_name: @name)
      resp = @client.delete_server_certificate(options)
      resp.data
    end
598739
public function removeOption(SwatOption $option)
    {
        $removed_option = null;

        foreach ($this->options as $key => $control_option) {
            if ($control_option === $option) {
                $removed_option = $control_option;

                // remove from options list
                unset($this->options[$key]);

                // remove metadata
                $key = $this->getOptionMetadataKey($control_option);
                unset($this->option_metadata[$key]);
            }
        }

        return $removed_option;
    }
688804
public void unregisterService(String serviceName, String providerId) {
        getServiceDirectoryClient().unregisterInstance(serviceName, providerId, disableOwnerError);
    }
203222
def delete(self, resource, resource_id):
        '''
        
        '''

        service_def, resource_def, path = self._get_service_information(
            resource)
        delete_path = "{0}{1}/" . format(path, resource_id)
        return self.call(path=delete_path, method="delete")
1133656
def delete_service(kwargs=None, conn=None, call=None):
    '''
    
    '''
    if call != 'function':
        raise SaltCloudSystemExit(
            'The delete_service function must be called with -f or --function.'
        )

    if kwargs is None:
        kwargs = {}

    if 'name' not in kwargs:
        raise SaltCloudSystemExit('A name must be specified as "name"')

    if not conn:
        conn = get_conn()

    try:
        conn.delete_hosted_service(kwargs['name'])
        return {'Success': 'The service was successfully deleted'}
    except AzureMissingResourceHttpError as exc:
        raise SaltCloudSystemExit('{0}: {1}'.format(kwargs['name'], exc.message))
680278
public static com.liferay.commerce.product.model.CPSpecificationOption deleteCPSpecificationOption(
		com.liferay.commerce.product.model.CPSpecificationOption cpSpecificationOption)
		throws com.liferay.portal.kernel.exception.PortalException {
		return getService().deleteCPSpecificationOption(cpSpecificationOption);
	}
1143806
def delete(options = {})
      options = options.merge(saml_provider_arn: @arn)
      resp = @client.delete_saml_provider(options)
      resp.data
    end
1210497
def del_option(self, option):
        
        assert isinstance(option, Option)
        while option in list(self._options):
            self._options.remove(option)
1204346
public function unsetOption($option)
    {
        if (!isset(static::$availableOptions[$option])) {
            throw new \InvalidArgumentException(sprintf(
                'Invalid option specified: "%s". Expected one of (%s)',
                $option,
                implode(', ', array_keys(static::$availableOptions))
            ));
        }
        $pos = array_search(static::$availableOptions[$option], $this->options, true);
        if (false !== $pos) {
            unset($this->options[$pos]);
        }
    }