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

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

public class INFOSApiExample {

    public static void main(String[] args) {
        
        INFOSApi apiInstance = new INFOSApi();
        String version = version_example; // String | Version de l'API
        String idParcelle = idParcelle_example; // String | L'ID de la parcelle à retourner
        try {
            apiInstance.getInfosLocParcelle(version, idParcelle);
        } catch (ApiException e) {
            System.err.println("Exception when calling INFOSApi#getInfosLocParcelle");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.INFOSApi;

public class INFOSApiExample {

    public static void main(String[] args) {
        INFOSApi apiInstance = new INFOSApi();
        String version = version_example; // String | Version de l'API
        String idParcelle = idParcelle_example; // String | L'ID de la parcelle à retourner
        try {
            apiInstance.getInfosLocParcelle(version, idParcelle);
        } catch (ApiException e) {
            System.err.println("Exception when calling INFOSApi#getInfosLocParcelle");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // Version de l'API
String *idParcelle = idParcelle_example; // L'ID de la parcelle à retourner

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

// Fonction qui fournit des informations de localisation d'une parcelle
[apiInstance getInfosLocParcelleWith:version
    idParcelle:idParcelle
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ApiRestUrba = require('api_rest_urba');

var api = new ApiRestUrba.INFOSApi()

var version = version_example; // {String} Version de l'API

var idParcelle = idParcelle_example; // {String} L'ID de la parcelle à retourner


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

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

namespace Example
{
    public class getInfosLocParcelleExample
    {
        public void main()
        {
            
            var apiInstance = new INFOSApi();
            var version = version_example;  // String | Version de l'API
            var idParcelle = idParcelle_example;  // String | L'ID de la parcelle à retourner

            try
            {
                // Fonction qui fournit des informations de localisation d'une parcelle
                apiInstance.getInfosLocParcelle(version, idParcelle);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling INFOSApi.getInfosLocParcelle: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\INFOSApi();
$version = version_example; // String | Version de l'API
$idParcelle = idParcelle_example; // String | L'ID de la parcelle à retourner

try {
    $api_instance->getInfosLocParcelle($version, $idParcelle);
} catch (Exception $e) {
    echo 'Exception when calling INFOSApi->getInfosLocParcelle: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::INFOSApi->new();
my $version = version_example; # String | Version de l'API
my $idParcelle = idParcelle_example; # String | L'ID de la parcelle à retourner

eval { 
    $api_instance->getInfosLocParcelle(version => $version, idParcelle => $idParcelle);
};
if ($@) {
    warn "Exception when calling INFOSApi->getInfosLocParcelle: $@\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.INFOSApi()
version = version_example # String | Version de l'API
idParcelle = idParcelle_example # String | L'ID de la parcelle à retourner

try: 
    # Fonction qui fournit des informations de localisation d'une parcelle
    api_instance.get_infos_loc_parcelle(version, idParcelle)
except ApiException as e:
    print("Exception when calling INFOSApi->getInfosLocParcelle: %s\n" % e)

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

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

public class NRUApiExample {

    public static void main(String[] args) {
        
        NRUApi apiInstance = new NRUApi();
        String version = version_example; // String | Version de l'API
        String idParcelle = idParcelle_example; // String | L'ID de la parcelle à retourner
        String format = format_example; // String | Format de retour souhaité
        try {
            apiInstance.getNRU(version, idParcelle, format);
        } catch (ApiException e) {
            System.err.println("Exception when calling NRUApi#getNRU");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.NRUApi;

public class NRUApiExample {

    public static void main(String[] args) {
        NRUApi apiInstance = new NRUApi();
        String version = version_example; // String | Version de l'API
        String idParcelle = idParcelle_example; // String | L'ID de la parcelle à retourner
        String format = format_example; // String | Format de retour souhaité
        try {
            apiInstance.getNRU(version, idParcelle, format);
        } catch (ApiException e) {
            System.err.println("Exception when calling NRUApi#getNRU");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // Version de l'API
String *idParcelle = idParcelle_example; // L'ID de la parcelle à retourner
String *format = format_example; // Format de retour souhaité

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

// Fonction qui génére le HTML/PDF d'une NRU
[apiInstance getNRUWith:version
    idParcelle:idParcelle
    format:format
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ApiRestUrba = require('api_rest_urba');

var api = new ApiRestUrba.NRUApi()

var version = version_example; // {String} Version de l'API

var idParcelle = idParcelle_example; // {String} L'ID de la parcelle à retourner

var format = format_example; // {String} Format de retour souhaité


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

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

namespace Example
{
    public class getNRUExample
    {
        public void main()
        {
            
            var apiInstance = new NRUApi();
            var version = version_example;  // String | Version de l'API
            var idParcelle = idParcelle_example;  // String | L'ID de la parcelle à retourner
            var format = format_example;  // String | Format de retour souhaité

            try
            {
                // Fonction qui génére le HTML/PDF d'une NRU
                apiInstance.getNRU(version, idParcelle, format);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NRUApi.getNRU: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\NRUApi();
$version = version_example; // String | Version de l'API
$idParcelle = idParcelle_example; // String | L'ID de la parcelle à retourner
$format = format_example; // String | Format de retour souhaité

try {
    $api_instance->getNRU($version, $idParcelle, $format);
} catch (Exception $e) {
    echo 'Exception when calling NRUApi->getNRU: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::NRUApi->new();
my $version = version_example; # String | Version de l'API
my $idParcelle = idParcelle_example; # String | L'ID de la parcelle à retourner
my $format = format_example; # String | Format de retour souhaité

eval { 
    $api_instance->getNRU(version => $version, idParcelle => $idParcelle, format => $format);
};
if ($@) {
    warn "Exception when calling NRUApi->getNRU: $@\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.NRUApi()
version = version_example # String | Version de l'API
idParcelle = idParcelle_example # String | L'ID de la parcelle à retourner
format = format_example # String | Format de retour souhaité

try: 
    # Fonction qui génére le HTML/PDF d'une NRU
    api_instance.get_nru(version, idParcelle, format)
except ApiException as e:
    print("Exception when calling NRUApi->getNRU: %s\n" % e)

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

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

public class RUApiExample {

    public static void main(String[] args) {
        
        RUApi apiInstance = new RUApi();
        String version = version_example; // String | Version de l'API
        String codeCommune = codeCommune_example; // String | Code insee de la commune à retourner
        Integer limit = 56; // Integer | Nombre de résultat à retourner
        Integer offset = 56; // Integer | Nombre à partir du quel il faut retourner les résultats
        try {
            apiInstance.getRUCommune(version, codeCommune, limit, offset);
        } catch (ApiException e) {
            System.err.println("Exception when calling RUApi#getRUCommune");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RUApi;

public class RUApiExample {

    public static void main(String[] args) {
        RUApi apiInstance = new RUApi();
        String version = version_example; // String | Version de l'API
        String codeCommune = codeCommune_example; // String | Code insee de la commune à retourner
        Integer limit = 56; // Integer | Nombre de résultat à retourner
        Integer offset = 56; // Integer | Nombre à partir du quel il faut retourner les résultats
        try {
            apiInstance.getRUCommune(version, codeCommune, limit, offset);
        } catch (ApiException e) {
            System.err.println("Exception when calling RUApi#getRUCommune");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // Version de l'API
String *codeCommune = codeCommune_example; // Code insee de la commune à retourner
Integer *limit = 56; // Nombre de résultat à retourner (optional)
Integer *offset = 56; // Nombre à partir du quel il faut retourner les résultats (optional)

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

// Fonction qui diffuse les RU à la commune
[apiInstance getRUCommuneWith:version
    codeCommune:codeCommune
    limit:limit
    offset:offset
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ApiRestUrba = require('api_rest_urba');

var api = new ApiRestUrba.RUApi()

var version = version_example; // {String} Version de l'API

var codeCommune = codeCommune_example; // {String} Code insee de la commune à retourner

var opts = { 
  'limit': 56, // {Integer} Nombre de résultat à retourner
  'offset': 56 // {Integer} Nombre à partir du quel il faut retourner les résultats
};

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

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

namespace Example
{
    public class getRUCommuneExample
    {
        public void main()
        {
            
            var apiInstance = new RUApi();
            var version = version_example;  // String | Version de l'API
            var codeCommune = codeCommune_example;  // String | Code insee de la commune à retourner
            var limit = 56;  // Integer | Nombre de résultat à retourner (optional) 
            var offset = 56;  // Integer | Nombre à partir du quel il faut retourner les résultats (optional) 

            try
            {
                // Fonction qui diffuse les RU à la commune
                apiInstance.getRUCommune(version, codeCommune, limit, offset);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RUApi.getRUCommune: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RUApi();
$version = version_example; // String | Version de l'API
$codeCommune = codeCommune_example; // String | Code insee de la commune à retourner
$limit = 56; // Integer | Nombre de résultat à retourner
$offset = 56; // Integer | Nombre à partir du quel il faut retourner les résultats

try {
    $api_instance->getRUCommune($version, $codeCommune, $limit, $offset);
} catch (Exception $e) {
    echo 'Exception when calling RUApi->getRUCommune: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::RUApi->new();
my $version = version_example; # String | Version de l'API
my $codeCommune = codeCommune_example; # String | Code insee de la commune à retourner
my $limit = 56; # Integer | Nombre de résultat à retourner
my $offset = 56; # Integer | Nombre à partir du quel il faut retourner les résultats

eval { 
    $api_instance->getRUCommune(version => $version, codeCommune => $codeCommune, limit => $limit, offset => $offset);
};
if ($@) {
    warn "Exception when calling RUApi->getRUCommune: $@\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.RUApi()
version = version_example # String | Version de l'API
codeCommune = codeCommune_example # String | Code insee de la commune à retourner
limit = 56 # Integer | Nombre de résultat à retourner (optional)
offset = 56 # Integer | Nombre à partir du quel il faut retourner les résultats (optional)

try: 
    # Fonction qui diffuse les RU à la commune
    api_instance.get_ru_commune(version, codeCommune, limit=limit, offset=offset)
except ApiException as e:
    print("Exception when calling RUApi->getRUCommune: %s\n" % e)

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

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

public class RUApiExample {

    public static void main(String[] args) {
        
        RUApi apiInstance = new RUApi();
        String version = version_example; // String | Version de l'API
        String idParcelle = idParcelle_example; // String | L'ID de la parcelle à retourner
        Integer limit = 56; // Integer | Nombre de résultat à retourner
        Integer offset = 56; // Integer | Nombre à partir du quel il faut retourner les résultats
        try {
            apiInstance.getRUParcelle(version, idParcelle, limit, offset);
        } catch (ApiException e) {
            System.err.println("Exception when calling RUApi#getRUParcelle");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RUApi;

public class RUApiExample {

    public static void main(String[] args) {
        RUApi apiInstance = new RUApi();
        String version = version_example; // String | Version de l'API
        String idParcelle = idParcelle_example; // String | L'ID de la parcelle à retourner
        Integer limit = 56; // Integer | Nombre de résultat à retourner
        Integer offset = 56; // Integer | Nombre à partir du quel il faut retourner les résultats
        try {
            apiInstance.getRUParcelle(version, idParcelle, limit, offset);
        } catch (ApiException e) {
            System.err.println("Exception when calling RUApi#getRUParcelle");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // Version de l'API
String *idParcelle = idParcelle_example; // L'ID de la parcelle à retourner
Integer *limit = 56; // Nombre de résultat à retourner (optional)
Integer *offset = 56; // Nombre à partir du quel il faut retourner les résultats (optional)

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

// Fonction qui diffuse les RU à la parcelle
[apiInstance getRUParcelleWith:version
    idParcelle:idParcelle
    limit:limit
    offset:offset
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ApiRestUrba = require('api_rest_urba');

var api = new ApiRestUrba.RUApi()

var version = version_example; // {String} Version de l'API

var idParcelle = idParcelle_example; // {String} L'ID de la parcelle à retourner

var opts = { 
  'limit': 56, // {Integer} Nombre de résultat à retourner
  'offset': 56 // {Integer} Nombre à partir du quel il faut retourner les résultats
};

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

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

namespace Example
{
    public class getRUParcelleExample
    {
        public void main()
        {
            
            var apiInstance = new RUApi();
            var version = version_example;  // String | Version de l'API
            var idParcelle = idParcelle_example;  // String | L'ID de la parcelle à retourner
            var limit = 56;  // Integer | Nombre de résultat à retourner (optional) 
            var offset = 56;  // Integer | Nombre à partir du quel il faut retourner les résultats (optional) 

            try
            {
                // Fonction qui diffuse les RU à la parcelle
                apiInstance.getRUParcelle(version, idParcelle, limit, offset);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RUApi.getRUParcelle: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RUApi();
$version = version_example; // String | Version de l'API
$idParcelle = idParcelle_example; // String | L'ID de la parcelle à retourner
$limit = 56; // Integer | Nombre de résultat à retourner
$offset = 56; // Integer | Nombre à partir du quel il faut retourner les résultats

try {
    $api_instance->getRUParcelle($version, $idParcelle, $limit, $offset);
} catch (Exception $e) {
    echo 'Exception when calling RUApi->getRUParcelle: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::RUApi->new();
my $version = version_example; # String | Version de l'API
my $idParcelle = idParcelle_example; # String | L'ID de la parcelle à retourner
my $limit = 56; # Integer | Nombre de résultat à retourner
my $offset = 56; # Integer | Nombre à partir du quel il faut retourner les résultats

eval { 
    $api_instance->getRUParcelle(version => $version, idParcelle => $idParcelle, limit => $limit, offset => $offset);
};
if ($@) {
    warn "Exception when calling RUApi->getRUParcelle: $@\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.RUApi()
version = version_example # String | Version de l'API
idParcelle = idParcelle_example # String | L'ID de la parcelle à retourner
limit = 56 # Integer | Nombre de résultat à retourner (optional)
offset = 56 # Integer | Nombre à partir du quel il faut retourner les résultats (optional)

try: 
    # Fonction qui diffuse les RU à la parcelle
    api_instance.get_ru_parcelle(version, idParcelle, limit=limit, offset=offset)
except ApiException as e:
    print("Exception when calling RUApi->getRUParcelle: %s\n" % e)

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

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

public class RUApiExample {

    public static void main(String[] args) {
        
        RUApi apiInstance = new RUApi();
        String version = version_example; // String | Version de l'API
        try {
            apiInstance.getRUZip(version);
        } catch (ApiException e) {
            System.err.println("Exception when calling RUApi#getRUZip");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RUApi;

public class RUApiExample {

    public static void main(String[] args) {
        RUApi apiInstance = new RUApi();
        String version = version_example; // String | Version de l'API
        try {
            apiInstance.getRUZip(version);
        } catch (ApiException e) {
            System.err.println("Exception when calling RUApi#getRUZip");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // Version de l'API

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

// Fonction qui diffuse les RU au complet
[apiInstance getRUZipWith:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ApiRestUrba = require('api_rest_urba');

var api = new ApiRestUrba.RUApi()

var version = version_example; // {String} Version de l'API


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

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

namespace Example
{
    public class getRUZipExample
    {
        public void main()
        {
            
            var apiInstance = new RUApi();
            var version = version_example;  // String | Version de l'API

            try
            {
                // Fonction qui diffuse les RU au complet
                apiInstance.getRUZip(version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RUApi.getRUZip: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\RUApi();
$version = version_example; // String | Version de l'API

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

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

my $api_instance = WWW::SwaggerClient::RUApi->new();
my $version = version_example; # String | Version de l'API

eval { 
    $api_instance->getRUZip(version => $version);
};
if ($@) {
    warn "Exception when calling RUApi->getRUZip: $@\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.RUApi()
version = version_example # String | Version de l'API

try: 
    # Fonction qui diffuse les RU au complet
    api_instance.get_ru_zip(version)
except ApiException as e:
    print("Exception when calling RUApi->getRUZip: %s\n" % e)