import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcidenteTrabalhoApi;

import java.io.File;
import java.util.*;

public class AcidenteTrabalhoApiExample {

    public static void main(String[] args) {
        
        AcidenteTrabalhoApi apiInstance = new AcidenteTrabalhoApi();
        array[AcidenteTrabalho] acidentesTrabalho = ; // array[AcidenteTrabalho] | Acidentes de Trabalho.
        try {
            apiInstance.acidenteTrabalho(acidentesTrabalho);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcidenteTrabalhoApi#acidenteTrabalho");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AcidenteTrabalhoApi;

public class AcidenteTrabalhoApiExample {

    public static void main(String[] args) {
        AcidenteTrabalhoApi apiInstance = new AcidenteTrabalhoApi();
        array[AcidenteTrabalho] acidentesTrabalho = ; // array[AcidenteTrabalho] | Acidentes de Trabalho.
        try {
            apiInstance.acidenteTrabalho(acidentesTrabalho);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcidenteTrabalhoApi#acidenteTrabalho");
            e.printStackTrace();
        }
    }
}

array[AcidenteTrabalho] *acidentesTrabalho = ; // Acidentes de Trabalho.

AcidenteTrabalhoApi *apiInstance = [[AcidenteTrabalhoApi alloc] init];

// Informar acidente de trabalho
[apiInstance acidenteTrabalhoWith:acidentesTrabalho
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.AcidenteTrabalhoApi()

var acidentesTrabalho = ; // {array[AcidenteTrabalho]} Acidentes de Trabalho.


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.acidenteTrabalho(acidentesTrabalho, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class acidenteTrabalhoExample
    {
        public void main()
        {
            
            var apiInstance = new AcidenteTrabalhoApi();
            var acidentesTrabalho = new array[AcidenteTrabalho](); // array[AcidenteTrabalho] | Acidentes de Trabalho.

            try
            {
                // Informar acidente de trabalho
                apiInstance.acidenteTrabalho(acidentesTrabalho);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AcidenteTrabalhoApi.acidenteTrabalho: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AcidenteTrabalhoApi();
$acidentesTrabalho = ; // array[AcidenteTrabalho] | Acidentes de Trabalho.

try {
    $api_instance->acidenteTrabalho($acidentesTrabalho);
} catch (Exception $e) {
    echo 'Exception when calling AcidenteTrabalhoApi->acidenteTrabalho: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcidenteTrabalhoApi;

my $api_instance = WWW::SwaggerClient::AcidenteTrabalhoApi->new();
my $acidentesTrabalho = [WWW::SwaggerClient::Object::array[AcidenteTrabalho]->new()]; # array[AcidenteTrabalho] | Acidentes de Trabalho.

eval { 
    $api_instance->acidenteTrabalho(acidentesTrabalho => $acidentesTrabalho);
};
if ($@) {
    warn "Exception when calling AcidenteTrabalhoApi->acidenteTrabalho: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AcidenteTrabalhoApi()
acidentesTrabalho =  # array[AcidenteTrabalho] | Acidentes de Trabalho.

try: 
    # Informar acidente de trabalho
    api_instance.acidente_trabalho(acidentesTrabalho)
except ApiException as e:
    print("Exception when calling AcidenteTrabalhoApi->acidenteTrabalho: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AmbienteApi;

import java.io.File;
import java.util.*;

public class AmbienteApiExample {

    public static void main(String[] args) {
        
        AmbienteApi apiInstance = new AmbienteApi();
        try {
            array[Ambiente] result = apiInstance.retornarAmbientes();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AmbienteApi#retornarAmbientes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AmbienteApi;

public class AmbienteApiExample {

    public static void main(String[] args) {
        AmbienteApi apiInstance = new AmbienteApi();
        try {
            array[Ambiente] result = apiInstance.retornarAmbientes();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AmbienteApi#retornarAmbientes");
            e.printStackTrace();
        }
    }
}

AmbienteApi *apiInstance = [[AmbienteApi alloc] init];

// Retornar todos os ambientes de trabalho
[apiInstance retornarAmbientesWithCompletionHandler: 
              ^(array[Ambiente] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.AmbienteApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarAmbientes(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarAmbientesExample
    {
        public void main()
        {
            
            var apiInstance = new AmbienteApi();

            try
            {
                // Retornar todos os ambientes de trabalho
                array[Ambiente] result = apiInstance.retornarAmbientes();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AmbienteApi.retornarAmbientes: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AmbienteApi();

try {
    $result = $api_instance->retornarAmbientes();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AmbienteApi->retornarAmbientes: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AmbienteApi;

my $api_instance = WWW::SwaggerClient::AmbienteApi->new();

eval { 
    my $result = $api_instance->retornarAmbientes();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AmbienteApi->retornarAmbientes: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AmbienteApi()

try: 
    # Retornar todos os ambientes de trabalho
    api_response = api_instance.retornar_ambientes()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AmbienteApi->retornarAmbientes: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AmbienteApi;

import java.io.File;
import java.util.*;

public class AmbienteApiExample {

    public static void main(String[] args) {
        
        AmbienteApi apiInstance = new AmbienteApi();
        Integer codigoAmbiente = 56; // Integer | 
        try {
            array[Ambiente] result = apiInstance.retornarAmbientesPorCodigo(codigoAmbiente);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AmbienteApi#retornarAmbientesPorCodigo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AmbienteApi;

public class AmbienteApiExample {

    public static void main(String[] args) {
        AmbienteApi apiInstance = new AmbienteApi();
        Integer codigoAmbiente = 56; // Integer | 
        try {
            array[Ambiente] result = apiInstance.retornarAmbientesPorCodigo(codigoAmbiente);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AmbienteApi#retornarAmbientesPorCodigo");
            e.printStackTrace();
        }
    }
}

Integer *codigoAmbiente = 56; // 

AmbienteApi *apiInstance = [[AmbienteApi alloc] init];

// Retornar ambiente de trabalho por Código
[apiInstance retornarAmbientesPorCodigoWith:codigoAmbiente
              completionHandler: ^(array[Ambiente] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.AmbienteApi()

var codigoAmbiente = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarAmbientesPorCodigo(codigoAmbiente, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarAmbientesPorCodigoExample
    {
        public void main()
        {
            
            var apiInstance = new AmbienteApi();
            var codigoAmbiente = 56;  // Integer | 

            try
            {
                // Retornar ambiente de trabalho por Código
                array[Ambiente] result = apiInstance.retornarAmbientesPorCodigo(codigoAmbiente);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AmbienteApi.retornarAmbientesPorCodigo: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AmbienteApi();
$codigoAmbiente = 56; // Integer | 

try {
    $result = $api_instance->retornarAmbientesPorCodigo($codigoAmbiente);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AmbienteApi->retornarAmbientesPorCodigo: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AmbienteApi;

my $api_instance = WWW::SwaggerClient::AmbienteApi->new();
my $codigoAmbiente = 56; # Integer | 

eval { 
    my $result = $api_instance->retornarAmbientesPorCodigo(codigoAmbiente => $codigoAmbiente);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AmbienteApi->retornarAmbientesPorCodigo: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AmbienteApi()
codigoAmbiente = 56 # Integer | 

try: 
    # Retornar ambiente de trabalho por Código
    api_response = api_instance.retornar_ambientes_por_codigo(codigoAmbiente)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AmbienteApi->retornarAmbientesPorCodigo: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AmbienteApi;

import java.io.File;
import java.util.*;

public class AmbienteApiExample {

    public static void main(String[] args) {
        
        AmbienteApi apiInstance = new AmbienteApi();
        String nomeAmbiente = nomeAmbiente_example; // String | 
        try {
            array[Ambiente] result = apiInstance.retornarAmbientesPorNome(nomeAmbiente);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AmbienteApi#retornarAmbientesPorNome");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AmbienteApi;

public class AmbienteApiExample {

    public static void main(String[] args) {
        AmbienteApi apiInstance = new AmbienteApi();
        String nomeAmbiente = nomeAmbiente_example; // String | 
        try {
            array[Ambiente] result = apiInstance.retornarAmbientesPorNome(nomeAmbiente);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AmbienteApi#retornarAmbientesPorNome");
            e.printStackTrace();
        }
    }
}

String *nomeAmbiente = nomeAmbiente_example; // 

AmbienteApi *apiInstance = [[AmbienteApi alloc] init];

// Retornar ambiente de trabalho pelo Nome
[apiInstance retornarAmbientesPorNomeWith:nomeAmbiente
              completionHandler: ^(array[Ambiente] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.AmbienteApi()

var nomeAmbiente = nomeAmbiente_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarAmbientesPorNome(nomeAmbiente, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarAmbientesPorNomeExample
    {
        public void main()
        {
            
            var apiInstance = new AmbienteApi();
            var nomeAmbiente = nomeAmbiente_example;  // String | 

            try
            {
                // Retornar ambiente de trabalho pelo Nome
                array[Ambiente] result = apiInstance.retornarAmbientesPorNome(nomeAmbiente);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AmbienteApi.retornarAmbientesPorNome: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AmbienteApi();
$nomeAmbiente = nomeAmbiente_example; // String | 

try {
    $result = $api_instance->retornarAmbientesPorNome($nomeAmbiente);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AmbienteApi->retornarAmbientesPorNome: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AmbienteApi;

my $api_instance = WWW::SwaggerClient::AmbienteApi->new();
my $nomeAmbiente = nomeAmbiente_example; # String | 

eval { 
    my $result = $api_instance->retornarAmbientesPorNome(nomeAmbiente => $nomeAmbiente);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AmbienteApi->retornarAmbientesPorNome: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AmbienteApi()
nomeAmbiente = nomeAmbiente_example # String | 

try: 
    # Retornar ambiente de trabalho pelo Nome
    api_response = api_instance.retornar_ambientes_por_nome(nomeAmbiente)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AmbienteApi->retornarAmbientesPorNome: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CRMApi;

import java.io.File;
import java.util.*;

public class CRMApiExample {

    public static void main(String[] args) {
        
        CRMApi apiInstance = new CRMApi();
        try {
            array[CRM] result = apiInstance.retornarCRM();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CRMApi#retornarCRM");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CRMApi;

public class CRMApiExample {

    public static void main(String[] args) {
        CRMApi apiInstance = new CRMApi();
        try {
            array[CRM] result = apiInstance.retornarCRM();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CRMApi#retornarCRM");
            e.printStackTrace();
        }
    }
}

CRMApi *apiInstance = [[CRMApi alloc] init];

// Retornar todos os registros de CRM
[apiInstance retornarCRMWithCompletionHandler: 
              ^(array[CRM] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.CRMApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarCRM(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarCRMExample
    {
        public void main()
        {
            
            var apiInstance = new CRMApi();

            try
            {
                // Retornar todos os registros de CRM
                array[CRM] result = apiInstance.retornarCRM();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CRMApi.retornarCRM: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\CRMApi();

try {
    $result = $api_instance->retornarCRM();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CRMApi->retornarCRM: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CRMApi;

my $api_instance = WWW::SwaggerClient::CRMApi->new();

eval { 
    my $result = $api_instance->retornarCRM();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CRMApi->retornarCRM: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CRMApi()

try: 
    # Retornar todos os registros de CRM
    api_response = api_instance.retornar_crm()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CRMApi->retornarCRM: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CRMApi;

import java.io.File;
import java.util.*;

public class CRMApiExample {

    public static void main(String[] args) {
        
        CRMApi apiInstance = new CRMApi();
        String cRM = cRM_example; // String | 
        String uF = uF_example; // String | 
        try {
            array[CRM] result = apiInstance.retornarCRMPorCodigoComUf(cRM, uF);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CRMApi#retornarCRMPorCodigoComUf");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CRMApi;

public class CRMApiExample {

    public static void main(String[] args) {
        CRMApi apiInstance = new CRMApi();
        String cRM = cRM_example; // String | 
        String uF = uF_example; // String | 
        try {
            array[CRM] result = apiInstance.retornarCRMPorCodigoComUf(cRM, uF);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CRMApi#retornarCRMPorCodigoComUf");
            e.printStackTrace();
        }
    }
}

String *cRM = cRM_example; // 
String *uF = uF_example; // 

CRMApi *apiInstance = [[CRMApi alloc] init];

// Retornar médicos por CRM e UF
[apiInstance retornarCRMPorCodigoComUfWith:cRM
    uF:uF
              completionHandler: ^(array[CRM] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.CRMApi()

var cRM = cRM_example; // {String} 

var uF = uF_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarCRMPorCodigoComUf(cRM, uF, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarCRMPorCodigoComUfExample
    {
        public void main()
        {
            
            var apiInstance = new CRMApi();
            var cRM = cRM_example;  // String | 
            var uF = uF_example;  // String | 

            try
            {
                // Retornar médicos por CRM e UF
                array[CRM] result = apiInstance.retornarCRMPorCodigoComUf(cRM, uF);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CRMApi.retornarCRMPorCodigoComUf: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\CRMApi();
$cRM = cRM_example; // String | 
$uF = uF_example; // String | 

try {
    $result = $api_instance->retornarCRMPorCodigoComUf($cRM, $uF);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CRMApi->retornarCRMPorCodigoComUf: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CRMApi;

my $api_instance = WWW::SwaggerClient::CRMApi->new();
my $cRM = cRM_example; # String | 
my $uF = uF_example; # String | 

eval { 
    my $result = $api_instance->retornarCRMPorCodigoComUf(cRM => $cRM, uF => $uF);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CRMApi->retornarCRMPorCodigoComUf: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CRMApi()
cRM = cRM_example # String | 
uF = uF_example # String | 

try: 
    # Retornar médicos por CRM e UF
    api_response = api_instance.retornar_crm_por_codigo_com_uf(cRM, uF)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CRMApi->retornarCRMPorCodigoComUf: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CRMApi;

import java.io.File;
import java.util.*;

public class CRMApiExample {

    public static void main(String[] args) {
        
        CRMApi apiInstance = new CRMApi();
        Integer codigoInternoCRM = 56; // Integer | 
        try {
            array[CRM] result = apiInstance.retornarCRMPorId(codigoInternoCRM);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CRMApi#retornarCRMPorId");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CRMApi;

public class CRMApiExample {

    public static void main(String[] args) {
        CRMApi apiInstance = new CRMApi();
        Integer codigoInternoCRM = 56; // Integer | 
        try {
            array[CRM] result = apiInstance.retornarCRMPorId(codigoInternoCRM);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CRMApi#retornarCRMPorId");
            e.printStackTrace();
        }
    }
}

Integer *codigoInternoCRM = 56; // 

CRMApi *apiInstance = [[CRMApi alloc] init];

// Retornar o cadastro de CRM pelo ID
[apiInstance retornarCRMPorIdWith:codigoInternoCRM
              completionHandler: ^(array[CRM] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.CRMApi()

var codigoInternoCRM = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarCRMPorId(codigoInternoCRM, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarCRMPorIdExample
    {
        public void main()
        {
            
            var apiInstance = new CRMApi();
            var codigoInternoCRM = 56;  // Integer | 

            try
            {
                // Retornar o cadastro de CRM pelo ID
                array[CRM] result = apiInstance.retornarCRMPorId(codigoInternoCRM);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CRMApi.retornarCRMPorId: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\CRMApi();
$codigoInternoCRM = 56; // Integer | 

try {
    $result = $api_instance->retornarCRMPorId($codigoInternoCRM);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CRMApi->retornarCRMPorId: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CRMApi;

my $api_instance = WWW::SwaggerClient::CRMApi->new();
my $codigoInternoCRM = 56; # Integer | 

eval { 
    my $result = $api_instance->retornarCRMPorId(codigoInternoCRM => $codigoInternoCRM);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CRMApi->retornarCRMPorId: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CRMApi()
codigoInternoCRM = 56 # Integer | 

try: 
    # Retornar o cadastro de CRM pelo ID
    api_response = api_instance.retornar_crm_por_id(codigoInternoCRM)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CRMApi->retornarCRMPorId: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CRMApi;

import java.io.File;
import java.util.*;

public class CRMApiExample {

    public static void main(String[] args) {
        
        CRMApi apiInstance = new CRMApi();
        String nomeMedico = nomeMedico_example; // String | 
        try {
            array[CRM] result = apiInstance.retornarCRMPorNome(nomeMedico);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CRMApi#retornarCRMPorNome");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CRMApi;

public class CRMApiExample {

    public static void main(String[] args) {
        CRMApi apiInstance = new CRMApi();
        String nomeMedico = nomeMedico_example; // String | 
        try {
            array[CRM] result = apiInstance.retornarCRMPorNome(nomeMedico);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CRMApi#retornarCRMPorNome");
            e.printStackTrace();
        }
    }
}

String *nomeMedico = nomeMedico_example; // 

CRMApi *apiInstance = [[CRMApi alloc] init];

// Retornar CRM pelo nome do medico
[apiInstance retornarCRMPorNomeWith:nomeMedico
              completionHandler: ^(array[CRM] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.CRMApi()

var nomeMedico = nomeMedico_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarCRMPorNome(nomeMedico, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarCRMPorNomeExample
    {
        public void main()
        {
            
            var apiInstance = new CRMApi();
            var nomeMedico = nomeMedico_example;  // String | 

            try
            {
                // Retornar CRM pelo nome do medico
                array[CRM] result = apiInstance.retornarCRMPorNome(nomeMedico);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CRMApi.retornarCRMPorNome: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\CRMApi();
$nomeMedico = nomeMedico_example; // String | 

try {
    $result = $api_instance->retornarCRMPorNome($nomeMedico);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CRMApi->retornarCRMPorNome: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CRMApi;

my $api_instance = WWW::SwaggerClient::CRMApi->new();
my $nomeMedico = nomeMedico_example; # String | 

eval { 
    my $result = $api_instance->retornarCRMPorNome(nomeMedico => $nomeMedico);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CRMApi->retornarCRMPorNome: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CRMApi()
nomeMedico = nomeMedico_example # String | 

try: 
    # Retornar CRM pelo nome do medico
    api_response = api_instance.retornar_crm_por_nome(nomeMedico)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CRMApi->retornarCRMPorNome: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CondicoesAmbientaisTrabalhoApi;

import java.io.File;
import java.util.*;

public class CondicoesAmbientaisTrabalhoApiExample {

    public static void main(String[] args) {
        
        CondicoesAmbientaisTrabalhoApi apiInstance = new CondicoesAmbientaisTrabalhoApi();
        array[CondicoesAmbientaisTrabalho] condicoesAmbientaisTrabalho = ; // array[CondicoesAmbientaisTrabalho] | Condições Ambientais de Trabalho.
        try {
            apiInstance.condicoesAmbientaisTrabalho(condicoesAmbientaisTrabalho);
        } catch (ApiException e) {
            System.err.println("Exception when calling CondicoesAmbientaisTrabalhoApi#condicoesAmbientaisTrabalho");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CondicoesAmbientaisTrabalhoApi;

public class CondicoesAmbientaisTrabalhoApiExample {

    public static void main(String[] args) {
        CondicoesAmbientaisTrabalhoApi apiInstance = new CondicoesAmbientaisTrabalhoApi();
        array[CondicoesAmbientaisTrabalho] condicoesAmbientaisTrabalho = ; // array[CondicoesAmbientaisTrabalho] | Condições Ambientais de Trabalho.
        try {
            apiInstance.condicoesAmbientaisTrabalho(condicoesAmbientaisTrabalho);
        } catch (ApiException e) {
            System.err.println("Exception when calling CondicoesAmbientaisTrabalhoApi#condicoesAmbientaisTrabalho");
            e.printStackTrace();
        }
    }
}

array[CondicoesAmbientaisTrabalho] *condicoesAmbientaisTrabalho = ; // Condições Ambientais de Trabalho.

CondicoesAmbientaisTrabalhoApi *apiInstance = [[CondicoesAmbientaisTrabalhoApi alloc] init];

// Informar exame toxicolágico.
[apiInstance condicoesAmbientaisTrabalhoWith:condicoesAmbientaisTrabalho
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.CondicoesAmbientaisTrabalhoApi()

var condicoesAmbientaisTrabalho = ; // {array[CondicoesAmbientaisTrabalho]} Condições Ambientais de Trabalho.


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.condicoesAmbientaisTrabalho(condicoesAmbientaisTrabalho, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class condicoesAmbientaisTrabalhoExample
    {
        public void main()
        {
            
            var apiInstance = new CondicoesAmbientaisTrabalhoApi();
            var condicoesAmbientaisTrabalho = new array[CondicoesAmbientaisTrabalho](); // array[CondicoesAmbientaisTrabalho] | Condições Ambientais de Trabalho.

            try
            {
                // Informar exame toxicolágico.
                apiInstance.condicoesAmbientaisTrabalho(condicoesAmbientaisTrabalho);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CondicoesAmbientaisTrabalhoApi.condicoesAmbientaisTrabalho: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\CondicoesAmbientaisTrabalhoApi();
$condicoesAmbientaisTrabalho = ; // array[CondicoesAmbientaisTrabalho] | Condições Ambientais de Trabalho.

try {
    $api_instance->condicoesAmbientaisTrabalho($condicoesAmbientaisTrabalho);
} catch (Exception $e) {
    echo 'Exception when calling CondicoesAmbientaisTrabalhoApi->condicoesAmbientaisTrabalho: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CondicoesAmbientaisTrabalhoApi;

my $api_instance = WWW::SwaggerClient::CondicoesAmbientaisTrabalhoApi->new();
my $condicoesAmbientaisTrabalho = [WWW::SwaggerClient::Object::array[CondicoesAmbientaisTrabalho]->new()]; # array[CondicoesAmbientaisTrabalho] | Condições Ambientais de Trabalho.

eval { 
    $api_instance->condicoesAmbientaisTrabalho(condicoesAmbientaisTrabalho => $condicoesAmbientaisTrabalho);
};
if ($@) {
    warn "Exception when calling CondicoesAmbientaisTrabalhoApi->condicoesAmbientaisTrabalho: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CondicoesAmbientaisTrabalhoApi()
condicoesAmbientaisTrabalho =  # array[CondicoesAmbientaisTrabalho] | Condições Ambientais de Trabalho.

try: 
    # Informar exame toxicolágico.
    api_instance.condicoes_ambientais_trabalho(condicoesAmbientaisTrabalho)
except ApiException as e:
    print("Exception when calling CondicoesAmbientaisTrabalhoApi->condicoesAmbientaisTrabalho: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExameToxicologicoApi;

import java.io.File;
import java.util.*;

public class ExameToxicologicoApiExample {

    public static void main(String[] args) {
        
        ExameToxicologicoApi apiInstance = new ExameToxicologicoApi();
        array[ExameToxicologico] exameToxicologico = ; // array[ExameToxicologico] | Monitoramento da Saúdo do Trabalhador.
        try {
            apiInstance.exameToxicologico(exameToxicologico);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExameToxicologicoApi#exameToxicologico");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ExameToxicologicoApi;

public class ExameToxicologicoApiExample {

    public static void main(String[] args) {
        ExameToxicologicoApi apiInstance = new ExameToxicologicoApi();
        array[ExameToxicologico] exameToxicologico = ; // array[ExameToxicologico] | Monitoramento da Saúdo do Trabalhador.
        try {
            apiInstance.exameToxicologico(exameToxicologico);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExameToxicologicoApi#exameToxicologico");
            e.printStackTrace();
        }
    }
}

array[ExameToxicologico] *exameToxicologico = ; // Monitoramento da Saúdo do Trabalhador.

ExameToxicologicoApi *apiInstance = [[ExameToxicologicoApi alloc] init];

// Informar exame toxicolágico.
[apiInstance exameToxicologicoWith:exameToxicologico
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.ExameToxicologicoApi()

var exameToxicologico = ; // {array[ExameToxicologico]} Monitoramento da Saúdo do Trabalhador.


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.exameToxicologico(exameToxicologico, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class exameToxicologicoExample
    {
        public void main()
        {
            
            var apiInstance = new ExameToxicologicoApi();
            var exameToxicologico = new array[ExameToxicologico](); // array[ExameToxicologico] | Monitoramento da Saúdo do Trabalhador.

            try
            {
                // Informar exame toxicolágico.
                apiInstance.exameToxicologico(exameToxicologico);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExameToxicologicoApi.exameToxicologico: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ExameToxicologicoApi();
$exameToxicologico = ; // array[ExameToxicologico] | Monitoramento da Saúdo do Trabalhador.

try {
    $api_instance->exameToxicologico($exameToxicologico);
} catch (Exception $e) {
    echo 'Exception when calling ExameToxicologicoApi->exameToxicologico: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExameToxicologicoApi;

my $api_instance = WWW::SwaggerClient::ExameToxicologicoApi->new();
my $exameToxicologico = [WWW::SwaggerClient::Object::array[ExameToxicologico]->new()]; # array[ExameToxicologico] | Monitoramento da Saúdo do Trabalhador.

eval { 
    $api_instance->exameToxicologico(exameToxicologico => $exameToxicologico);
};
if ($@) {
    warn "Exception when calling ExameToxicologicoApi->exameToxicologico: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ExameToxicologicoApi()
exameToxicologico =  # array[ExameToxicologico] | Monitoramento da Saúdo do Trabalhador.

try: 
    # Informar exame toxicolágico.
    api_instance.exame_toxicologico(exameToxicologico)
except ApiException as e:
    print("Exception when calling ExameToxicologicoApi->exameToxicologico: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncaoApi;

import java.io.File;
import java.util.*;

public class FuncaoApiExample {

    public static void main(String[] args) {
        
        FuncaoApi apiInstance = new FuncaoApi();
        try {
            array[Funcao] result = apiInstance.retornarFuncao();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncaoApi#retornarFuncao");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncaoApi;

public class FuncaoApiExample {

    public static void main(String[] args) {
        FuncaoApi apiInstance = new FuncaoApi();
        try {
            array[Funcao] result = apiInstance.retornarFuncao();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncaoApi#retornarFuncao");
            e.printStackTrace();
        }
    }
}

FuncaoApi *apiInstance = [[FuncaoApi alloc] init];

// Retornar todas as funções
[apiInstance retornarFuncaoWithCompletionHandler: 
              ^(array[Funcao] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncaoApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarFuncao(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarFuncaoExample
    {
        public void main()
        {
            
            var apiInstance = new FuncaoApi();

            try
            {
                // Retornar todas as funções
                array[Funcao] result = apiInstance.retornarFuncao();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncaoApi.retornarFuncao: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncaoApi();

try {
    $result = $api_instance->retornarFuncao();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncaoApi->retornarFuncao: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncaoApi;

my $api_instance = WWW::SwaggerClient::FuncaoApi->new();

eval { 
    my $result = $api_instance->retornarFuncao();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncaoApi->retornarFuncao: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncaoApi()

try: 
    # Retornar todas as funções
    api_response = api_instance.retornar_funcao()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncaoApi->retornarFuncao: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncaoApi;

import java.io.File;
import java.util.*;

public class FuncaoApiExample {

    public static void main(String[] args) {
        
        FuncaoApi apiInstance = new FuncaoApi();
        Integer codigoFuncao = 56; // Integer | 
        try {
            array[Funcao] result = apiInstance.retornarFuncaoPorCodigo(codigoFuncao);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncaoApi#retornarFuncaoPorCodigo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncaoApi;

public class FuncaoApiExample {

    public static void main(String[] args) {
        FuncaoApi apiInstance = new FuncaoApi();
        Integer codigoFuncao = 56; // Integer | 
        try {
            array[Funcao] result = apiInstance.retornarFuncaoPorCodigo(codigoFuncao);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncaoApi#retornarFuncaoPorCodigo");
            e.printStackTrace();
        }
    }
}

Integer *codigoFuncao = 56; // 

FuncaoApi *apiInstance = [[FuncaoApi alloc] init];

// Retornar função pelo Código.
[apiInstance retornarFuncaoPorCodigoWith:codigoFuncao
              completionHandler: ^(array[Funcao] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncaoApi()

var codigoFuncao = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarFuncaoPorCodigo(codigoFuncao, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarFuncaoPorCodigoExample
    {
        public void main()
        {
            
            var apiInstance = new FuncaoApi();
            var codigoFuncao = 56;  // Integer | 

            try
            {
                // Retornar função pelo Código.
                array[Funcao] result = apiInstance.retornarFuncaoPorCodigo(codigoFuncao);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncaoApi.retornarFuncaoPorCodigo: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncaoApi();
$codigoFuncao = 56; // Integer | 

try {
    $result = $api_instance->retornarFuncaoPorCodigo($codigoFuncao);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncaoApi->retornarFuncaoPorCodigo: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncaoApi;

my $api_instance = WWW::SwaggerClient::FuncaoApi->new();
my $codigoFuncao = 56; # Integer | 

eval { 
    my $result = $api_instance->retornarFuncaoPorCodigo(codigoFuncao => $codigoFuncao);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncaoApi->retornarFuncaoPorCodigo: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncaoApi()
codigoFuncao = 56 # Integer | 

try: 
    # Retornar função pelo Código.
    api_response = api_instance.retornar_funcao_por_codigo(codigoFuncao)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncaoApi->retornarFuncaoPorCodigo: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncaoApi;

import java.io.File;
import java.util.*;

public class FuncaoApiExample {

    public static void main(String[] args) {
        
        FuncaoApi apiInstance = new FuncaoApi();
        String codigoCBO = codigoCBO_example; // String | 
        try {
            array[Funcao] result = apiInstance.retornarFuncaoPorCodigoCBO(codigoCBO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncaoApi#retornarFuncaoPorCodigoCBO");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncaoApi;

public class FuncaoApiExample {

    public static void main(String[] args) {
        FuncaoApi apiInstance = new FuncaoApi();
        String codigoCBO = codigoCBO_example; // String | 
        try {
            array[Funcao] result = apiInstance.retornarFuncaoPorCodigoCBO(codigoCBO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncaoApi#retornarFuncaoPorCodigoCBO");
            e.printStackTrace();
        }
    }
}

String *codigoCBO = codigoCBO_example; // 

FuncaoApi *apiInstance = [[FuncaoApi alloc] init];

// Retornar função pelo Código CBO
[apiInstance retornarFuncaoPorCodigoCBOWith:codigoCBO
              completionHandler: ^(array[Funcao] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncaoApi()

var codigoCBO = codigoCBO_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarFuncaoPorCodigoCBO(codigoCBO, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarFuncaoPorCodigoCBOExample
    {
        public void main()
        {
            
            var apiInstance = new FuncaoApi();
            var codigoCBO = codigoCBO_example;  // String | 

            try
            {
                // Retornar função pelo Código CBO
                array[Funcao] result = apiInstance.retornarFuncaoPorCodigoCBO(codigoCBO);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncaoApi.retornarFuncaoPorCodigoCBO: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncaoApi();
$codigoCBO = codigoCBO_example; // String | 

try {
    $result = $api_instance->retornarFuncaoPorCodigoCBO($codigoCBO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncaoApi->retornarFuncaoPorCodigoCBO: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncaoApi;

my $api_instance = WWW::SwaggerClient::FuncaoApi->new();
my $codigoCBO = codigoCBO_example; # String | 

eval { 
    my $result = $api_instance->retornarFuncaoPorCodigoCBO(codigoCBO => $codigoCBO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncaoApi->retornarFuncaoPorCodigoCBO: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncaoApi()
codigoCBO = codigoCBO_example # String | 

try: 
    # Retornar função pelo Código CBO
    api_response = api_instance.retornar_funcao_por_codigo_cbo(codigoCBO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncaoApi->retornarFuncaoPorCodigoCBO: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncaoApi;

import java.io.File;
import java.util.*;

public class FuncaoApiExample {

    public static void main(String[] args) {
        
        FuncaoApi apiInstance = new FuncaoApi();
        String descricaoFuncao = descricaoFuncao_example; // String | 
        try {
            array[Funcao] result = apiInstance.retornarFuncaoPorDescricao(descricaoFuncao);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncaoApi#retornarFuncaoPorDescricao");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncaoApi;

public class FuncaoApiExample {

    public static void main(String[] args) {
        FuncaoApi apiInstance = new FuncaoApi();
        String descricaoFuncao = descricaoFuncao_example; // String | 
        try {
            array[Funcao] result = apiInstance.retornarFuncaoPorDescricao(descricaoFuncao);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncaoApi#retornarFuncaoPorDescricao");
            e.printStackTrace();
        }
    }
}

String *descricaoFuncao = descricaoFuncao_example; // 

FuncaoApi *apiInstance = [[FuncaoApi alloc] init];

// Retornar função pela descrição
[apiInstance retornarFuncaoPorDescricaoWith:descricaoFuncao
              completionHandler: ^(array[Funcao] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncaoApi()

var descricaoFuncao = descricaoFuncao_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarFuncaoPorDescricao(descricaoFuncao, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarFuncaoPorDescricaoExample
    {
        public void main()
        {
            
            var apiInstance = new FuncaoApi();
            var descricaoFuncao = descricaoFuncao_example;  // String | 

            try
            {
                // Retornar função pela descrição
                array[Funcao] result = apiInstance.retornarFuncaoPorDescricao(descricaoFuncao);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncaoApi.retornarFuncaoPorDescricao: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncaoApi();
$descricaoFuncao = descricaoFuncao_example; // String | 

try {
    $result = $api_instance->retornarFuncaoPorDescricao($descricaoFuncao);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncaoApi->retornarFuncaoPorDescricao: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncaoApi;

my $api_instance = WWW::SwaggerClient::FuncaoApi->new();
my $descricaoFuncao = descricaoFuncao_example; # String | 

eval { 
    my $result = $api_instance->retornarFuncaoPorDescricao(descricaoFuncao => $descricaoFuncao);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncaoApi->retornarFuncaoPorDescricao: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncaoApi()
descricaoFuncao = descricaoFuncao_example # String | 

try: 
    # Retornar função pela descrição
    api_response = api_instance.retornar_funcao_por_descricao(descricaoFuncao)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncaoApi->retornarFuncaoPorDescricao: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncionarioApi;

import java.io.File;
import java.util.*;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        
        FuncionarioApi apiInstance = new FuncionarioApi();
        String cpf = cpf_example; // String | 
        try {
            array[Funcionario] result = apiInstance.retornarFuncionarioPorCpf(cpf);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionarioPorCpf");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncionarioApi;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        FuncionarioApi apiInstance = new FuncionarioApi();
        String cpf = cpf_example; // String | 
        try {
            array[Funcionario] result = apiInstance.retornarFuncionarioPorCpf(cpf);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionarioPorCpf");
            e.printStackTrace();
        }
    }
}

String *cpf = cpf_example; // 

FuncionarioApi *apiInstance = [[FuncionarioApi alloc] init];

// Retorna funcionario por CPF
[apiInstance retornarFuncionarioPorCpfWith:cpf
              completionHandler: ^(array[Funcionario] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncionarioApi()

var cpf = cpf_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarFuncionarioPorCpf(cpf, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarFuncionarioPorCpfExample
    {
        public void main()
        {
            
            var apiInstance = new FuncionarioApi();
            var cpf = cpf_example;  // String | 

            try
            {
                // Retorna funcionario por CPF
                array[Funcionario] result = apiInstance.retornarFuncionarioPorCpf(cpf);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncionarioApi.retornarFuncionarioPorCpf: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncionarioApi();
$cpf = cpf_example; // String | 

try {
    $result = $api_instance->retornarFuncionarioPorCpf($cpf);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncionarioApi->retornarFuncionarioPorCpf: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncionarioApi;

my $api_instance = WWW::SwaggerClient::FuncionarioApi->new();
my $cpf = cpf_example; # String | 

eval { 
    my $result = $api_instance->retornarFuncionarioPorCpf(cpf => $cpf);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncionarioApi->retornarFuncionarioPorCpf: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncionarioApi()
cpf = cpf_example # String | 

try: 
    # Retorna funcionario por CPF
    api_response = api_instance.retornar_funcionario_por_cpf(cpf)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncionarioApi->retornarFuncionarioPorCpf: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncionarioApi;

import java.io.File;
import java.util.*;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        
        FuncionarioApi apiInstance = new FuncionarioApi();
        try {
            array[Funcionario] result = apiInstance.retornarFuncionarios();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionarios");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncionarioApi;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        FuncionarioApi apiInstance = new FuncionarioApi();
        try {
            array[Funcionario] result = apiInstance.retornarFuncionarios();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionarios");
            e.printStackTrace();
        }
    }
}

FuncionarioApi *apiInstance = [[FuncionarioApi alloc] init];

// Retornar todos os funcionarios
[apiInstance retornarFuncionariosWithCompletionHandler: 
              ^(array[Funcionario] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncionarioApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarFuncionarios(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarFuncionariosExample
    {
        public void main()
        {
            
            var apiInstance = new FuncionarioApi();

            try
            {
                // Retornar todos os funcionarios
                array[Funcionario] result = apiInstance.retornarFuncionarios();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncionarioApi.retornarFuncionarios: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncionarioApi();

try {
    $result = $api_instance->retornarFuncionarios();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncionarioApi->retornarFuncionarios: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncionarioApi;

my $api_instance = WWW::SwaggerClient::FuncionarioApi->new();

eval { 
    my $result = $api_instance->retornarFuncionarios();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncionarioApi->retornarFuncionarios: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncionarioApi()

try: 
    # Retornar todos os funcionarios
    api_response = api_instance.retornar_funcionarios()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncionarioApi->retornarFuncionarios: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncionarioApi;

import java.io.File;
import java.util.*;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[FuncionariosAdmitidos] result = apiInstance.retornarFuncionariosAdmitidosPorPeriodo(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionariosAdmitidosPorPeriodo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncionarioApi;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[FuncionariosAdmitidos] result = apiInstance.retornarFuncionariosAdmitidosPorPeriodo(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionariosAdmitidosPorPeriodo");
            e.printStackTrace();
        }
    }
}

date *dtIni = 2013-10-20; // 
date *dtFim = 2013-10-20; // 

FuncionarioApi *apiInstance = [[FuncionarioApi alloc] init];

// Retorna funcionario admitido por periodo
[apiInstance retornarFuncionariosAdmitidosPorPeriodoWith:dtIni
    dtFim:dtFim
              completionHandler: ^(array[FuncionariosAdmitidos] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncionarioApi()

var dtIni = 2013-10-20; // {date} 

var dtFim = 2013-10-20; // {date} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarFuncionariosAdmitidosPorPeriodo(dtIni, dtFim, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarFuncionariosAdmitidosPorPeriodoExample
    {
        public void main()
        {
            
            var apiInstance = new FuncionarioApi();
            var dtIni = 2013-10-20;  // date | 
            var dtFim = 2013-10-20;  // date | 

            try
            {
                // Retorna funcionario admitido por periodo
                array[FuncionariosAdmitidos] result = apiInstance.retornarFuncionariosAdmitidosPorPeriodo(dtIni, dtFim);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncionarioApi.retornarFuncionariosAdmitidosPorPeriodo: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncionarioApi();
$dtIni = 2013-10-20; // date | 
$dtFim = 2013-10-20; // date | 

try {
    $result = $api_instance->retornarFuncionariosAdmitidosPorPeriodo($dtIni, $dtFim);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncionarioApi->retornarFuncionariosAdmitidosPorPeriodo: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncionarioApi;

my $api_instance = WWW::SwaggerClient::FuncionarioApi->new();
my $dtIni = 2013-10-20; # date | 
my $dtFim = 2013-10-20; # date | 

eval { 
    my $result = $api_instance->retornarFuncionariosAdmitidosPorPeriodo(dtIni => $dtIni, dtFim => $dtFim);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncionarioApi->retornarFuncionariosAdmitidosPorPeriodo: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncionarioApi()
dtIni = 2013-10-20 # date | 
dtFim = 2013-10-20 # date | 

try: 
    # Retorna funcionario admitido por periodo
    api_response = api_instance.retornar_funcionarios_admitidos_por_periodo(dtIni, dtFim)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncionarioApi->retornarFuncionariosAdmitidosPorPeriodo: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncionarioApi;

import java.io.File;
import java.util.*;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[Funcionario] result = apiInstance.retornarFuncionariosAfastadosPorPeriodo(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionariosAfastadosPorPeriodo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncionarioApi;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[Funcionario] result = apiInstance.retornarFuncionariosAfastadosPorPeriodo(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionariosAfastadosPorPeriodo");
            e.printStackTrace();
        }
    }
}

date *dtIni = 2013-10-20; // 
date *dtFim = 2013-10-20; // 

FuncionarioApi *apiInstance = [[FuncionarioApi alloc] init];

// Retorna funcionario afastado por periodo
[apiInstance retornarFuncionariosAfastadosPorPeriodoWith:dtIni
    dtFim:dtFim
              completionHandler: ^(array[Funcionario] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncionarioApi()

var dtIni = 2013-10-20; // {date} 

var dtFim = 2013-10-20; // {date} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarFuncionariosAfastadosPorPeriodo(dtIni, dtFim, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarFuncionariosAfastadosPorPeriodoExample
    {
        public void main()
        {
            
            var apiInstance = new FuncionarioApi();
            var dtIni = 2013-10-20;  // date | 
            var dtFim = 2013-10-20;  // date | 

            try
            {
                // Retorna funcionario afastado por periodo
                array[Funcionario] result = apiInstance.retornarFuncionariosAfastadosPorPeriodo(dtIni, dtFim);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncionarioApi.retornarFuncionariosAfastadosPorPeriodo: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncionarioApi();
$dtIni = 2013-10-20; // date | 
$dtFim = 2013-10-20; // date | 

try {
    $result = $api_instance->retornarFuncionariosAfastadosPorPeriodo($dtIni, $dtFim);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncionarioApi->retornarFuncionariosAfastadosPorPeriodo: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncionarioApi;

my $api_instance = WWW::SwaggerClient::FuncionarioApi->new();
my $dtIni = 2013-10-20; # date | 
my $dtFim = 2013-10-20; # date | 

eval { 
    my $result = $api_instance->retornarFuncionariosAfastadosPorPeriodo(dtIni => $dtIni, dtFim => $dtFim);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncionarioApi->retornarFuncionariosAfastadosPorPeriodo: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncionarioApi()
dtIni = 2013-10-20 # date | 
dtFim = 2013-10-20 # date | 

try: 
    # Retorna funcionario afastado por periodo
    api_response = api_instance.retornar_funcionarios_afastados_por_periodo(dtIni, dtFim)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncionarioApi->retornarFuncionariosAfastadosPorPeriodo: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncionarioApi;

import java.io.File;
import java.util.*;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[FuncionariosAfastados2] result = apiInstance.retornarFuncionariosAfastadosPorPeriodo2(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionariosAfastadosPorPeriodo2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncionarioApi;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[FuncionariosAfastados2] result = apiInstance.retornarFuncionariosAfastadosPorPeriodo2(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionariosAfastadosPorPeriodo2");
            e.printStackTrace();
        }
    }
}

date *dtIni = 2013-10-20; // 
date *dtFim = 2013-10-20; // 

FuncionarioApi *apiInstance = [[FuncionarioApi alloc] init];

// Retorna funcionario afastado por periodo 2
[apiInstance retornarFuncionariosAfastadosPorPeriodo2With:dtIni
    dtFim:dtFim
              completionHandler: ^(array[FuncionariosAfastados2] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncionarioApi()

var dtIni = 2013-10-20; // {date} 

var dtFim = 2013-10-20; // {date} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarFuncionariosAfastadosPorPeriodo2(dtIni, dtFim, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarFuncionariosAfastadosPorPeriodo2Example
    {
        public void main()
        {
            
            var apiInstance = new FuncionarioApi();
            var dtIni = 2013-10-20;  // date | 
            var dtFim = 2013-10-20;  // date | 

            try
            {
                // Retorna funcionario afastado por periodo 2
                array[FuncionariosAfastados2] result = apiInstance.retornarFuncionariosAfastadosPorPeriodo2(dtIni, dtFim);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncionarioApi.retornarFuncionariosAfastadosPorPeriodo2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncionarioApi();
$dtIni = 2013-10-20; // date | 
$dtFim = 2013-10-20; // date | 

try {
    $result = $api_instance->retornarFuncionariosAfastadosPorPeriodo2($dtIni, $dtFim);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncionarioApi->retornarFuncionariosAfastadosPorPeriodo2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncionarioApi;

my $api_instance = WWW::SwaggerClient::FuncionarioApi->new();
my $dtIni = 2013-10-20; # date | 
my $dtFim = 2013-10-20; # date | 

eval { 
    my $result = $api_instance->retornarFuncionariosAfastadosPorPeriodo2(dtIni => $dtIni, dtFim => $dtFim);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncionarioApi->retornarFuncionariosAfastadosPorPeriodo2: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncionarioApi()
dtIni = 2013-10-20 # date | 
dtFim = 2013-10-20 # date | 

try: 
    # Retorna funcionario afastado por periodo 2
    api_response = api_instance.retornar_funcionarios_afastados_por_periodo2(dtIni, dtFim)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncionarioApi->retornarFuncionariosAfastadosPorPeriodo2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncionarioApi;

import java.io.File;
import java.util.*;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[FuncionariosDemitidos] result = apiInstance.retornarFuncionariosDemitidosPorPeriodo(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionariosDemitidosPorPeriodo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncionarioApi;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[FuncionariosDemitidos] result = apiInstance.retornarFuncionariosDemitidosPorPeriodo(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionariosDemitidosPorPeriodo");
            e.printStackTrace();
        }
    }
}

date *dtIni = 2013-10-20; // 
date *dtFim = 2013-10-20; // 

FuncionarioApi *apiInstance = [[FuncionarioApi alloc] init];

// Retorna funcionario demitido por periodo
[apiInstance retornarFuncionariosDemitidosPorPeriodoWith:dtIni
    dtFim:dtFim
              completionHandler: ^(array[FuncionariosDemitidos] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncionarioApi()

var dtIni = 2013-10-20; // {date} 

var dtFim = 2013-10-20; // {date} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarFuncionariosDemitidosPorPeriodo(dtIni, dtFim, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarFuncionariosDemitidosPorPeriodoExample
    {
        public void main()
        {
            
            var apiInstance = new FuncionarioApi();
            var dtIni = 2013-10-20;  // date | 
            var dtFim = 2013-10-20;  // date | 

            try
            {
                // Retorna funcionario demitido por periodo
                array[FuncionariosDemitidos] result = apiInstance.retornarFuncionariosDemitidosPorPeriodo(dtIni, dtFim);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncionarioApi.retornarFuncionariosDemitidosPorPeriodo: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncionarioApi();
$dtIni = 2013-10-20; // date | 
$dtFim = 2013-10-20; // date | 

try {
    $result = $api_instance->retornarFuncionariosDemitidosPorPeriodo($dtIni, $dtFim);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncionarioApi->retornarFuncionariosDemitidosPorPeriodo: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncionarioApi;

my $api_instance = WWW::SwaggerClient::FuncionarioApi->new();
my $dtIni = 2013-10-20; # date | 
my $dtFim = 2013-10-20; # date | 

eval { 
    my $result = $api_instance->retornarFuncionariosDemitidosPorPeriodo(dtIni => $dtIni, dtFim => $dtFim);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncionarioApi->retornarFuncionariosDemitidosPorPeriodo: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncionarioApi()
dtIni = 2013-10-20 # date | 
dtFim = 2013-10-20 # date | 

try: 
    # Retorna funcionario demitido por periodo
    api_response = api_instance.retornar_funcionarios_demitidos_por_periodo(dtIni, dtFim)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncionarioApi->retornarFuncionariosDemitidosPorPeriodo: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncionarioApi;

import java.io.File;
import java.util.*;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[FuncionarioFerias] result = apiInstance.retornarFuncionariosFeriasPorPeriodo(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionariosFeriasPorPeriodo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncionarioApi;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[FuncionarioFerias] result = apiInstance.retornarFuncionariosFeriasPorPeriodo(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionariosFeriasPorPeriodo");
            e.printStackTrace();
        }
    }
}

date *dtIni = 2013-10-20; // 
date *dtFim = 2013-10-20; // 

FuncionarioApi *apiInstance = [[FuncionarioApi alloc] init];

// Retorna ferias do funcionario por periodo
[apiInstance retornarFuncionariosFeriasPorPeriodoWith:dtIni
    dtFim:dtFim
              completionHandler: ^(array[FuncionarioFerias] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncionarioApi()

var dtIni = 2013-10-20; // {date} 

var dtFim = 2013-10-20; // {date} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarFuncionariosFeriasPorPeriodo(dtIni, dtFim, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarFuncionariosFeriasPorPeriodoExample
    {
        public void main()
        {
            
            var apiInstance = new FuncionarioApi();
            var dtIni = 2013-10-20;  // date | 
            var dtFim = 2013-10-20;  // date | 

            try
            {
                // Retorna ferias do funcionario por periodo
                array[FuncionarioFerias] result = apiInstance.retornarFuncionariosFeriasPorPeriodo(dtIni, dtFim);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncionarioApi.retornarFuncionariosFeriasPorPeriodo: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncionarioApi();
$dtIni = 2013-10-20; // date | 
$dtFim = 2013-10-20; // date | 

try {
    $result = $api_instance->retornarFuncionariosFeriasPorPeriodo($dtIni, $dtFim);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncionarioApi->retornarFuncionariosFeriasPorPeriodo: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncionarioApi;

my $api_instance = WWW::SwaggerClient::FuncionarioApi->new();
my $dtIni = 2013-10-20; # date | 
my $dtFim = 2013-10-20; # date | 

eval { 
    my $result = $api_instance->retornarFuncionariosFeriasPorPeriodo(dtIni => $dtIni, dtFim => $dtFim);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncionarioApi->retornarFuncionariosFeriasPorPeriodo: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncionarioApi()
dtIni = 2013-10-20 # date | 
dtFim = 2013-10-20 # date | 

try: 
    # Retorna ferias do funcionario por periodo
    api_response = api_instance.retornar_funcionarios_ferias_por_periodo(dtIni, dtFim)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncionarioApi->retornarFuncionariosFeriasPorPeriodo: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncionarioApi;

import java.io.File;
import java.util.*;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        
        FuncionarioApi apiInstance = new FuncionarioApi();
        String nomeFuncionario = nomeFuncionario_example; // String | 
        try {
            array[Funcionario] result = apiInstance.retornarFuncionariosPorNome(nomeFuncionario);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionariosPorNome");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncionarioApi;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        FuncionarioApi apiInstance = new FuncionarioApi();
        String nomeFuncionario = nomeFuncionario_example; // String | 
        try {
            array[Funcionario] result = apiInstance.retornarFuncionariosPorNome(nomeFuncionario);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarFuncionariosPorNome");
            e.printStackTrace();
        }
    }
}

String *nomeFuncionario = nomeFuncionario_example; // 

FuncionarioApi *apiInstance = [[FuncionarioApi alloc] init];

// Retorna funcionario por nome
[apiInstance retornarFuncionariosPorNomeWith:nomeFuncionario
              completionHandler: ^(array[Funcionario] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncionarioApi()

var nomeFuncionario = nomeFuncionario_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarFuncionariosPorNome(nomeFuncionario, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarFuncionariosPorNomeExample
    {
        public void main()
        {
            
            var apiInstance = new FuncionarioApi();
            var nomeFuncionario = nomeFuncionario_example;  // String | 

            try
            {
                // Retorna funcionario por nome
                array[Funcionario] result = apiInstance.retornarFuncionariosPorNome(nomeFuncionario);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncionarioApi.retornarFuncionariosPorNome: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncionarioApi();
$nomeFuncionario = nomeFuncionario_example; // String | 

try {
    $result = $api_instance->retornarFuncionariosPorNome($nomeFuncionario);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncionarioApi->retornarFuncionariosPorNome: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncionarioApi;

my $api_instance = WWW::SwaggerClient::FuncionarioApi->new();
my $nomeFuncionario = nomeFuncionario_example; # String | 

eval { 
    my $result = $api_instance->retornarFuncionariosPorNome(nomeFuncionario => $nomeFuncionario);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncionarioApi->retornarFuncionariosPorNome: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncionarioApi()
nomeFuncionario = nomeFuncionario_example # String | 

try: 
    # Retorna funcionario por nome
    api_response = api_instance.retornar_funcionarios_por_nome(nomeFuncionario)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncionarioApi->retornarFuncionariosPorNome: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncionarioApi;

import java.io.File;
import java.util.*;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[FuncionarioHistorico] result = apiInstance.retornarHistoricoFuncionariosPorPeriodo(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarHistoricoFuncionariosPorPeriodo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncionarioApi;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[FuncionarioHistorico] result = apiInstance.retornarHistoricoFuncionariosPorPeriodo(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarHistoricoFuncionariosPorPeriodo");
            e.printStackTrace();
        }
    }
}

date *dtIni = 2013-10-20; // 
date *dtFim = 2013-10-20; // 

FuncionarioApi *apiInstance = [[FuncionarioApi alloc] init];

// Retorna historico do funcionario por periodo
[apiInstance retornarHistoricoFuncionariosPorPeriodoWith:dtIni
    dtFim:dtFim
              completionHandler: ^(array[FuncionarioHistorico] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncionarioApi()

var dtIni = 2013-10-20; // {date} 

var dtFim = 2013-10-20; // {date} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarHistoricoFuncionariosPorPeriodo(dtIni, dtFim, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarHistoricoFuncionariosPorPeriodoExample
    {
        public void main()
        {
            
            var apiInstance = new FuncionarioApi();
            var dtIni = 2013-10-20;  // date | 
            var dtFim = 2013-10-20;  // date | 

            try
            {
                // Retorna historico do funcionario por periodo
                array[FuncionarioHistorico] result = apiInstance.retornarHistoricoFuncionariosPorPeriodo(dtIni, dtFim);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncionarioApi.retornarHistoricoFuncionariosPorPeriodo: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncionarioApi();
$dtIni = 2013-10-20; // date | 
$dtFim = 2013-10-20; // date | 

try {
    $result = $api_instance->retornarHistoricoFuncionariosPorPeriodo($dtIni, $dtFim);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncionarioApi->retornarHistoricoFuncionariosPorPeriodo: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncionarioApi;

my $api_instance = WWW::SwaggerClient::FuncionarioApi->new();
my $dtIni = 2013-10-20; # date | 
my $dtFim = 2013-10-20; # date | 

eval { 
    my $result = $api_instance->retornarHistoricoFuncionariosPorPeriodo(dtIni => $dtIni, dtFim => $dtFim);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncionarioApi->retornarHistoricoFuncionariosPorPeriodo: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncionarioApi()
dtIni = 2013-10-20 # date | 
dtFim = 2013-10-20 # date | 

try: 
    # Retorna historico do funcionario por periodo
    api_response = api_instance.retornar_historico_funcionarios_por_periodo(dtIni, dtFim)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncionarioApi->retornarHistoricoFuncionariosPorPeriodo: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FuncionarioApi;

import java.io.File;
import java.util.*;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[FuncionarioTransferencia] result = apiInstance.retornarTransferenciaFuncionarioPorPeriodo(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarTransferenciaFuncionarioPorPeriodo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FuncionarioApi;

public class FuncionarioApiExample {

    public static void main(String[] args) {
        FuncionarioApi apiInstance = new FuncionarioApi();
        date dtIni = 2013-10-20; // date | 
        date dtFim = 2013-10-20; // date | 
        try {
            array[FuncionarioTransferencia] result = apiInstance.retornarTransferenciaFuncionarioPorPeriodo(dtIni, dtFim);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FuncionarioApi#retornarTransferenciaFuncionarioPorPeriodo");
            e.printStackTrace();
        }
    }
}

date *dtIni = 2013-10-20; // 
date *dtFim = 2013-10-20; // 

FuncionarioApi *apiInstance = [[FuncionarioApi alloc] init];

// Retorna transferência de funcionario por periodo
[apiInstance retornarTransferenciaFuncionarioPorPeriodoWith:dtIni
    dtFim:dtFim
              completionHandler: ^(array[FuncionarioTransferencia] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.FuncionarioApi()

var dtIni = 2013-10-20; // {date} 

var dtFim = 2013-10-20; // {date} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarTransferenciaFuncionarioPorPeriodo(dtIni, dtFim, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarTransferenciaFuncionarioPorPeriodoExample
    {
        public void main()
        {
            
            var apiInstance = new FuncionarioApi();
            var dtIni = 2013-10-20;  // date | 
            var dtFim = 2013-10-20;  // date | 

            try
            {
                // Retorna transferência de funcionario por periodo
                array[FuncionarioTransferencia] result = apiInstance.retornarTransferenciaFuncionarioPorPeriodo(dtIni, dtFim);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FuncionarioApi.retornarTransferenciaFuncionarioPorPeriodo: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\FuncionarioApi();
$dtIni = 2013-10-20; // date | 
$dtFim = 2013-10-20; // date | 

try {
    $result = $api_instance->retornarTransferenciaFuncionarioPorPeriodo($dtIni, $dtFim);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FuncionarioApi->retornarTransferenciaFuncionarioPorPeriodo: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FuncionarioApi;

my $api_instance = WWW::SwaggerClient::FuncionarioApi->new();
my $dtIni = 2013-10-20; # date | 
my $dtFim = 2013-10-20; # date | 

eval { 
    my $result = $api_instance->retornarTransferenciaFuncionarioPorPeriodo(dtIni => $dtIni, dtFim => $dtFim);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FuncionarioApi->retornarTransferenciaFuncionarioPorPeriodo: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FuncionarioApi()
dtIni = 2013-10-20 # date | 
dtFim = 2013-10-20 # date | 

try: 
    # Retorna transferência de funcionario por periodo
    api_response = api_instance.retornar_transferencia_funcionario_por_periodo(dtIni, dtFim)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FuncionarioApi->retornarTransferenciaFuncionarioPorPeriodo: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MonitoramentoSaudeTrabApi;

import java.io.File;
import java.util.*;

public class MonitoramentoSaudeTrabApiExample {

    public static void main(String[] args) {
        
        MonitoramentoSaudeTrabApi apiInstance = new MonitoramentoSaudeTrabApi();
        array[MonitoramentoSaudeTrab] monitoramentoSaudeTrab = ; // array[MonitoramentoSaudeTrab] | Monitoramento da Saúdo do Trabalhador.
        try {
            apiInstance.monitoramentoSaudeTrab(monitoramentoSaudeTrab);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoramentoSaudeTrabApi#monitoramentoSaudeTrab");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MonitoramentoSaudeTrabApi;

public class MonitoramentoSaudeTrabApiExample {

    public static void main(String[] args) {
        MonitoramentoSaudeTrabApi apiInstance = new MonitoramentoSaudeTrabApi();
        array[MonitoramentoSaudeTrab] monitoramentoSaudeTrab = ; // array[MonitoramentoSaudeTrab] | Monitoramento da Saúdo do Trabalhador.
        try {
            apiInstance.monitoramentoSaudeTrab(monitoramentoSaudeTrab);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoramentoSaudeTrabApi#monitoramentoSaudeTrab");
            e.printStackTrace();
        }
    }
}

array[MonitoramentoSaudeTrab] *monitoramentoSaudeTrab = ; // Monitoramento da Saúdo do Trabalhador.

MonitoramentoSaudeTrabApi *apiInstance = [[MonitoramentoSaudeTrabApi alloc] init];

// Informar monitoramento de saúde do trabalhador
[apiInstance monitoramentoSaudeTrabWith:monitoramentoSaudeTrab
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.MonitoramentoSaudeTrabApi()

var monitoramentoSaudeTrab = ; // {array[MonitoramentoSaudeTrab]} Monitoramento da Saúdo do Trabalhador.


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.monitoramentoSaudeTrab(monitoramentoSaudeTrab, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class monitoramentoSaudeTrabExample
    {
        public void main()
        {
            
            var apiInstance = new MonitoramentoSaudeTrabApi();
            var monitoramentoSaudeTrab = new array[MonitoramentoSaudeTrab](); // array[MonitoramentoSaudeTrab] | Monitoramento da Saúdo do Trabalhador.

            try
            {
                // Informar monitoramento de saúde do trabalhador
                apiInstance.monitoramentoSaudeTrab(monitoramentoSaudeTrab);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MonitoramentoSaudeTrabApi.monitoramentoSaudeTrab: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\MonitoramentoSaudeTrabApi();
$monitoramentoSaudeTrab = ; // array[MonitoramentoSaudeTrab] | Monitoramento da Saúdo do Trabalhador.

try {
    $api_instance->monitoramentoSaudeTrab($monitoramentoSaudeTrab);
} catch (Exception $e) {
    echo 'Exception when calling MonitoramentoSaudeTrabApi->monitoramentoSaudeTrab: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MonitoramentoSaudeTrabApi;

my $api_instance = WWW::SwaggerClient::MonitoramentoSaudeTrabApi->new();
my $monitoramentoSaudeTrab = [WWW::SwaggerClient::Object::array[MonitoramentoSaudeTrab]->new()]; # array[MonitoramentoSaudeTrab] | Monitoramento da Saúdo do Trabalhador.

eval { 
    $api_instance->monitoramentoSaudeTrab(monitoramentoSaudeTrab => $monitoramentoSaudeTrab);
};
if ($@) {
    warn "Exception when calling MonitoramentoSaudeTrabApi->monitoramentoSaudeTrab: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.MonitoramentoSaudeTrabApi()
monitoramentoSaudeTrab =  # array[MonitoramentoSaudeTrab] | Monitoramento da Saúdo do Trabalhador.

try: 
    # Informar monitoramento de saúde do trabalhador
    api_instance.monitoramento_saude_trab(monitoramentoSaudeTrab)
except ApiException as e:
    print("Exception when calling MonitoramentoSaudeTrabApi->monitoramentoSaudeTrab: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SetorApi;

import java.io.File;
import java.util.*;

public class SetorApiExample {

    public static void main(String[] args) {
        
        SetorApi apiInstance = new SetorApi();
        String descricaoSetor = descricaoSetor_example; // String | 
        try {
            array[Setor] result = apiInstance.retornarSetorPorDescricao(descricaoSetor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetorApi#retornarSetorPorDescricao");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SetorApi;

public class SetorApiExample {

    public static void main(String[] args) {
        SetorApi apiInstance = new SetorApi();
        String descricaoSetor = descricaoSetor_example; // String | 
        try {
            array[Setor] result = apiInstance.retornarSetorPorDescricao(descricaoSetor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetorApi#retornarSetorPorDescricao");
            e.printStackTrace();
        }
    }
}

String *descricaoSetor = descricaoSetor_example; // 

SetorApi *apiInstance = [[SetorApi alloc] init];

// Retornar Setores pela Descrição
[apiInstance retornarSetorPorDescricaoWith:descricaoSetor
              completionHandler: ^(array[Setor] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.SetorApi()

var descricaoSetor = descricaoSetor_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarSetorPorDescricao(descricaoSetor, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarSetorPorDescricaoExample
    {
        public void main()
        {
            
            var apiInstance = new SetorApi();
            var descricaoSetor = descricaoSetor_example;  // String | 

            try
            {
                // Retornar Setores pela Descrição
                array[Setor] result = apiInstance.retornarSetorPorDescricao(descricaoSetor);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SetorApi.retornarSetorPorDescricao: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\SetorApi();
$descricaoSetor = descricaoSetor_example; // String | 

try {
    $result = $api_instance->retornarSetorPorDescricao($descricaoSetor);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SetorApi->retornarSetorPorDescricao: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SetorApi;

my $api_instance = WWW::SwaggerClient::SetorApi->new();
my $descricaoSetor = descricaoSetor_example; # String | 

eval { 
    my $result = $api_instance->retornarSetorPorDescricao(descricaoSetor => $descricaoSetor);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SetorApi->retornarSetorPorDescricao: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.SetorApi()
descricaoSetor = descricaoSetor_example # String | 

try: 
    # Retornar Setores pela Descrição
    api_response = api_instance.retornar_setor_por_descricao(descricaoSetor)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SetorApi->retornarSetorPorDescricao: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SetorApi;

import java.io.File;
import java.util.*;

public class SetorApiExample {

    public static void main(String[] args) {
        
        SetorApi apiInstance = new SetorApi();
        try {
            array[Setor] result = apiInstance.retornarSetores();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetorApi#retornarSetores");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SetorApi;

public class SetorApiExample {

    public static void main(String[] args) {
        SetorApi apiInstance = new SetorApi();
        try {
            array[Setor] result = apiInstance.retornarSetores();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetorApi#retornarSetores");
            e.printStackTrace();
        }
    }
}

SetorApi *apiInstance = [[SetorApi alloc] init];

// Retornar Setores
[apiInstance retornarSetoresWithCompletionHandler: 
              ^(array[Setor] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SstPraxio = require('sst___praxio');

var api = new SstPraxio.SetorApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retornarSetores(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class retornarSetoresExample
    {
        public void main()
        {
            
            var apiInstance = new SetorApi();

            try
            {
                // Retornar Setores
                array[Setor] result = apiInstance.retornarSetores();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SetorApi.retornarSetores: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\SetorApi();

try {
    $result = $api_instance->retornarSetores();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SetorApi->retornarSetores: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SetorApi;

my $api_instance = WWW::SwaggerClient::SetorApi->new();

eval { 
    my $result = $api_instance->retornarSetores();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SetorApi->retornarSetores: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.SetorApi()

try: 
    # Retornar Setores
    api_response = api_instance.retornar_setores()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SetorApi->retornarSetores: %s\n" % e)