BravoAPI

Lpr

addLprAlphadigi

Encaminha o alerta tratado pela camera ALPHADIGI

Recebimento e processamento dos bilhetes recebidos via ALPHADIGI


/add/lpr/alphadigi

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/add/lpr/alphadigi" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LprApi;

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

public class LprApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LprApi apiInstance = new LprApi();
        AddLprAlphadigiRequest addLprAlphadigiRequest = ; // AddLprAlphadigiRequest | 

        try {
            apiInstance.addLprAlphadigi(addLprAlphadigiRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprAlphadigi");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AddLprAlphadigiRequest addLprAlphadigiRequest = new AddLprAlphadigiRequest(); // AddLprAlphadigiRequest | 

try {
    final result = await api_instance.addLprAlphadigi(addLprAlphadigiRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addLprAlphadigi: $e\n');
}


import org.openapitools.client.api.LprApi;

public class LprApiExample {
    public static void main(String[] args) {
        LprApi apiInstance = new LprApi();
        AddLprAlphadigiRequest addLprAlphadigiRequest = ; // AddLprAlphadigiRequest | 

        try {
            apiInstance.addLprAlphadigi(addLprAlphadigiRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprAlphadigi");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LprApi *apiInstance = [[LprApi alloc] init];
AddLprAlphadigiRequest *addLprAlphadigiRequest = ; // 

// Encaminha o alerta tratado pela camera ALPHADIGI
[apiInstance addLprAlphadigiWith:addLprAlphadigiRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.LprApi()
var addLprAlphadigiRequest = ; // {AddLprAlphadigiRequest} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addLprAlphadigiExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LprApi();
            var addLprAlphadigiRequest = new AddLprAlphadigiRequest(); // AddLprAlphadigiRequest | 

            try {
                // Encaminha o alerta tratado pela camera ALPHADIGI
                apiInstance.addLprAlphadigi(addLprAlphadigiRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling LprApi.addLprAlphadigi: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LprApi();
$addLprAlphadigiRequest = ; // AddLprAlphadigiRequest | 

try {
    $api_instance->addLprAlphadigi($addLprAlphadigiRequest);
} catch (Exception $e) {
    echo 'Exception when calling LprApi->addLprAlphadigi: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LprApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LprApi->new();
my $addLprAlphadigiRequest = WWW::OPenAPIClient::Object::AddLprAlphadigiRequest->new(); # AddLprAlphadigiRequest | 

eval {
    $api_instance->addLprAlphadigi(addLprAlphadigiRequest => $addLprAlphadigiRequest);
};
if ($@) {
    warn "Exception when calling LprApi->addLprAlphadigi: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LprApi()
addLprAlphadigiRequest =  # AddLprAlphadigiRequest | 

try:
    # Encaminha o alerta tratado pela camera ALPHADIGI
    api_instance.add_lpr_alphadigi(addLprAlphadigiRequest)
except ApiException as e:
    print("Exception when calling LprApi->addLprAlphadigi: %s\n" % e)
extern crate LprApi;

pub fn main() {
    let addLprAlphadigiRequest = ; // AddLprAlphadigiRequest

    let mut context = LprApi::Context::default();
    let result = client.addLprAlphadigi(addLprAlphadigiRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
addLprAlphadigiRequest *

Dados da leitura realizada

Responses

addLprAxxon

Encaminha o alerta tratado pelas cameras vinculadas a um servidor Axxon *** (EM DESENVOLVIMENTO) ***

Este método permite o recebimento e processamento dos bilhetes encaminhados pelas câmeras vinculadas a um servidor Axxon. https://www.axxonsoft.com *** (EM DESENVOLVIMENTO) ***


/add/lpr/axxon/{nodeName}

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/add/lpr/axxon/{nodeName}" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LprApi;

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

public class LprApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LprApi apiInstance = new LprApi();
        String nodeName = NODE1; // String | o nodeName do servidor
        AddLprAxxonRequest addLprAxxonRequest = ; // AddLprAxxonRequest | 

        try {
            apiInstance.addLprAxxon(nodeName, addLprAxxonRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprAxxon");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String nodeName = new String(); // String | o nodeName do servidor
final AddLprAxxonRequest addLprAxxonRequest = new AddLprAxxonRequest(); // AddLprAxxonRequest | 

try {
    final result = await api_instance.addLprAxxon(nodeName, addLprAxxonRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addLprAxxon: $e\n');
}


import org.openapitools.client.api.LprApi;

public class LprApiExample {
    public static void main(String[] args) {
        LprApi apiInstance = new LprApi();
        String nodeName = NODE1; // String | o nodeName do servidor
        AddLprAxxonRequest addLprAxxonRequest = ; // AddLprAxxonRequest | 

        try {
            apiInstance.addLprAxxon(nodeName, addLprAxxonRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprAxxon");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LprApi *apiInstance = [[LprApi alloc] init];
String *nodeName = NODE1; // o nodeName do servidor (default to null)
AddLprAxxonRequest *addLprAxxonRequest = ; // 

// Encaminha o alerta tratado pelas cameras vinculadas a um servidor Axxon *** (EM DESENVOLVIMENTO) ***
[apiInstance addLprAxxonWith:nodeName
    addLprAxxonRequest:addLprAxxonRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.LprApi()
var nodeName = NODE1; // {String} o nodeName do servidor
var addLprAxxonRequest = ; // {AddLprAxxonRequest} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addLprAxxonExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LprApi();
            var nodeName = NODE1;  // String | o nodeName do servidor (default to null)
            var addLprAxxonRequest = new AddLprAxxonRequest(); // AddLprAxxonRequest | 

            try {
                // Encaminha o alerta tratado pelas cameras vinculadas a um servidor Axxon *** (EM DESENVOLVIMENTO) ***
                apiInstance.addLprAxxon(nodeName, addLprAxxonRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling LprApi.addLprAxxon: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LprApi();
$nodeName = NODE1; // String | o nodeName do servidor
$addLprAxxonRequest = ; // AddLprAxxonRequest | 

try {
    $api_instance->addLprAxxon($nodeName, $addLprAxxonRequest);
} catch (Exception $e) {
    echo 'Exception when calling LprApi->addLprAxxon: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LprApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LprApi->new();
my $nodeName = NODE1; # String | o nodeName do servidor
my $addLprAxxonRequest = WWW::OPenAPIClient::Object::AddLprAxxonRequest->new(); # AddLprAxxonRequest | 

eval {
    $api_instance->addLprAxxon(nodeName => $nodeName, addLprAxxonRequest => $addLprAxxonRequest);
};
if ($@) {
    warn "Exception when calling LprApi->addLprAxxon: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LprApi()
nodeName = NODE1 # String | o nodeName do servidor (default to null)
addLprAxxonRequest =  # AddLprAxxonRequest | 

try:
    # Encaminha o alerta tratado pelas cameras vinculadas a um servidor Axxon *** (EM DESENVOLVIMENTO) ***
    api_instance.add_lpr_axxon(nodeName, addLprAxxonRequest)
except ApiException as e:
    print("Exception when calling LprApi->addLprAxxon: %s\n" % e)
extern crate LprApi;

pub fn main() {
    let nodeName = NODE1; // String
    let addLprAxxonRequest = ; // AddLprAxxonRequest

    let mut context = LprApi::Context::default();
    let result = client.addLprAxxon(nodeName, addLprAxxonRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
nodeName*
String
o nodeName do servidor
Required
Body parameters
Name Description
addLprAxxonRequest *

Dados da leitura realizada

Responses

addLprCGGallo

Encaminha o alerta tratado pela CCGallo

Este método permite o recebimento e processamento dos bilhetes encaminhados pelas câmeras da CC Gallo - Pomerode.


/add/lpr/pegaplaca

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/add/lpr/pegaplaca" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LprApi;

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

public class LprApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LprApi apiInstance = new LprApi();
        AddLprCGGalloRequest addLprCGGalloRequest = ; // AddLprCGGalloRequest | 

        try {
            apiInstance.addLprCGGallo(addLprCGGalloRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprCGGallo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AddLprCGGalloRequest addLprCGGalloRequest = new AddLprCGGalloRequest(); // AddLprCGGalloRequest | 

try {
    final result = await api_instance.addLprCGGallo(addLprCGGalloRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addLprCGGallo: $e\n');
}


import org.openapitools.client.api.LprApi;

public class LprApiExample {
    public static void main(String[] args) {
        LprApi apiInstance = new LprApi();
        AddLprCGGalloRequest addLprCGGalloRequest = ; // AddLprCGGalloRequest | 

        try {
            apiInstance.addLprCGGallo(addLprCGGalloRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprCGGallo");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LprApi *apiInstance = [[LprApi alloc] init];
AddLprCGGalloRequest *addLprCGGalloRequest = ; // 

// Encaminha o alerta tratado pela CCGallo
[apiInstance addLprCGGalloWith:addLprCGGalloRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.LprApi()
var addLprCGGalloRequest = ; // {AddLprCGGalloRequest} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addLprCGGalloExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LprApi();
            var addLprCGGalloRequest = new AddLprCGGalloRequest(); // AddLprCGGalloRequest | 

            try {
                // Encaminha o alerta tratado pela CCGallo
                apiInstance.addLprCGGallo(addLprCGGalloRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling LprApi.addLprCGGallo: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LprApi();
$addLprCGGalloRequest = ; // AddLprCGGalloRequest | 

try {
    $api_instance->addLprCGGallo($addLprCGGalloRequest);
} catch (Exception $e) {
    echo 'Exception when calling LprApi->addLprCGGallo: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LprApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LprApi->new();
my $addLprCGGalloRequest = WWW::OPenAPIClient::Object::AddLprCGGalloRequest->new(); # AddLprCGGalloRequest | 

eval {
    $api_instance->addLprCGGallo(addLprCGGalloRequest => $addLprCGGalloRequest);
};
if ($@) {
    warn "Exception when calling LprApi->addLprCGGallo: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LprApi()
addLprCGGalloRequest =  # AddLprCGGalloRequest | 

try:
    # Encaminha o alerta tratado pela CCGallo
    api_instance.add_lpr_cg_gallo(addLprCGGalloRequest)
except ApiException as e:
    print("Exception when calling LprApi->addLprCGGallo: %s\n" % e)
extern crate LprApi;

pub fn main() {
    let addLprCGGalloRequest = ; // AddLprCGGalloRequest

    let mut context = LprApi::Context::default();
    let result = client.addLprCGGallo(addLprCGGalloRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
addLprCGGalloRequest *

Dados da leitura realizada

Responses

addLprGenetec

Este método permite o recebimento e processamento dos bilhetes encaminhados pelas câmeras AutoVu da fabricante Genetec.

Recebimento e processamento dos bilhetes recebidos das câmeras AutoVu Genetec


/add/lpr/genetec

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/add/lpr/genetec" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LprApi;

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

public class LprApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LprApi apiInstance = new LprApi();
        AddLprGenetecRequest addLprGenetecRequest = ; // AddLprGenetecRequest | 

        try {
            apiInstance.addLprGenetec(addLprGenetecRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprGenetec");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AddLprGenetecRequest addLprGenetecRequest = new AddLprGenetecRequest(); // AddLprGenetecRequest | 

try {
    final result = await api_instance.addLprGenetec(addLprGenetecRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addLprGenetec: $e\n');
}


import org.openapitools.client.api.LprApi;

public class LprApiExample {
    public static void main(String[] args) {
        LprApi apiInstance = new LprApi();
        AddLprGenetecRequest addLprGenetecRequest = ; // AddLprGenetecRequest | 

        try {
            apiInstance.addLprGenetec(addLprGenetecRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprGenetec");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LprApi *apiInstance = [[LprApi alloc] init];
AddLprGenetecRequest *addLprGenetecRequest = ; // 

// Este método permite o recebimento e processamento dos bilhetes encaminhados pelas câmeras AutoVu da fabricante Genetec.
[apiInstance addLprGenetecWith:addLprGenetecRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.LprApi()
var addLprGenetecRequest = ; // {AddLprGenetecRequest} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addLprGenetecExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LprApi();
            var addLprGenetecRequest = new AddLprGenetecRequest(); // AddLprGenetecRequest | 

            try {
                // Este método permite o recebimento e processamento dos bilhetes encaminhados pelas câmeras AutoVu da fabricante Genetec.
                apiInstance.addLprGenetec(addLprGenetecRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling LprApi.addLprGenetec: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LprApi();
$addLprGenetecRequest = ; // AddLprGenetecRequest | 

try {
    $api_instance->addLprGenetec($addLprGenetecRequest);
} catch (Exception $e) {
    echo 'Exception when calling LprApi->addLprGenetec: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LprApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LprApi->new();
my $addLprGenetecRequest = WWW::OPenAPIClient::Object::AddLprGenetecRequest->new(); # AddLprGenetecRequest | 

eval {
    $api_instance->addLprGenetec(addLprGenetecRequest => $addLprGenetecRequest);
};
if ($@) {
    warn "Exception when calling LprApi->addLprGenetec: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LprApi()
addLprGenetecRequest =  # AddLprGenetecRequest | 

try:
    # Este método permite o recebimento e processamento dos bilhetes encaminhados pelas câmeras AutoVu da fabricante Genetec.
    api_instance.add_lpr_genetec(addLprGenetecRequest)
except ApiException as e:
    print("Exception when calling LprApi->addLprGenetec: %s\n" % e)
extern crate LprApi;

pub fn main() {
    let addLprGenetecRequest = ; // AddLprGenetecRequest

    let mut context = LprApi::Context::default();
    let result = client.addLprGenetec(addLprGenetecRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
addLprGenetecRequest *

Dados da leitura realizada

Responses

addLprHelper

Este método permite o recebimento e processamento dos bilhetes conforme padrão da empresa Helper.

Recebimento e processamento dos bilhetes recebidos pela empresa Helper


/add/lpr/helper

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/add/lpr/helper" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LprApi;

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

public class LprApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LprApi apiInstance = new LprApi();
        AddLprHelperRequest addLprHelperRequest = ; // AddLprHelperRequest | 

        try {
            apiInstance.addLprHelper(addLprHelperRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprHelper");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AddLprHelperRequest addLprHelperRequest = new AddLprHelperRequest(); // AddLprHelperRequest | 

try {
    final result = await api_instance.addLprHelper(addLprHelperRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addLprHelper: $e\n');
}


import org.openapitools.client.api.LprApi;

public class LprApiExample {
    public static void main(String[] args) {
        LprApi apiInstance = new LprApi();
        AddLprHelperRequest addLprHelperRequest = ; // AddLprHelperRequest | 

        try {
            apiInstance.addLprHelper(addLprHelperRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprHelper");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LprApi *apiInstance = [[LprApi alloc] init];
AddLprHelperRequest *addLprHelperRequest = ; // 

// Este método permite o recebimento e processamento dos bilhetes conforme padrão da empresa Helper.
[apiInstance addLprHelperWith:addLprHelperRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.LprApi()
var addLprHelperRequest = ; // {AddLprHelperRequest} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addLprHelperExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LprApi();
            var addLprHelperRequest = new AddLprHelperRequest(); // AddLprHelperRequest | 

            try {
                // Este método permite o recebimento e processamento dos bilhetes conforme padrão da empresa Helper.
                apiInstance.addLprHelper(addLprHelperRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling LprApi.addLprHelper: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LprApi();
$addLprHelperRequest = ; // AddLprHelperRequest | 

try {
    $api_instance->addLprHelper($addLprHelperRequest);
} catch (Exception $e) {
    echo 'Exception when calling LprApi->addLprHelper: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LprApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LprApi->new();
my $addLprHelperRequest = WWW::OPenAPIClient::Object::AddLprHelperRequest->new(); # AddLprHelperRequest | 

eval {
    $api_instance->addLprHelper(addLprHelperRequest => $addLprHelperRequest);
};
if ($@) {
    warn "Exception when calling LprApi->addLprHelper: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LprApi()
addLprHelperRequest =  # AddLprHelperRequest | 

try:
    # Este método permite o recebimento e processamento dos bilhetes conforme padrão da empresa Helper.
    api_instance.add_lpr_helper(addLprHelperRequest)
except ApiException as e:
    print("Exception when calling LprApi->addLprHelper: %s\n" % e)
extern crate LprApi;

pub fn main() {
    let addLprHelperRequest = ; // AddLprHelperRequest

    let mut context = LprApi::Context::default();
    let result = client.addLprHelper(addLprHelperRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
addLprHelperRequest *

Dados da leitura realizada

Responses

addLprHydra

Este método permite o recebimento e processamento dos bilhetes conforme padrão da SSP e Software HYDRA - DATA e HORA LOCAL.

Recebimento e processamento dos bilhetes recebidos da plataforma HYDRA e não tratados previamente - DATA e HORA LOCAL


/add/lpr/hydra

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/add/lpr/hydra" \
 -d '{
  "dispositivoLeitura" : "BCU_LPR_002",
  "longitudeLeitura" : "-48.334455",
  "UFLeitura" : "SC",
  "leitura" : "MLH3370",
  "imagemLeitura" : "LzlqLzRBQS4uLjBBZi85az0=",
  "dataLeitura" : "2019-12-22 19:25:30.000",
  "enderecoLeitura" : "Avenida Brasil x Rua 3700 - sentido bairro",
  "cidadeLeitura" : "Balneario Camboriu",
  "dadosAdicionais" : "{}",
  "latitudeLeitura" : "-27.776688"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LprApi;

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

public class LprApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LprApi apiInstance = new LprApi();
        array[addLprHydra_request_inner] addLprHydraRequestInner = ; // array[addLprHydra_request_inner] | 

        try {
            apiInstance.addLprHydra(addLprHydraRequestInner);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprHydra");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[addLprHydra_request_inner] addLprHydraRequestInner = new array[addLprHydra_request_inner](); // array[addLprHydra_request_inner] | 

try {
    final result = await api_instance.addLprHydra(addLprHydraRequestInner);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addLprHydra: $e\n');
}


import org.openapitools.client.api.LprApi;

public class LprApiExample {
    public static void main(String[] args) {
        LprApi apiInstance = new LprApi();
        array[addLprHydra_request_inner] addLprHydraRequestInner = ; // array[addLprHydra_request_inner] | 

        try {
            apiInstance.addLprHydra(addLprHydraRequestInner);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprHydra");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LprApi *apiInstance = [[LprApi alloc] init];
array[addLprHydra_request_inner] *addLprHydraRequestInner = ; // 

// Este método permite o recebimento e processamento dos bilhetes conforme padrão da SSP e Software HYDRA - DATA e HORA LOCAL.
[apiInstance addLprHydraWith:addLprHydraRequestInner
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.LprApi()
var addLprHydraRequestInner = ; // {array[addLprHydra_request_inner]} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addLprHydraExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LprApi();
            var addLprHydraRequestInner = new array[addLprHydra_request_inner](); // array[addLprHydra_request_inner] | 

            try {
                // Este método permite o recebimento e processamento dos bilhetes conforme padrão da SSP e Software HYDRA - DATA e HORA LOCAL.
                apiInstance.addLprHydra(addLprHydraRequestInner);
            } catch (Exception e) {
                Debug.Print("Exception when calling LprApi.addLprHydra: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LprApi();
$addLprHydraRequestInner = ; // array[addLprHydra_request_inner] | 

try {
    $api_instance->addLprHydra($addLprHydraRequestInner);
} catch (Exception $e) {
    echo 'Exception when calling LprApi->addLprHydra: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LprApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LprApi->new();
my $addLprHydraRequestInner = [WWW::OPenAPIClient::Object::array[addLprHydra_request_inner]->new()]; # array[addLprHydra_request_inner] | 

eval {
    $api_instance->addLprHydra(addLprHydraRequestInner => $addLprHydraRequestInner);
};
if ($@) {
    warn "Exception when calling LprApi->addLprHydra: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LprApi()
addLprHydraRequestInner =  # array[addLprHydra_request_inner] | 

try:
    # Este método permite o recebimento e processamento dos bilhetes conforme padrão da SSP e Software HYDRA - DATA e HORA LOCAL.
    api_instance.add_lpr_hydra(addLprHydraRequestInner)
except ApiException as e:
    print("Exception when calling LprApi->addLprHydra: %s\n" % e)
extern crate LprApi;

pub fn main() {
    let addLprHydraRequestInner = ; // array[addLprHydra_request_inner]

    let mut context = LprApi::Context::default();
    let result = client.addLprHydra(addLprHydraRequestInner, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
addLprHydraRequestInner *

Dados da leitura realizada

Responses

addLprIntelbras

Encaminha o alerta tratado pela camera Intelbras - firmware BemTeVi

Este método permite o recebimento e processamento dos bilhetes encaminhados pelas câmeras Intelbras https://www.intelbras.com.br


/add/lpr/intelbras/{nomeDispositivo}

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/add/lpr/intelbras/{nomeDispositivo}" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LprApi;

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

public class LprApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LprApi apiInstance = new LprApi();
        String nomeDispositivo = FNS_P001_C002; // String | o nome do dispositivo
        AddLprIntelbrasRequest addLprIntelbrasRequest = ; // AddLprIntelbrasRequest | 

        try {
            apiInstance.addLprIntelbras(nomeDispositivo, addLprIntelbrasRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprIntelbras");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String nomeDispositivo = new String(); // String | o nome do dispositivo
final AddLprIntelbrasRequest addLprIntelbrasRequest = new AddLprIntelbrasRequest(); // AddLprIntelbrasRequest | 

try {
    final result = await api_instance.addLprIntelbras(nomeDispositivo, addLprIntelbrasRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addLprIntelbras: $e\n');
}


import org.openapitools.client.api.LprApi;

public class LprApiExample {
    public static void main(String[] args) {
        LprApi apiInstance = new LprApi();
        String nomeDispositivo = FNS_P001_C002; // String | o nome do dispositivo
        AddLprIntelbrasRequest addLprIntelbrasRequest = ; // AddLprIntelbrasRequest | 

        try {
            apiInstance.addLprIntelbras(nomeDispositivo, addLprIntelbrasRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprIntelbras");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LprApi *apiInstance = [[LprApi alloc] init];
String *nomeDispositivo = FNS_P001_C002; // o nome do dispositivo (default to null)
AddLprIntelbrasRequest *addLprIntelbrasRequest = ; // 

// Encaminha o alerta tratado pela camera Intelbras - firmware BemTeVi
[apiInstance addLprIntelbrasWith:nomeDispositivo
    addLprIntelbrasRequest:addLprIntelbrasRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.LprApi()
var nomeDispositivo = FNS_P001_C002; // {String} o nome do dispositivo
var addLprIntelbrasRequest = ; // {AddLprIntelbrasRequest} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addLprIntelbrasExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LprApi();
            var nomeDispositivo = FNS_P001_C002;  // String | o nome do dispositivo (default to null)
            var addLprIntelbrasRequest = new AddLprIntelbrasRequest(); // AddLprIntelbrasRequest | 

            try {
                // Encaminha o alerta tratado pela camera Intelbras - firmware BemTeVi
                apiInstance.addLprIntelbras(nomeDispositivo, addLprIntelbrasRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling LprApi.addLprIntelbras: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LprApi();
$nomeDispositivo = FNS_P001_C002; // String | o nome do dispositivo
$addLprIntelbrasRequest = ; // AddLprIntelbrasRequest | 

try {
    $api_instance->addLprIntelbras($nomeDispositivo, $addLprIntelbrasRequest);
} catch (Exception $e) {
    echo 'Exception when calling LprApi->addLprIntelbras: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LprApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LprApi->new();
my $nomeDispositivo = FNS_P001_C002; # String | o nome do dispositivo
my $addLprIntelbrasRequest = WWW::OPenAPIClient::Object::AddLprIntelbrasRequest->new(); # AddLprIntelbrasRequest | 

eval {
    $api_instance->addLprIntelbras(nomeDispositivo => $nomeDispositivo, addLprIntelbrasRequest => $addLprIntelbrasRequest);
};
if ($@) {
    warn "Exception when calling LprApi->addLprIntelbras: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LprApi()
nomeDispositivo = FNS_P001_C002 # String | o nome do dispositivo (default to null)
addLprIntelbrasRequest =  # AddLprIntelbrasRequest | 

try:
    # Encaminha o alerta tratado pela camera Intelbras - firmware BemTeVi
    api_instance.add_lpr_intelbras(nomeDispositivo, addLprIntelbrasRequest)
except ApiException as e:
    print("Exception when calling LprApi->addLprIntelbras: %s\n" % e)
extern crate LprApi;

pub fn main() {
    let nomeDispositivo = FNS_P001_C002; // String
    let addLprIntelbrasRequest = ; // AddLprIntelbrasRequest

    let mut context = LprApi::Context::default();
    let result = client.addLprIntelbras(nomeDispositivo, addLprIntelbrasRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
nomeDispositivo*
String
o nome do dispositivo
Required
Body parameters
Name Description
addLprIntelbrasRequest *

Dados da leitura realizada

Responses

addLprMilesight

Este método permite o recebimento e processamento dos bilhetes conforme padrão do dispositivo Milesight. *** (EM DESENVOLVIMENTO) ***

Recebimento e processamento dos bilhetes gerados pela camera Milesight através do método POST. *** (EM DESENVOLVIMENTO) ***


/add/lpr/milesight/{nomeDispositivo}

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/add/lpr/milesight/{nomeDispositivo}" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LprApi;

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

public class LprApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LprApi apiInstance = new LprApi();
        String nomeDispositivo = FNS_P001_C002; // String | o nome do dispositivo
        AddLprMilesightRequest addLprMilesightRequest = ; // AddLprMilesightRequest | 

        try {
            apiInstance.addLprMilesight(nomeDispositivo, addLprMilesightRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprMilesight");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String nomeDispositivo = new String(); // String | o nome do dispositivo
final AddLprMilesightRequest addLprMilesightRequest = new AddLprMilesightRequest(); // AddLprMilesightRequest | 

try {
    final result = await api_instance.addLprMilesight(nomeDispositivo, addLprMilesightRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addLprMilesight: $e\n');
}


import org.openapitools.client.api.LprApi;

public class LprApiExample {
    public static void main(String[] args) {
        LprApi apiInstance = new LprApi();
        String nomeDispositivo = FNS_P001_C002; // String | o nome do dispositivo
        AddLprMilesightRequest addLprMilesightRequest = ; // AddLprMilesightRequest | 

        try {
            apiInstance.addLprMilesight(nomeDispositivo, addLprMilesightRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprMilesight");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LprApi *apiInstance = [[LprApi alloc] init];
String *nomeDispositivo = FNS_P001_C002; // o nome do dispositivo (default to null)
AddLprMilesightRequest *addLprMilesightRequest = ; // 

// Este método permite o recebimento e processamento dos bilhetes conforme padrão do dispositivo Milesight. *** (EM DESENVOLVIMENTO) ***
[apiInstance addLprMilesightWith:nomeDispositivo
    addLprMilesightRequest:addLprMilesightRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.LprApi()
var nomeDispositivo = FNS_P001_C002; // {String} o nome do dispositivo
var addLprMilesightRequest = ; // {AddLprMilesightRequest} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addLprMilesightExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LprApi();
            var nomeDispositivo = FNS_P001_C002;  // String | o nome do dispositivo (default to null)
            var addLprMilesightRequest = new AddLprMilesightRequest(); // AddLprMilesightRequest | 

            try {
                // Este método permite o recebimento e processamento dos bilhetes conforme padrão do dispositivo Milesight. *** (EM DESENVOLVIMENTO) ***
                apiInstance.addLprMilesight(nomeDispositivo, addLprMilesightRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling LprApi.addLprMilesight: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LprApi();
$nomeDispositivo = FNS_P001_C002; // String | o nome do dispositivo
$addLprMilesightRequest = ; // AddLprMilesightRequest | 

try {
    $api_instance->addLprMilesight($nomeDispositivo, $addLprMilesightRequest);
} catch (Exception $e) {
    echo 'Exception when calling LprApi->addLprMilesight: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LprApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LprApi->new();
my $nomeDispositivo = FNS_P001_C002; # String | o nome do dispositivo
my $addLprMilesightRequest = WWW::OPenAPIClient::Object::AddLprMilesightRequest->new(); # AddLprMilesightRequest | 

eval {
    $api_instance->addLprMilesight(nomeDispositivo => $nomeDispositivo, addLprMilesightRequest => $addLprMilesightRequest);
};
if ($@) {
    warn "Exception when calling LprApi->addLprMilesight: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LprApi()
nomeDispositivo = FNS_P001_C002 # String | o nome do dispositivo (default to null)
addLprMilesightRequest =  # AddLprMilesightRequest | 

try:
    # Este método permite o recebimento e processamento dos bilhetes conforme padrão do dispositivo Milesight. *** (EM DESENVOLVIMENTO) ***
    api_instance.add_lpr_milesight(nomeDispositivo, addLprMilesightRequest)
except ApiException as e:
    print("Exception when calling LprApi->addLprMilesight: %s\n" % e)
extern crate LprApi;

pub fn main() {
    let nomeDispositivo = FNS_P001_C002; // String
    let addLprMilesightRequest = ; // AddLprMilesightRequest

    let mut context = LprApi::Context::default();
    let result = client.addLprMilesight(nomeDispositivo, addLprMilesightRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
nomeDispositivo*
String
o nome do dispositivo
Required
Body parameters
Name Description
addLprMilesightRequest *

Dados da leitura realizada

Responses

addLprOpenalpr

Encaminha o alerta tratado pelo OPENALPR

Este método permite o recebimento e processamento dos bilhetes encaminhados pelas câmeras que estão sendo processadas na Nuvem de reconhecimento de placas OpenALPR https://cloud.openalpr.com


/add/lpr/openalpr

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/add/lpr/openalpr" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LprApi;

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

public class LprApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LprApi apiInstance = new LprApi();
        AddLprOpenalprRequest addLprOpenalprRequest = ; // AddLprOpenalprRequest | 

        try {
            apiInstance.addLprOpenalpr(addLprOpenalprRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprOpenalpr");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AddLprOpenalprRequest addLprOpenalprRequest = new AddLprOpenalprRequest(); // AddLprOpenalprRequest | 

try {
    final result = await api_instance.addLprOpenalpr(addLprOpenalprRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addLprOpenalpr: $e\n');
}


import org.openapitools.client.api.LprApi;

public class LprApiExample {
    public static void main(String[] args) {
        LprApi apiInstance = new LprApi();
        AddLprOpenalprRequest addLprOpenalprRequest = ; // AddLprOpenalprRequest | 

        try {
            apiInstance.addLprOpenalpr(addLprOpenalprRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprOpenalpr");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LprApi *apiInstance = [[LprApi alloc] init];
AddLprOpenalprRequest *addLprOpenalprRequest = ; // 

// Encaminha o alerta tratado pelo OPENALPR
[apiInstance addLprOpenalprWith:addLprOpenalprRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.LprApi()
var addLprOpenalprRequest = ; // {AddLprOpenalprRequest} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addLprOpenalprExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LprApi();
            var addLprOpenalprRequest = new AddLprOpenalprRequest(); // AddLprOpenalprRequest | 

            try {
                // Encaminha o alerta tratado pelo OPENALPR
                apiInstance.addLprOpenalpr(addLprOpenalprRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling LprApi.addLprOpenalpr: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LprApi();
$addLprOpenalprRequest = ; // AddLprOpenalprRequest | 

try {
    $api_instance->addLprOpenalpr($addLprOpenalprRequest);
} catch (Exception $e) {
    echo 'Exception when calling LprApi->addLprOpenalpr: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LprApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LprApi->new();
my $addLprOpenalprRequest = WWW::OPenAPIClient::Object::AddLprOpenalprRequest->new(); # AddLprOpenalprRequest | 

eval {
    $api_instance->addLprOpenalpr(addLprOpenalprRequest => $addLprOpenalprRequest);
};
if ($@) {
    warn "Exception when calling LprApi->addLprOpenalpr: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LprApi()
addLprOpenalprRequest =  # AddLprOpenalprRequest | 

try:
    # Encaminha o alerta tratado pelo OPENALPR
    api_instance.add_lpr_openalpr(addLprOpenalprRequest)
except ApiException as e:
    print("Exception when calling LprApi->addLprOpenalpr: %s\n" % e)
extern crate LprApi;

pub fn main() {
    let addLprOpenalprRequest = ; // AddLprOpenalprRequest

    let mut context = LprApi::Context::default();
    let result = client.addLprOpenalpr(addLprOpenalprRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
addLprOpenalprRequest *

Dados da leitura realizada

Responses

addLprPumatronix

Este método permite o recebimento e processamento dos bilhetes conforme aplicação Pumatronix ITSCAM movel.

Recebimento e processamento dos bilhetes recebidos pelas câmeras e dispositivos Pumatronix


/add/lpr/pumatronix

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/add/lpr/pumatronix" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LprApi;

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

public class LprApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LprApi apiInstance = new LprApi();
        AddLprPumatronixRequest addLprPumatronixRequest = ; // AddLprPumatronixRequest | 

        try {
            apiInstance.addLprPumatronix(addLprPumatronixRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprPumatronix");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AddLprPumatronixRequest addLprPumatronixRequest = new AddLprPumatronixRequest(); // AddLprPumatronixRequest | 

try {
    final result = await api_instance.addLprPumatronix(addLprPumatronixRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addLprPumatronix: $e\n');
}


import org.openapitools.client.api.LprApi;

public class LprApiExample {
    public static void main(String[] args) {
        LprApi apiInstance = new LprApi();
        AddLprPumatronixRequest addLprPumatronixRequest = ; // AddLprPumatronixRequest | 

        try {
            apiInstance.addLprPumatronix(addLprPumatronixRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprPumatronix");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LprApi *apiInstance = [[LprApi alloc] init];
AddLprPumatronixRequest *addLprPumatronixRequest = ; // 

// Este método permite o recebimento e processamento dos bilhetes conforme aplicação Pumatronix ITSCAM movel.
[apiInstance addLprPumatronixWith:addLprPumatronixRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.LprApi()
var addLprPumatronixRequest = ; // {AddLprPumatronixRequest} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addLprPumatronixExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LprApi();
            var addLprPumatronixRequest = new AddLprPumatronixRequest(); // AddLprPumatronixRequest | 

            try {
                // Este método permite o recebimento e processamento dos bilhetes conforme aplicação Pumatronix ITSCAM movel.
                apiInstance.addLprPumatronix(addLprPumatronixRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling LprApi.addLprPumatronix: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LprApi();
$addLprPumatronixRequest = ; // AddLprPumatronixRequest | 

try {
    $api_instance->addLprPumatronix($addLprPumatronixRequest);
} catch (Exception $e) {
    echo 'Exception when calling LprApi->addLprPumatronix: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LprApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LprApi->new();
my $addLprPumatronixRequest = WWW::OPenAPIClient::Object::AddLprPumatronixRequest->new(); # AddLprPumatronixRequest | 

eval {
    $api_instance->addLprPumatronix(addLprPumatronixRequest => $addLprPumatronixRequest);
};
if ($@) {
    warn "Exception when calling LprApi->addLprPumatronix: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LprApi()
addLprPumatronixRequest =  # AddLprPumatronixRequest | 

try:
    # Este método permite o recebimento e processamento dos bilhetes conforme aplicação Pumatronix ITSCAM movel.
    api_instance.add_lpr_pumatronix(addLprPumatronixRequest)
except ApiException as e:
    print("Exception when calling LprApi->addLprPumatronix: %s\n" % e)
extern crate LprApi;

pub fn main() {
    let addLprPumatronixRequest = ; // AddLprPumatronixRequest

    let mut context = LprApi::Context::default();
    let result = client.addLprPumatronix(addLprPumatronixRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
addLprPumatronixRequest *

Dados da leitura realizada

Responses

addLprRaw

Este método permite o recebimento e processamento dos bilhetes conforme padrão da SSP - DATA e HORA LOCAL.

Recebimento e processamento dos bilhetes recebidos de forma genérica e não tratados previamente - DATA e HORA LOCAL


/add/lpr/raw

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/add/lpr/raw" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LprApi;

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

public class LprApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LprApi apiInstance = new LprApi();
        AddLprRawRequest addLprRawRequest = ; // AddLprRawRequest | 

        try {
            apiInstance.addLprRaw(addLprRawRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprRaw");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AddLprRawRequest addLprRawRequest = new AddLprRawRequest(); // AddLprRawRequest | 

try {
    final result = await api_instance.addLprRaw(addLprRawRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addLprRaw: $e\n');
}


import org.openapitools.client.api.LprApi;

public class LprApiExample {
    public static void main(String[] args) {
        LprApi apiInstance = new LprApi();
        AddLprRawRequest addLprRawRequest = ; // AddLprRawRequest | 

        try {
            apiInstance.addLprRaw(addLprRawRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprRaw");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LprApi *apiInstance = [[LprApi alloc] init];
AddLprRawRequest *addLprRawRequest = ; // 

// Este método permite o recebimento e processamento dos bilhetes conforme padrão da SSP - DATA e HORA LOCAL.
[apiInstance addLprRawWith:addLprRawRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.LprApi()
var addLprRawRequest = ; // {AddLprRawRequest} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addLprRawExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LprApi();
            var addLprRawRequest = new AddLprRawRequest(); // AddLprRawRequest | 

            try {
                // Este método permite o recebimento e processamento dos bilhetes conforme padrão da SSP - DATA e HORA LOCAL.
                apiInstance.addLprRaw(addLprRawRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling LprApi.addLprRaw: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LprApi();
$addLprRawRequest = ; // AddLprRawRequest | 

try {
    $api_instance->addLprRaw($addLprRawRequest);
} catch (Exception $e) {
    echo 'Exception when calling LprApi->addLprRaw: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LprApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LprApi->new();
my $addLprRawRequest = WWW::OPenAPIClient::Object::AddLprRawRequest->new(); # AddLprRawRequest | 

eval {
    $api_instance->addLprRaw(addLprRawRequest => $addLprRawRequest);
};
if ($@) {
    warn "Exception when calling LprApi->addLprRaw: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LprApi()
addLprRawRequest =  # AddLprRawRequest | 

try:
    # Este método permite o recebimento e processamento dos bilhetes conforme padrão da SSP - DATA e HORA LOCAL.
    api_instance.add_lpr_raw(addLprRawRequest)
except ApiException as e:
    print("Exception when calling LprApi->addLprRaw: %s\n" % e)
extern crate LprApi;

pub fn main() {
    let addLprRawRequest = ; // AddLprRawRequest

    let mut context = LprApi::Context::default();
    let result = client.addLprRaw(addLprRawRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
addLprRawRequest *

Dados da leitura realizada

Responses

addLprRawUTC

Este método permite o recebimento e processamento dos bilhetes conforme padrão da SSP - DATA e HORA UTC.

Recebimento e processamento dos bilhetes recebidos de forma genérica e não tratados previamente - DATA e HORA UTC.


/add/lpr/rawutc

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/add/lpr/rawutc" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LprApi;

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

public class LprApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LprApi apiInstance = new LprApi();
        AddLprRawUTCRequest addLprRawUTCRequest = ; // AddLprRawUTCRequest | 

        try {
            apiInstance.addLprRawUTC(addLprRawUTCRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprRawUTC");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AddLprRawUTCRequest addLprRawUTCRequest = new AddLprRawUTCRequest(); // AddLprRawUTCRequest | 

try {
    final result = await api_instance.addLprRawUTC(addLprRawUTCRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addLprRawUTC: $e\n');
}


import org.openapitools.client.api.LprApi;

public class LprApiExample {
    public static void main(String[] args) {
        LprApi apiInstance = new LprApi();
        AddLprRawUTCRequest addLprRawUTCRequest = ; // AddLprRawUTCRequest | 

        try {
            apiInstance.addLprRawUTC(addLprRawUTCRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprRawUTC");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LprApi *apiInstance = [[LprApi alloc] init];
AddLprRawUTCRequest *addLprRawUTCRequest = ; // 

// Este método permite o recebimento e processamento dos bilhetes conforme padrão da SSP - DATA e HORA UTC.
[apiInstance addLprRawUTCWith:addLprRawUTCRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.LprApi()
var addLprRawUTCRequest = ; // {AddLprRawUTCRequest} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addLprRawUTCExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LprApi();
            var addLprRawUTCRequest = new AddLprRawUTCRequest(); // AddLprRawUTCRequest | 

            try {
                // Este método permite o recebimento e processamento dos bilhetes conforme padrão da SSP - DATA e HORA UTC.
                apiInstance.addLprRawUTC(addLprRawUTCRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling LprApi.addLprRawUTC: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LprApi();
$addLprRawUTCRequest = ; // AddLprRawUTCRequest | 

try {
    $api_instance->addLprRawUTC($addLprRawUTCRequest);
} catch (Exception $e) {
    echo 'Exception when calling LprApi->addLprRawUTC: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LprApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LprApi->new();
my $addLprRawUTCRequest = WWW::OPenAPIClient::Object::AddLprRawUTCRequest->new(); # AddLprRawUTCRequest | 

eval {
    $api_instance->addLprRawUTC(addLprRawUTCRequest => $addLprRawUTCRequest);
};
if ($@) {
    warn "Exception when calling LprApi->addLprRawUTC: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LprApi()
addLprRawUTCRequest =  # AddLprRawUTCRequest | 

try:
    # Este método permite o recebimento e processamento dos bilhetes conforme padrão da SSP - DATA e HORA UTC.
    api_instance.add_lpr_raw_utc(addLprRawUTCRequest)
except ApiException as e:
    print("Exception when calling LprApi->addLprRawUTC: %s\n" % e)
extern crate LprApi;

pub fn main() {
    let addLprRawUTCRequest = ; // AddLprRawUTCRequest

    let mut context = LprApi::Context::default();
    let result = client.addLprRawUTC(addLprRawUTCRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
addLprRawUTCRequest *

Dados da leitura realizada

Responses

addLprSPID

Encaminha o alerta tratado pelo SPID

Recebimento e processamento dos bilhetes recebidos via SPID


/add/lpr/spid

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/add/lpr/spid" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LprApi;

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

public class LprApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LprApi apiInstance = new LprApi();
        AddLprSPIDRequest addLprSPIDRequest = ; // AddLprSPIDRequest | 

        try {
            apiInstance.addLprSPID(addLprSPIDRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprSPID");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AddLprSPIDRequest addLprSPIDRequest = new AddLprSPIDRequest(); // AddLprSPIDRequest | 

try {
    final result = await api_instance.addLprSPID(addLprSPIDRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addLprSPID: $e\n');
}


import org.openapitools.client.api.LprApi;

public class LprApiExample {
    public static void main(String[] args) {
        LprApi apiInstance = new LprApi();
        AddLprSPIDRequest addLprSPIDRequest = ; // AddLprSPIDRequest | 

        try {
            apiInstance.addLprSPID(addLprSPIDRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LprApi#addLprSPID");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LprApi *apiInstance = [[LprApi alloc] init];
AddLprSPIDRequest *addLprSPIDRequest = ; // 

// Encaminha o alerta tratado pelo SPID
[apiInstance addLprSPIDWith:addLprSPIDRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.LprApi()
var addLprSPIDRequest = ; // {AddLprSPIDRequest} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addLprSPIDExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LprApi();
            var addLprSPIDRequest = new AddLprSPIDRequest(); // AddLprSPIDRequest | 

            try {
                // Encaminha o alerta tratado pelo SPID
                apiInstance.addLprSPID(addLprSPIDRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling LprApi.addLprSPID: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LprApi();
$addLprSPIDRequest = ; // AddLprSPIDRequest | 

try {
    $api_instance->addLprSPID($addLprSPIDRequest);
} catch (Exception $e) {
    echo 'Exception when calling LprApi->addLprSPID: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LprApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LprApi->new();
my $addLprSPIDRequest = WWW::OPenAPIClient::Object::AddLprSPIDRequest->new(); # AddLprSPIDRequest | 

eval {
    $api_instance->addLprSPID(addLprSPIDRequest => $addLprSPIDRequest);
};
if ($@) {
    warn "Exception when calling LprApi->addLprSPID: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LprApi()
addLprSPIDRequest =  # AddLprSPIDRequest | 

try:
    # Encaminha o alerta tratado pelo SPID
    api_instance.add_lpr_spid(addLprSPIDRequest)
except ApiException as e:
    print("Exception when calling LprApi->addLprSPID: %s\n" % e)
extern crate LprApi;

pub fn main() {
    let addLprSPIDRequest = ; // AddLprSPIDRequest

    let mut context = LprApi::Context::default();
    let result = client.addLprSPID(addLprSPIDRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
addLprSPIDRequest *

Dados da leitura realizada

Responses

Notification

notificationDeviceInfo

Método padrão de comunicação dos dados do dispositivo das câmeras intelbras

Recebimento e retorno de informações para as câmeras intelbras


/NotificationInfo/DeviceInfo

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/NotificationInfo/DeviceInfo" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.NotificationApi;

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

public class NotificationApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        NotificationApi apiInstance = new NotificationApi();
        Object body = Object; // Object | 

        try {
            apiInstance.notificationDeviceInfo(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#notificationDeviceInfo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Object body = new Object(); // Object | 

try {
    final result = await api_instance.notificationDeviceInfo(body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->notificationDeviceInfo: $e\n');
}


import org.openapitools.client.api.NotificationApi;

public class NotificationApiExample {
    public static void main(String[] args) {
        NotificationApi apiInstance = new NotificationApi();
        Object body = Object; // Object | 

        try {
            apiInstance.notificationDeviceInfo(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#notificationDeviceInfo");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
NotificationApi *apiInstance = [[NotificationApi alloc] init];
Object *body = Object; // 

// Método padrão de comunicação dos dados do dispositivo das câmeras intelbras
[apiInstance notificationDeviceInfoWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.NotificationApi()
var body = Object; // {Object} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class notificationDeviceInfoExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new NotificationApi();
            var body = Object;  // Object | 

            try {
                // Método padrão de comunicação dos dados do dispositivo das câmeras intelbras
                apiInstance.notificationDeviceInfo(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling NotificationApi.notificationDeviceInfo: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\NotificationApi();
$body = Object; // Object | 

try {
    $api_instance->notificationDeviceInfo($body);
} catch (Exception $e) {
    echo 'Exception when calling NotificationApi->notificationDeviceInfo: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::NotificationApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::NotificationApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->notificationDeviceInfo(body => $body);
};
if ($@) {
    warn "Exception when calling NotificationApi->notificationDeviceInfo: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.NotificationApi()
body = Object # Object | 

try:
    # Método padrão de comunicação dos dados do dispositivo das câmeras intelbras
    api_instance.notification_device_info(body)
except ApiException as e:
    print("Exception when calling NotificationApi->notificationDeviceInfo: %s\n" % e)
extern crate NotificationApi;

pub fn main() {
    let body = Object; // Object

    let mut context = NotificationApi::Context::default();
    let result = client.notificationDeviceInfo(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body *

Dados da leitura realizada

Responses

notificationKeepAlive

Método padrão de keepalive dos dispositivos intelbras

Recebimento e retorno de keepalive para as câmeras intelbras


/NotificationInfo/KeepAlive

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "https://api-sensores.pm.sc.gov.br:4443/NotificationInfo/KeepAlive" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.NotificationApi;

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

public class NotificationApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        NotificationApi apiInstance = new NotificationApi();
        Object body = Object; // Object | 

        try {
            apiInstance.notificationKeepAlive(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#notificationKeepAlive");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Object body = new Object(); // Object | 

try {
    final result = await api_instance.notificationKeepAlive(body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->notificationKeepAlive: $e\n');
}


import org.openapitools.client.api.NotificationApi;

public class NotificationApiExample {
    public static void main(String[] args) {
        NotificationApi apiInstance = new NotificationApi();
        Object body = Object; // Object | 

        try {
            apiInstance.notificationKeepAlive(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#notificationKeepAlive");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
NotificationApi *apiInstance = [[NotificationApi alloc] init];
Object *body = Object; // 

// Método padrão de keepalive dos dispositivos intelbras
[apiInstance notificationKeepAliveWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BravoApi = require('bravo_api');

// Create an instance of the API class
var api = new BravoApi.NotificationApi()
var body = Object; // {Object} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class notificationKeepAliveExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new NotificationApi();
            var body = Object;  // Object | 

            try {
                // Método padrão de keepalive dos dispositivos intelbras
                apiInstance.notificationKeepAlive(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling NotificationApi.notificationKeepAlive: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\NotificationApi();
$body = Object; // Object | 

try {
    $api_instance->notificationKeepAlive($body);
} catch (Exception $e) {
    echo 'Exception when calling NotificationApi->notificationKeepAlive: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::NotificationApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::NotificationApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->notificationKeepAlive(body => $body);
};
if ($@) {
    warn "Exception when calling NotificationApi->notificationKeepAlive: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.NotificationApi()
body = Object # Object | 

try:
    # Método padrão de keepalive dos dispositivos intelbras
    api_instance.notification_keep_alive(body)
except ApiException as e:
    print("Exception when calling NotificationApi->notificationKeepAlive: %s\n" % e)
extern crate NotificationApi;

pub fn main() {
    let body = Object; // Object

    let mut context = NotificationApi::Context::default();
    let result = client.notificationKeepAlive(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body *

Dados da leitura realizada

Responses