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

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

public class DebugApiExample {

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

import io.swagger.client.api.DebugApi;

public class DebugApiExample {

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

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

// Return "debug-level" information about the gepetto service execution environment
[apiInstance getDebugWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GepettoApiDocumentation = require('gepetto_api_documentation');

var api = new GepettoApiDocumentation.DebugApi()

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

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

namespace Example
{
    public class getDebugExample
    {
        public void main()
        {
            
            var apiInstance = new DebugApi();

            try
            {
                // Return "debug-level" information about the gepetto service execution environment
                'String' result = apiInstance.getDebug();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DebugApi.getDebug: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getDebug();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DebugApi->getDebug: $@\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.DebugApi()

try: 
    # Return "debug-level" information about the gepetto service execution environment
    api_response = api_instance.get_debug()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DebugApi->getDebug: %s\n" % e)

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

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

public class GotoApiExample {

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

import io.swagger.client.api.GotoApi;

public class GotoApiExample {

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

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

// Go to a URL without returning page contents
[apiInstance getGotoWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GepettoApiDocumentation = require('gepetto_api_documentation');

var api = new GepettoApiDocumentation.GotoApi()

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

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

namespace Example
{
    public class getGotoExample
    {
        public void main()
        {
            
            var apiInstance = new GotoApi();

            try
            {
                // Go to a URL without returning page contents
                'String' result = apiInstance.getGoto();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GotoApi.getGoto: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getGoto();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GotoApi->getGoto: $@\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.GotoApi()

try: 
    # Go to a URL without returning page contents
    api_response = api_instance.get_goto()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GotoApi->getGoto: %s\n" % e)

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

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

public class PageMetricsApiExample {

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

import io.swagger.client.api.PageMetricsApi;

public class PageMetricsApiExample {

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

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

// Retrieve page metrics
[apiInstance getPageMetricsWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GepettoApiDocumentation = require('gepetto_api_documentation');

var api = new GepettoApiDocumentation.PageMetricsApi()

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

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

namespace Example
{
    public class getPageMetricsExample
    {
        public void main()
        {
            
            var apiInstance = new PageMetricsApi();

            try
            {
                // Retrieve page metrics
                'String' result = apiInstance.getPageMetrics();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PageMetricsApi.getPageMetrics: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getPageMetrics();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PageMetricsApi->getPageMetrics: $@\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.PageMetricsApi()

try: 
    # Retrieve page metrics
    api_response = api_instance.get_page_metrics()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PageMetricsApi->getPageMetrics: %s\n" % e)

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

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

public class PageTitleApiExample {

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

import io.swagger.client.api.PageTitleApi;

public class PageTitleApiExample {

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

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

// Retrieve title of the current page
[apiInstance getPageTitleWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GepettoApiDocumentation = require('gepetto_api_documentation');

var api = new GepettoApiDocumentation.PageTitleApi()

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

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

namespace Example
{
    public class getPageTitleExample
    {
        public void main()
        {
            
            var apiInstance = new PageTitleApi();

            try
            {
                // Retrieve title of the current page
                'String' result = apiInstance.getPageTitle();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PageTitleApi.getPageTitle: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getPageTitle();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PageTitleApi->getPageTitle: $@\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.PageTitleApi()

try: 
    # Retrieve title of the current page
    api_response = api_instance.get_page_title()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PageTitleApi->getPageTitle: %s\n" % e)

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

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

public class PageUrlApiExample {

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

import io.swagger.client.api.PageUrlApi;

public class PageUrlApiExample {

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

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

// Retrieve URL of the current page
[apiInstance getPageUrlWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GepettoApiDocumentation = require('gepetto_api_documentation');

var api = new GepettoApiDocumentation.PageUrlApi()

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

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

namespace Example
{
    public class getPageUrlExample
    {
        public void main()
        {
            
            var apiInstance = new PageUrlApi();

            try
            {
                // Retrieve URL of the current page
                'String' result = apiInstance.getPageUrl();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PageUrlApi.getPageUrl: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getPageUrl();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PageUrlApi->getPageUrl: $@\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.PageUrlApi()

try: 
    # Retrieve URL of the current page
    api_response = api_instance.get_page_url()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PageUrlApi->getPageUrl: %s\n" % e)

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

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

public class PingApiExample {

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

import io.swagger.client.api.PingApi;

public class PingApiExample {

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

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

// Test if the gepetto service is up
[apiInstance getPingWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GepettoApiDocumentation = require('gepetto_api_documentation');

var api = new GepettoApiDocumentation.PingApi()

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

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

namespace Example
{
    public class getPingExample
    {
        public void main()
        {
            
            var apiInstance = new PingApi();

            try
            {
                // Test if the gepetto service is up
                'String' result = apiInstance.getPing();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PingApi.getPing: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getPing();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PingApi->getPing: $@\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.PingApi()

try: 
    # Test if the gepetto service is up
    api_response = api_instance.get_ping()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PingApi->getPing: %s\n" % e)

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

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

public class RenderHarApiExample {

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

import io.swagger.client.api.RenderHarApi;

public class RenderHarApiExample {

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

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

// Visit a URL in a javascript context and return HAR JSON with all of the requests metadata
[apiInstance getRenderHarWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GepettoApiDocumentation = require('gepetto_api_documentation');

var api = new GepettoApiDocumentation.RenderHarApi()

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

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

namespace Example
{
    public class getRenderHarExample
    {
        public void main()
        {
            
            var apiInstance = new RenderHarApi();

            try
            {
                // Visit a URL in a javascript context and return HAR JSON with all of the requests metadata
                'String' result = apiInstance.getRenderHar();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RenderHarApi.getRenderHar: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getRenderHar();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RenderHarApi->getRenderHar: $@\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.RenderHarApi()

try: 
    # Visit a URL in a javascript context and return HAR JSON with all of the requests metadata
    api_response = api_instance.get_render_har()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RenderHarApi->getRenderHar: %s\n" % e)

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

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

public class RenderHtmlApiExample {

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

import io.swagger.client.api.RenderHtmlApi;

public class RenderHtmlApiExample {

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

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

// Visit a URL in a javascript context and return the resultant document HTML
[apiInstance getRenderHtmlWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GepettoApiDocumentation = require('gepetto_api_documentation');

var api = new GepettoApiDocumentation.RenderHtmlApi()

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

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

namespace Example
{
    public class getRenderHtmlExample
    {
        public void main()
        {
            
            var apiInstance = new RenderHtmlApi();

            try
            {
                // Visit a URL in a javascript context and return the resultant document HTML
                'String' result = apiInstance.getRenderHtml();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RenderHtmlApi.getRenderHtml: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getRenderHtml();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RenderHtmlApi->getRenderHtml: $@\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.RenderHtmlApi()

try: 
    # Visit a URL in a javascript context and return the resultant document HTML
    api_response = api_instance.get_render_html()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RenderHtmlApi->getRenderHtml: %s\n" % e)

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

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

public class RenderPdfApiExample {

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

import io.swagger.client.api.RenderPdfApi;

public class RenderPdfApiExample {

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

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

// Visit a URL in a javascript context and return the resultant document in PDF form
[apiInstance getRenderPdfWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GepettoApiDocumentation = require('gepetto_api_documentation');

var api = new GepettoApiDocumentation.RenderPdfApi()

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

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

namespace Example
{
    public class getRenderPdfExample
    {
        public void main()
        {
            
            var apiInstance = new RenderPdfApi();

            try
            {
                // Visit a URL in a javascript context and return the resultant document in PDF form
                'String' result = apiInstance.getRenderPdf();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RenderPdfApi.getRenderPdf: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getRenderPdf();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RenderPdfApi->getRenderPdf: $@\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.RenderPdfApi()

try: 
    # Visit a URL in a javascript context and return the resultant document in PDF form
    api_response = api_instance.get_render_pdf()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RenderPdfApi->getRenderPdf: %s\n" % e)

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

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

public class RenderPngApiExample {

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

import io.swagger.client.api.RenderPngApi;

public class RenderPngApiExample {

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

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

// Visit a URL in a javascript context and return the resultant document screenshot
[apiInstance getRenderPngWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GepettoApiDocumentation = require('gepetto_api_documentation');

var api = new GepettoApiDocumentation.RenderPngApi()

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

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

namespace Example
{
    public class getRenderPngExample
    {
        public void main()
        {
            
            var apiInstance = new RenderPngApi();

            try
            {
                // Visit a URL in a javascript context and return the resultant document screenshot
                'String' result = apiInstance.getRenderPng();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RenderPngApi.getRenderPng: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getRenderPng();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RenderPngApi->getRenderPng: $@\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.RenderPngApi()

try: 
    # Visit a URL in a javascript context and return the resultant document screenshot
    api_response = api_instance.get_render_png()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RenderPngApi->getRenderPng: %s\n" % e)

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

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

public class SelectApiExample {

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

import io.swagger.client.api.SelectApi;

public class SelectApiExample {

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

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

// Select the first HTML element matching the CSS selector and return the `outerHTML` for it
[apiInstance getSelectWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GepettoApiDocumentation = require('gepetto_api_documentation');

var api = new GepettoApiDocumentation.SelectApi()

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

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

namespace Example
{
    public class getSelectExample
    {
        public void main()
        {
            
            var apiInstance = new SelectApi();

            try
            {
                // Select the first HTML element matching the CSS selector and return the `outerHTML` for it
                'String' result = apiInstance.getSelect();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SelectApi.getSelect: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getSelect();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SelectApi->getSelect: $@\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.SelectApi()

try: 
    # Select the first HTML element matching the CSS selector and return the `outerHTML` for it
    api_response = api_instance.get_select()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SelectApi->getSelect: %s\n" % e)

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

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

public class SelectAllApiExample {

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

import io.swagger.client.api.SelectAllApi;

public class SelectAllApiExample {

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

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

// Select all the HTML elements matching the CSS selector and return the `outerHTML` for the collection
[apiInstance getSelectAllWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GepettoApiDocumentation = require('gepetto_api_documentation');

var api = new GepettoApiDocumentation.SelectAllApi()

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

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

namespace Example
{
    public class getSelectAllExample
    {
        public void main()
        {
            
            var apiInstance = new SelectAllApi();

            try
            {
                // Select all the HTML elements matching the CSS selector and return the `outerHTML` for the collection
                'String' result = apiInstance.getSelectAll();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SelectAllApi.getSelectAll: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getSelectAll();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SelectAllApi->getSelectAll: $@\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.SelectAllApi()

try: 
    # Select all the HTML elements matching the CSS selector and return the `outerHTML` for the collection
    api_response = api_instance.get_select_all()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SelectAllApi->getSelectAll: %s\n" % e)

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

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

public class StopApiExample {

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

import io.swagger.client.api.StopApi;

public class StopApiExample {

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

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

// Stop the gepetto service and shudown Headless Chrome
[apiInstance getStopWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GepettoApiDocumentation = require('gepetto_api_documentation');

var api = new GepettoApiDocumentation.StopApi()

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

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

namespace Example
{
    public class getStopExample
    {
        public void main()
        {
            
            var apiInstance = new StopApi();

            try
            {
                // Stop the gepetto service and shudown Headless Chrome
                'String' result = apiInstance.getStop();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StopApi.getStop: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->getStop();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling StopApi->getStop: $@\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.StopApi()

try: 
    # Stop the gepetto service and shudown Headless Chrome
    api_response = api_instance.get_stop()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StopApi->getStop: %s\n" % e)