Cancel call forwarding
Cancel call forwarding for the current agent.
@param cancelForwardBody Request parameters. (optional)
@return ApiSuccessResponse
@throws ApiException If fail to call the API, e.g. server error or cannot deserialize the response body
434544
public ApiSuccessResponse cancelForward(CancelForwardBody cancelForwardBody) throws ApiException {
        ApiResponse<ApiSuccessResponse> resp = cancelForwardWithHttpInfo(cancelForwardBody);
        return resp.getData();
    }
1200880
public ApiResponse<ApiSuccessResponse> modifyOutboundSettingsWithHttpInfo(ModifyOutboundData body) throws ApiException {
        com.squareup.okhttp.Call call = modifyOutboundSettingsValidateBeforeCall(body, null, null);
        Type localVarReturnType = new TypeToken<ApiSuccessResponse>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
499934
def delete_api_method_response(restApiId, resourcePath, httpMethod, statusCode,
                               region=None, key=None, keyid=None, profile=None):
    '''
    

    '''
    try:
        resource = describe_api_resource(restApiId, resourcePath, region=region,
                                         key=key, keyid=keyid, profile=profile).get('resource')
        if resource:
            conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
            conn.delete_method_response(restApiId=restApiId, resourceId=resource['id'],
                                        httpMethod=httpMethod, statusCode=str(statusCode))  # future lint: disable=blacklisted-function
            return {'deleted': True}
        return {'deleted': False, 'error': 'no such resource'}
    except ClientError as e:
        return {'deleted': False, 'error': __utils__['boto3.get_error'](e)}
985016
public ApiResponse<ApiSuccessResponse> modifyInboundSettingsWithHttpInfo(ModifyInboundData body) throws ApiException {
        com.squareup.okhttp.Call call = modifyInboundSettingsValidateBeforeCall(body, null, null);
        Type localVarReturnType = new TypeToken<ApiSuccessResponse>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
944334
public SubscriptionEnvelope deleteSubscription(String subId) throws ApiException {
        ApiResponse<SubscriptionEnvelope> resp = deleteSubscriptionWithHttpInfo(subId);
        return resp.getData();
    }
1127132
@Override
    public boolean cancel(boolean mayInterruptIfRunning) {
        if (!isInitialized()) {
            return internalFuture.cancel(mayInterruptIfRunning);
        }
        return synchronisationFuture.cancel(mayInterruptIfRunning) && internalFuture.cancel(mayInterruptIfRunning);
    }
1291109
public AzkabanClientStatus cancelFlow(String execId) throws AzkabanClientException {
    AzkabanMultiCallables.CancelFlowCallable callable =
        AzkabanMultiCallables.CancelFlowCallable.builder()
            .client(this)
            .execId(execId)
            .build();

    return runWithRetry(callable, AzkabanClientStatus.class);
  }
908411
public function cancel($identity, $params = array())
    {
        $path = Util::subUrl(
            '/mandate_imports/:identity/actions/cancel',
            array(
                
                'identity' => $identity
            )
        );
        if(isset($params['params'])) { 
            $params['body'] = json_encode(array("data" => (object)$params['params']));
        
            unset($params['params']);
        }

        
        try {
            $response = $this->api_client->post($path, $params);
        } catch(InvalidStateException $e) {
            if ($e->isIdempotentCreationConflict()) {
                return $this->get($e->getConflictingResourceId());
            }

            throw $e;
        }
        

        return $this->getResourceForResponse($response);
    }
312099
public ApiResponse<UserEnvelope> getSelfWithHttpInfo() throws ApiException {
        com.squareup.okhttp.Call call = getSelfValidateBeforeCall(null, null);
        Type localVarReturnType = new TypeToken<UserEnvelope>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
437607
public void cancel(ResponseCallback responseCallback) {
    // To avoid creating an extra message, we adopt the convention that writing the callback
    // directly means cancellation
    writeCoalescer.writeAndFlush(channel, responseCallback).addListener(UncaughtExceptions::log);
  }
1113173
public ApiResponse<Void> disconnectWithHttpInfo() throws ApiException {
        com.squareup.okhttp.Call call = disconnectValidateBeforeCall(null, null);
        return apiClient.execute(call);
    }
241705
protected <T> ServiceResponse<T> makeBackwardCompatibleHttpPostRequestAndCreateServiceResponse(String uri, Object body, Class<T> resultType, Map<String, String> headers) {
        logger.debug("About to send POST request to '{}' with payload '{}'", uri, body);
        KieServerHttpRequest request = newRequest( uri ).headers(headers).body(serialize( body )).post();
        KieServerHttpResponse response = request.response();

        owner.setConversationId(response.header(KieServerConstants.KIE_CONVERSATION_ID_TYPE_HEADER));

        if ( response.code() == Response.Status.OK.getStatusCode() ) {
            ServiceResponse serviceResponse = deserialize( response.body(), ServiceResponse.class );
            // serialize it back to string to make it backward compatible
            serviceResponse.setResult(serialize(serviceResponse.getResult()));
            checkResultType(serviceResponse, resultType);
            return serviceResponse;
        } else {
            throw createExceptionForUnexpectedResponseCode( request, response );
        }
    }
713283
def cancel_subscription(self, idempotency_key=None, **params):
        """"""
        warnings.warn(
            'The `cancel_subscription` method is deprecated. Instead, use the '
            '`subscriptions` resource on the customer object to cancel a '
            'subscription',
            DeprecationWarning)
        url = self.instance_url() + '/subscription'
        headers = populate_headers(idempotency_key)
        d = self.request('delete', url, params, headers)
        d.addCallback(lambda response: self.refresh_from(
            {'subscription': response}, api_key, True))
        return d.addCallback(lambda _: self.subscription)
255439
protected static function deleteCancelOperationByIdAsyncWithHttpInfo($cancel_operation_id) 
    {
        $returnType = '';  
        $request = self::deleteCancelOperationByIdRequest($cancel_operation_id); 

        return self::getHttpClient()
            ->sendAsync($request, self::createHttpClientOption())
            ->then(
                function ($response) use ($returnType) {
                    return [null, $response->getStatusCode(), $response->getHeaders()];
                },
                function ($exception) {
                    $response = $exception->getResponse();
                    $statusCode = $response->getStatusCode();
                    throw new ApiException(
                        sprintf(
                            '[%d] Error connecting to the API (%s)',
                            $statusCode,
                            $exception->getRequest()->getUri()
                        ),
                        $statusCode,
                        $response->getHeaders(),
                        $response->getBody()
                    );
                }
            );
    }
1289214
def cancel(self):
        """"""
        response = self.api_client._post(self.resource_path, 'cancel')
        return self.api_client._make_api_object(response, APIObject)
352220
public void forward(ServletRequest request, ServletResponse response)
			throws ServletException, IOException {
		if(request != null) {
			((SipServletRequest)request).getSession().setHandler(handler.getName());
		} else {
			((SipServletResponse)response).getSession().setHandler(handler.getName());
		}
		Servlet servlet = handler.allocate();
		servlet.service(request, response);
		handler.deallocate(servlet);
	}
1006249
public JsonResponse cancelSend(String sendId) throws IOException {
        Map<String, Object> data = new HashMap<String, Object>();
        data.put(Send.PARAM_SEND_ID, sendId);
        return apiDelete(ApiAction.send, data);
    }