Geodetic Calculators API

ATRF2014ToGDA2020

atrf2014ToGda2020DdDdPost

Input: Decimal degrees / Output: Decimal degrees

/atrf2014_to_gda2020/dd/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/atrf2014_to_gda2020/dd/dd"

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

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

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DecimalDegreeWithEpochRequest body = ; // DecimalDegreeWithEpochRequest | 
        try {
            DecimalDegreeWithEpochResponse result = apiInstance.atrf2014ToGda2020DdDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DdDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ATRF2014ToGDA2020Api;

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DecimalDegreeWithEpochRequest body = ; // DecimalDegreeWithEpochRequest | 
        try {
            DecimalDegreeWithEpochResponse result = apiInstance.atrf2014ToGda2020DdDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DdDdPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeWithEpochRequest *body = ; // 

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

// Input: Decimal degrees / Output: Decimal degrees
[apiInstance atrf2014ToGda2020DdDdPostWith:body
              completionHandler: ^(DecimalDegreeWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.ATRF2014ToGDA2020Api()

var body = ; // {DecimalDegreeWithEpochRequest} 


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

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

namespace Example
{
    public class atrf2014ToGda2020DdDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new ATRF2014ToGDA2020Api();
            var body = new DecimalDegreeWithEpochRequest(); // DecimalDegreeWithEpochRequest | 

            try
            {
                // Input: Decimal degrees / Output: Decimal degrees
                DecimalDegreeWithEpochResponse result = apiInstance.atrf2014ToGda2020DdDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ATRF2014ToGDA2020Api.atrf2014ToGda2020DdDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ATRF2014ToGDA2020Api();
$body = ; // DecimalDegreeWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::ATRF2014ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeWithEpochRequest->new(); # DecimalDegreeWithEpochRequest | 

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

try: 
    # Input: Decimal degrees / Output: Decimal degrees
    api_response = api_instance.atrf2014_to_gda2020_dd_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ATRF2014ToGDA2020Api->atrf2014ToGda2020DdDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

atrf2014ToGda2020DdDdmPost

Input: Decimal degrees / Output: Degrees decimal minutes

/atrf2014_to_gda2020/dd/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/atrf2014_to_gda2020/dd/ddm"

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

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

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DecimalDegreeWithEpochRequest body = ; // DecimalDegreeWithEpochRequest | 
        try {
            DecimalDegreeMinuteWithEpochResponse result = apiInstance.atrf2014ToGda2020DdDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DdDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ATRF2014ToGDA2020Api;

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DecimalDegreeWithEpochRequest body = ; // DecimalDegreeWithEpochRequest | 
        try {
            DecimalDegreeMinuteWithEpochResponse result = apiInstance.atrf2014ToGda2020DdDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DdDdmPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeWithEpochRequest *body = ; // 

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

// Input: Decimal degrees / Output: Degrees decimal minutes
[apiInstance atrf2014ToGda2020DdDdmPostWith:body
              completionHandler: ^(DecimalDegreeMinuteWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.ATRF2014ToGDA2020Api()

var body = ; // {DecimalDegreeWithEpochRequest} 


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

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

namespace Example
{
    public class atrf2014ToGda2020DdDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new ATRF2014ToGDA2020Api();
            var body = new DecimalDegreeWithEpochRequest(); // DecimalDegreeWithEpochRequest | 

            try
            {
                // Input: Decimal degrees / Output: Degrees decimal minutes
                DecimalDegreeMinuteWithEpochResponse result = apiInstance.atrf2014ToGda2020DdDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ATRF2014ToGDA2020Api.atrf2014ToGda2020DdDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ATRF2014ToGDA2020Api();
$body = ; // DecimalDegreeWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::ATRF2014ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeWithEpochRequest->new(); # DecimalDegreeWithEpochRequest | 

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

try: 
    # Input: Decimal degrees / Output: Degrees decimal minutes
    api_response = api_instance.atrf2014_to_gda2020_dd_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ATRF2014ToGDA2020Api->atrf2014ToGda2020DdDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

atrf2014ToGda2020DdDmsPost

Input: Decimal degrees / Output: Degrees minutes seconds

/atrf2014_to_gda2020/dd/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/atrf2014_to_gda2020/dd/dms"

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

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

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DecimalDegreeWithEpochRequest body = ; // DecimalDegreeWithEpochRequest | 
        try {
            DegreeMinuteSecondWithEpochResponse result = apiInstance.atrf2014ToGda2020DdDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DdDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ATRF2014ToGDA2020Api;

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DecimalDegreeWithEpochRequest body = ; // DecimalDegreeWithEpochRequest | 
        try {
            DegreeMinuteSecondWithEpochResponse result = apiInstance.atrf2014ToGda2020DdDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DdDmsPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeWithEpochRequest *body = ; // 

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

// Input: Decimal degrees / Output: Degrees minutes seconds
[apiInstance atrf2014ToGda2020DdDmsPostWith:body
              completionHandler: ^(DegreeMinuteSecondWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.ATRF2014ToGDA2020Api()

var body = ; // {DecimalDegreeWithEpochRequest} 


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

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

namespace Example
{
    public class atrf2014ToGda2020DdDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new ATRF2014ToGDA2020Api();
            var body = new DecimalDegreeWithEpochRequest(); // DecimalDegreeWithEpochRequest | 

            try
            {
                // Input: Decimal degrees / Output: Degrees minutes seconds
                DegreeMinuteSecondWithEpochResponse result = apiInstance.atrf2014ToGda2020DdDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ATRF2014ToGDA2020Api.atrf2014ToGda2020DdDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ATRF2014ToGDA2020Api();
$body = ; // DecimalDegreeWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::ATRF2014ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeWithEpochRequest->new(); # DecimalDegreeWithEpochRequest | 

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

try: 
    # Input: Decimal degrees / Output: Degrees minutes seconds
    api_response = api_instance.atrf2014_to_gda2020_dd_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ATRF2014ToGDA2020Api->atrf2014ToGda2020DdDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

atrf2014ToGda2020DdmDdPost

Input: Degrees decimal minutes / Output: Decimal degrees

/atrf2014_to_gda2020/ddm/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/atrf2014_to_gda2020/ddm/dd"

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

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

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DecimalDegreeMinuteWithEpochRequest body = ; // DecimalDegreeMinuteWithEpochRequest | 
        try {
            DecimalDegreeWithEpochResponse result = apiInstance.atrf2014ToGda2020DdmDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DdmDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ATRF2014ToGDA2020Api;

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DecimalDegreeMinuteWithEpochRequest body = ; // DecimalDegreeMinuteWithEpochRequest | 
        try {
            DecimalDegreeWithEpochResponse result = apiInstance.atrf2014ToGda2020DdmDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DdmDdPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeMinuteWithEpochRequest *body = ; // 

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

// Input: Degrees decimal minutes / Output: Decimal degrees
[apiInstance atrf2014ToGda2020DdmDdPostWith:body
              completionHandler: ^(DecimalDegreeWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.ATRF2014ToGDA2020Api()

var body = ; // {DecimalDegreeMinuteWithEpochRequest} 


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

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

namespace Example
{
    public class atrf2014ToGda2020DdmDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new ATRF2014ToGDA2020Api();
            var body = new DecimalDegreeMinuteWithEpochRequest(); // DecimalDegreeMinuteWithEpochRequest | 

            try
            {
                // Input: Degrees decimal minutes / Output: Decimal degrees
                DecimalDegreeWithEpochResponse result = apiInstance.atrf2014ToGda2020DdmDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ATRF2014ToGDA2020Api.atrf2014ToGda2020DdmDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ATRF2014ToGDA2020Api();
$body = ; // DecimalDegreeMinuteWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::ATRF2014ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeMinuteWithEpochRequest->new(); # DecimalDegreeMinuteWithEpochRequest | 

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

try: 
    # Input: Degrees decimal minutes / Output: Decimal degrees
    api_response = api_instance.atrf2014_to_gda2020_ddm_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ATRF2014ToGDA2020Api->atrf2014ToGda2020DdmDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

atrf2014ToGda2020DdmDdmPost

Input: Degrees decimal minutes / Output: Degrees decimal minutes

/atrf2014_to_gda2020/ddm/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/atrf2014_to_gda2020/ddm/ddm"

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

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

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DecimalDegreeMinuteWithEpochRequest body = ; // DecimalDegreeMinuteWithEpochRequest | 
        try {
            DecimalDegreeMinuteWithEpochResponse result = apiInstance.atrf2014ToGda2020DdmDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DdmDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ATRF2014ToGDA2020Api;

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DecimalDegreeMinuteWithEpochRequest body = ; // DecimalDegreeMinuteWithEpochRequest | 
        try {
            DecimalDegreeMinuteWithEpochResponse result = apiInstance.atrf2014ToGda2020DdmDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DdmDdmPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeMinuteWithEpochRequest *body = ; // 

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

// Input: Degrees decimal minutes / Output: Degrees decimal minutes
[apiInstance atrf2014ToGda2020DdmDdmPostWith:body
              completionHandler: ^(DecimalDegreeMinuteWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.ATRF2014ToGDA2020Api()

var body = ; // {DecimalDegreeMinuteWithEpochRequest} 


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

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

namespace Example
{
    public class atrf2014ToGda2020DdmDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new ATRF2014ToGDA2020Api();
            var body = new DecimalDegreeMinuteWithEpochRequest(); // DecimalDegreeMinuteWithEpochRequest | 

            try
            {
                // Input: Degrees decimal minutes / Output: Degrees decimal minutes
                DecimalDegreeMinuteWithEpochResponse result = apiInstance.atrf2014ToGda2020DdmDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ATRF2014ToGDA2020Api.atrf2014ToGda2020DdmDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ATRF2014ToGDA2020Api();
$body = ; // DecimalDegreeMinuteWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::ATRF2014ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeMinuteWithEpochRequest->new(); # DecimalDegreeMinuteWithEpochRequest | 

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

try: 
    # Input: Degrees decimal minutes / Output: Degrees decimal minutes
    api_response = api_instance.atrf2014_to_gda2020_ddm_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ATRF2014ToGDA2020Api->atrf2014ToGda2020DdmDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

atrf2014ToGda2020DdmDmsPost

Input: Degrees decimal minutes / Output: Degrees minutes seconds

/atrf2014_to_gda2020/ddm/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/atrf2014_to_gda2020/ddm/dms"

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

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

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DecimalDegreeMinuteWithEpochRequest body = ; // DecimalDegreeMinuteWithEpochRequest | 
        try {
            DegreeMinuteSecondWithEpochResponse result = apiInstance.atrf2014ToGda2020DdmDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DdmDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ATRF2014ToGDA2020Api;

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DecimalDegreeMinuteWithEpochRequest body = ; // DecimalDegreeMinuteWithEpochRequest | 
        try {
            DegreeMinuteSecondWithEpochResponse result = apiInstance.atrf2014ToGda2020DdmDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DdmDmsPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeMinuteWithEpochRequest *body = ; // 

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

// Input: Degrees decimal minutes / Output: Degrees minutes seconds
[apiInstance atrf2014ToGda2020DdmDmsPostWith:body
              completionHandler: ^(DegreeMinuteSecondWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.ATRF2014ToGDA2020Api()

var body = ; // {DecimalDegreeMinuteWithEpochRequest} 


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

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

namespace Example
{
    public class atrf2014ToGda2020DdmDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new ATRF2014ToGDA2020Api();
            var body = new DecimalDegreeMinuteWithEpochRequest(); // DecimalDegreeMinuteWithEpochRequest | 

            try
            {
                // Input: Degrees decimal minutes / Output: Degrees minutes seconds
                DegreeMinuteSecondWithEpochResponse result = apiInstance.atrf2014ToGda2020DdmDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ATRF2014ToGDA2020Api.atrf2014ToGda2020DdmDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ATRF2014ToGDA2020Api();
$body = ; // DecimalDegreeMinuteWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::ATRF2014ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeMinuteWithEpochRequest->new(); # DecimalDegreeMinuteWithEpochRequest | 

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

try: 
    # Input: Degrees decimal minutes / Output: Degrees minutes seconds
    api_response = api_instance.atrf2014_to_gda2020_ddm_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ATRF2014ToGDA2020Api->atrf2014ToGda2020DdmDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

atrf2014ToGda2020DmsDdPost

Input: Degrees minutes seconds / Output: Decimal degrees

/atrf2014_to_gda2020/dms/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/atrf2014_to_gda2020/dms/dd"

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

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

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DegreeMinuteSecondWithEpochRequest body = ; // DegreeMinuteSecondWithEpochRequest | 
        try {
            DecimalDegreeWithEpochResponse result = apiInstance.atrf2014ToGda2020DmsDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DmsDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ATRF2014ToGDA2020Api;

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DegreeMinuteSecondWithEpochRequest body = ; // DegreeMinuteSecondWithEpochRequest | 
        try {
            DecimalDegreeWithEpochResponse result = apiInstance.atrf2014ToGda2020DmsDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DmsDdPost");
            e.printStackTrace();
        }
    }
}

DegreeMinuteSecondWithEpochRequest *body = ; // 

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

// Input: Degrees minutes seconds / Output: Decimal degrees
[apiInstance atrf2014ToGda2020DmsDdPostWith:body
              completionHandler: ^(DecimalDegreeWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.ATRF2014ToGDA2020Api()

var body = ; // {DegreeMinuteSecondWithEpochRequest} 


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

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

namespace Example
{
    public class atrf2014ToGda2020DmsDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new ATRF2014ToGDA2020Api();
            var body = new DegreeMinuteSecondWithEpochRequest(); // DegreeMinuteSecondWithEpochRequest | 

            try
            {
                // Input: Degrees minutes seconds / Output: Decimal degrees
                DecimalDegreeWithEpochResponse result = apiInstance.atrf2014ToGda2020DmsDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ATRF2014ToGDA2020Api.atrf2014ToGda2020DmsDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ATRF2014ToGDA2020Api();
$body = ; // DegreeMinuteSecondWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::ATRF2014ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DegreeMinuteSecondWithEpochRequest->new(); # DegreeMinuteSecondWithEpochRequest | 

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

try: 
    # Input: Degrees minutes seconds / Output: Decimal degrees
    api_response = api_instance.atrf2014_to_gda2020_dms_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ATRF2014ToGDA2020Api->atrf2014ToGda2020DmsDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

atrf2014ToGda2020DmsDdmPost

Input: Degrees minutes seconds / Output: Degrees decimal minutes

/atrf2014_to_gda2020/dms/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/atrf2014_to_gda2020/dms/ddm"

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

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

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DegreeMinuteSecondWithEpochRequest body = ; // DegreeMinuteSecondWithEpochRequest | 
        try {
            DecimalDegreeMinuteWithEpochResponse result = apiInstance.atrf2014ToGda2020DmsDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DmsDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ATRF2014ToGDA2020Api;

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DegreeMinuteSecondWithEpochRequest body = ; // DegreeMinuteSecondWithEpochRequest | 
        try {
            DecimalDegreeMinuteWithEpochResponse result = apiInstance.atrf2014ToGda2020DmsDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DmsDdmPost");
            e.printStackTrace();
        }
    }
}

DegreeMinuteSecondWithEpochRequest *body = ; // 

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

// Input: Degrees minutes seconds / Output: Degrees decimal minutes
[apiInstance atrf2014ToGda2020DmsDdmPostWith:body
              completionHandler: ^(DecimalDegreeMinuteWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.ATRF2014ToGDA2020Api()

var body = ; // {DegreeMinuteSecondWithEpochRequest} 


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

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

namespace Example
{
    public class atrf2014ToGda2020DmsDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new ATRF2014ToGDA2020Api();
            var body = new DegreeMinuteSecondWithEpochRequest(); // DegreeMinuteSecondWithEpochRequest | 

            try
            {
                // Input: Degrees minutes seconds / Output: Degrees decimal minutes
                DecimalDegreeMinuteWithEpochResponse result = apiInstance.atrf2014ToGda2020DmsDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ATRF2014ToGDA2020Api.atrf2014ToGda2020DmsDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ATRF2014ToGDA2020Api();
$body = ; // DegreeMinuteSecondWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::ATRF2014ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DegreeMinuteSecondWithEpochRequest->new(); # DegreeMinuteSecondWithEpochRequest | 

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

try: 
    # Input: Degrees minutes seconds / Output: Degrees decimal minutes
    api_response = api_instance.atrf2014_to_gda2020_dms_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ATRF2014ToGDA2020Api->atrf2014ToGda2020DmsDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

atrf2014ToGda2020DmsDmsPost

Input: Degrees minutes seconds / Output: Degrees minutes seconds

/atrf2014_to_gda2020/dms/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/atrf2014_to_gda2020/dms/dms"

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

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

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DegreeMinuteSecondWithEpochRequest body = ; // DegreeMinuteSecondWithEpochRequest | 
        try {
            DegreeMinuteSecondWithEpochResponse result = apiInstance.atrf2014ToGda2020DmsDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DmsDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ATRF2014ToGDA2020Api;

public class ATRF2014ToGDA2020ApiExample {

    public static void main(String[] args) {
        ATRF2014ToGDA2020Api apiInstance = new ATRF2014ToGDA2020Api();
        DegreeMinuteSecondWithEpochRequest body = ; // DegreeMinuteSecondWithEpochRequest | 
        try {
            DegreeMinuteSecondWithEpochResponse result = apiInstance.atrf2014ToGda2020DmsDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ATRF2014ToGDA2020Api#atrf2014ToGda2020DmsDmsPost");
            e.printStackTrace();
        }
    }
}

DegreeMinuteSecondWithEpochRequest *body = ; // 

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

// Input: Degrees minutes seconds / Output: Degrees minutes seconds
[apiInstance atrf2014ToGda2020DmsDmsPostWith:body
              completionHandler: ^(DegreeMinuteSecondWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.ATRF2014ToGDA2020Api()

var body = ; // {DegreeMinuteSecondWithEpochRequest} 


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

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

namespace Example
{
    public class atrf2014ToGda2020DmsDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new ATRF2014ToGDA2020Api();
            var body = new DegreeMinuteSecondWithEpochRequest(); // DegreeMinuteSecondWithEpochRequest | 

            try
            {
                // Input: Degrees minutes seconds / Output: Degrees minutes seconds
                DegreeMinuteSecondWithEpochResponse result = apiInstance.atrf2014ToGda2020DmsDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ATRF2014ToGDA2020Api.atrf2014ToGda2020DmsDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ATRF2014ToGDA2020Api();
$body = ; // DegreeMinuteSecondWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::ATRF2014ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DegreeMinuteSecondWithEpochRequest->new(); # DegreeMinuteSecondWithEpochRequest | 

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

try: 
    # Input: Degrees minutes seconds / Output: Degrees minutes seconds
    api_response = api_instance.atrf2014_to_gda2020_dms_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ATRF2014ToGDA2020Api->atrf2014ToGda2020DmsDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

AUSGeoid

ausgeoidPost

Input: Decimal degrees

/ausgeoid

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/ausgeoid"

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

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

public class AUSGeoidApiExample {

    public static void main(String[] args) {
        
        AUSGeoidApi apiInstance = new AUSGeoidApi();
        AUSGeoidRequest body = ; // AUSGeoidRequest | 
        try {
            AUSGeoidResponse result = apiInstance.ausgeoidPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AUSGeoidApi#ausgeoidPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AUSGeoidApi;

public class AUSGeoidApiExample {

    public static void main(String[] args) {
        AUSGeoidApi apiInstance = new AUSGeoidApi();
        AUSGeoidRequest body = ; // AUSGeoidRequest | 
        try {
            AUSGeoidResponse result = apiInstance.ausgeoidPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AUSGeoidApi#ausgeoidPost");
            e.printStackTrace();
        }
    }
}

AUSGeoidRequest *body = ; // 

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

// Input: Decimal degrees
[apiInstance ausgeoidPostWith:body
              completionHandler: ^(AUSGeoidResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.AUSGeoidApi()

var body = ; // {AUSGeoidRequest} 


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

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

namespace Example
{
    public class ausgeoidPostExample
    {
        public void main()
        {
            
            var apiInstance = new AUSGeoidApi();
            var body = new AUSGeoidRequest(); // AUSGeoidRequest | 

            try
            {
                // Input: Decimal degrees
                AUSGeoidResponse result = apiInstance.ausgeoidPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AUSGeoidApi.ausgeoidPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AUSGeoidApi();
$body = ; // AUSGeoidRequest | 

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

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

my $api_instance = WWW::SwaggerClient::AUSGeoidApi->new();
my $body = WWW::SwaggerClient::Object::AUSGeoidRequest->new(); # AUSGeoidRequest | 

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

try: 
    # Input: Decimal degrees
    api_response = api_instance.ausgeoid_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AUSGeoidApi->ausgeoidPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

AVWS

avwsPost

Input: Decimal degrees

/avws

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/avws"

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

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

public class AVWSApiExample {

    public static void main(String[] args) {
        
        AVWSApi apiInstance = new AVWSApi();
        AVWSRequest body = ; // AVWSRequest | 
        try {
            AVWSResponse result = apiInstance.avwsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AVWSApi#avwsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AVWSApi;

public class AVWSApiExample {

    public static void main(String[] args) {
        AVWSApi apiInstance = new AVWSApi();
        AVWSRequest body = ; // AVWSRequest | 
        try {
            AVWSResponse result = apiInstance.avwsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AVWSApi#avwsPost");
            e.printStackTrace();
        }
    }
}

AVWSRequest *body = ; // 

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

// Input: Decimal degrees
[apiInstance avwsPostWith:body
              completionHandler: ^(AVWSResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.AVWSApi()

var body = ; // {AVWSRequest} 


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

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

namespace Example
{
    public class avwsPostExample
    {
        public void main()
        {
            
            var apiInstance = new AVWSApi();
            var body = new AVWSRequest(); // AVWSRequest | 

            try
            {
                // Input: Decimal degrees
                AVWSResponse result = apiInstance.avwsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AVWSApi.avwsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AVWSApi();
$body = ; // AVWSRequest | 

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

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

my $api_instance = WWW::SwaggerClient::AVWSApi->new();
my $body = WWW::SwaggerClient::Object::AVWSRequest->new(); # AVWSRequest | 

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

try: 
    # Input: Decimal degrees
    api_response = api_instance.avws_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AVWSApi->avwsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

GDA2020ToATRF2014

gda2020ToAtrf2014DdDdPost

Input: Decimal degrees / Output: Decimal degrees

/gda2020_to_atrf2014/dd/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_atrf2014/dd/dd"

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

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

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DecimalDegreeWithEpochRequest body = ; // DecimalDegreeWithEpochRequest | 
        try {
            DecimalDegreeWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DdDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToATRF2014Api;

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DecimalDegreeWithEpochRequest body = ; // DecimalDegreeWithEpochRequest | 
        try {
            DecimalDegreeWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DdDdPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeWithEpochRequest *body = ; // 

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

// Input: Decimal degrees / Output: Decimal degrees
[apiInstance gda2020ToAtrf2014DdDdPostWith:body
              completionHandler: ^(DecimalDegreeWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToATRF2014Api()

var body = ; // {DecimalDegreeWithEpochRequest} 


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

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

namespace Example
{
    public class gda2020ToAtrf2014DdDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToATRF2014Api();
            var body = new DecimalDegreeWithEpochRequest(); // DecimalDegreeWithEpochRequest | 

            try
            {
                // Input: Decimal degrees / Output: Decimal degrees
                DecimalDegreeWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToATRF2014Api.gda2020ToAtrf2014DdDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToATRF2014Api();
$body = ; // DecimalDegreeWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToATRF2014Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeWithEpochRequest->new(); # DecimalDegreeWithEpochRequest | 

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

try: 
    # Input: Decimal degrees / Output: Decimal degrees
    api_response = api_instance.gda2020_to_atrf2014_dd_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToATRF2014Api->gda2020ToAtrf2014DdDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToAtrf2014DdDdmPost

Input: Decimal degrees / Output: Degrees decimal minutes

/gda2020_to_atrf2014/dd/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_atrf2014/dd/ddm"

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

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

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DecimalDegreeWithEpochRequest body = ; // DecimalDegreeWithEpochRequest | 
        try {
            DecimalDegreeMinuteWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DdDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToATRF2014Api;

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DecimalDegreeWithEpochRequest body = ; // DecimalDegreeWithEpochRequest | 
        try {
            DecimalDegreeMinuteWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DdDdmPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeWithEpochRequest *body = ; // 

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

// Input: Decimal degrees / Output: Degrees decimal minutes
[apiInstance gda2020ToAtrf2014DdDdmPostWith:body
              completionHandler: ^(DecimalDegreeMinuteWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToATRF2014Api()

var body = ; // {DecimalDegreeWithEpochRequest} 


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

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

namespace Example
{
    public class gda2020ToAtrf2014DdDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToATRF2014Api();
            var body = new DecimalDegreeWithEpochRequest(); // DecimalDegreeWithEpochRequest | 

            try
            {
                // Input: Decimal degrees / Output: Degrees decimal minutes
                DecimalDegreeMinuteWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToATRF2014Api.gda2020ToAtrf2014DdDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToATRF2014Api();
$body = ; // DecimalDegreeWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToATRF2014Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeWithEpochRequest->new(); # DecimalDegreeWithEpochRequest | 

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

try: 
    # Input: Decimal degrees / Output: Degrees decimal minutes
    api_response = api_instance.gda2020_to_atrf2014_dd_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToATRF2014Api->gda2020ToAtrf2014DdDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToAtrf2014DdDmsPost

Input: Decimal degrees / Output: Degrees minutes seconds

/gda2020_to_atrf2014/dd/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_atrf2014/dd/dms"

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

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

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DecimalDegreeWithEpochRequest body = ; // DecimalDegreeWithEpochRequest | 
        try {
            DegreeMinuteSecondWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DdDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToATRF2014Api;

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DecimalDegreeWithEpochRequest body = ; // DecimalDegreeWithEpochRequest | 
        try {
            DegreeMinuteSecondWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DdDmsPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeWithEpochRequest *body = ; // 

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

// Input: Decimal degrees / Output: Degrees minutes seconds
[apiInstance gda2020ToAtrf2014DdDmsPostWith:body
              completionHandler: ^(DegreeMinuteSecondWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToATRF2014Api()

var body = ; // {DecimalDegreeWithEpochRequest} 


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

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

namespace Example
{
    public class gda2020ToAtrf2014DdDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToATRF2014Api();
            var body = new DecimalDegreeWithEpochRequest(); // DecimalDegreeWithEpochRequest | 

            try
            {
                // Input: Decimal degrees / Output: Degrees minutes seconds
                DegreeMinuteSecondWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToATRF2014Api.gda2020ToAtrf2014DdDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToATRF2014Api();
$body = ; // DecimalDegreeWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToATRF2014Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeWithEpochRequest->new(); # DecimalDegreeWithEpochRequest | 

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

try: 
    # Input: Decimal degrees / Output: Degrees minutes seconds
    api_response = api_instance.gda2020_to_atrf2014_dd_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToATRF2014Api->gda2020ToAtrf2014DdDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToAtrf2014DdmDdPost

Input: Degrees decimal minutes / Output: Decimal degrees

/gda2020_to_atrf2014/ddm/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_atrf2014/ddm/dd"

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

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

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DecimalDegreeMinuteWithEpochRequest body = ; // DecimalDegreeMinuteWithEpochRequest | 
        try {
            DecimalDegreeWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdmDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DdmDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToATRF2014Api;

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DecimalDegreeMinuteWithEpochRequest body = ; // DecimalDegreeMinuteWithEpochRequest | 
        try {
            DecimalDegreeWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdmDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DdmDdPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeMinuteWithEpochRequest *body = ; // 

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

// Input: Degrees decimal minutes / Output: Decimal degrees
[apiInstance gda2020ToAtrf2014DdmDdPostWith:body
              completionHandler: ^(DecimalDegreeWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToATRF2014Api()

var body = ; // {DecimalDegreeMinuteWithEpochRequest} 


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

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

namespace Example
{
    public class gda2020ToAtrf2014DdmDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToATRF2014Api();
            var body = new DecimalDegreeMinuteWithEpochRequest(); // DecimalDegreeMinuteWithEpochRequest | 

            try
            {
                // Input: Degrees decimal minutes / Output: Decimal degrees
                DecimalDegreeWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdmDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToATRF2014Api.gda2020ToAtrf2014DdmDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToATRF2014Api();
$body = ; // DecimalDegreeMinuteWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToATRF2014Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeMinuteWithEpochRequest->new(); # DecimalDegreeMinuteWithEpochRequest | 

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

try: 
    # Input: Degrees decimal minutes / Output: Decimal degrees
    api_response = api_instance.gda2020_to_atrf2014_ddm_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToATRF2014Api->gda2020ToAtrf2014DdmDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToAtrf2014DdmDdmPost

Input: Degrees decimal minutes / Output: Degrees decimal minutes

/gda2020_to_atrf2014/ddm/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_atrf2014/ddm/ddm"

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

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

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DecimalDegreeMinuteWithEpochRequest body = ; // DecimalDegreeMinuteWithEpochRequest | 
        try {
            DecimalDegreeMinuteWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdmDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DdmDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToATRF2014Api;

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DecimalDegreeMinuteWithEpochRequest body = ; // DecimalDegreeMinuteWithEpochRequest | 
        try {
            DecimalDegreeMinuteWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdmDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DdmDdmPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeMinuteWithEpochRequest *body = ; // 

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

// Input: Degrees decimal minutes / Output: Degrees decimal minutes
[apiInstance gda2020ToAtrf2014DdmDdmPostWith:body
              completionHandler: ^(DecimalDegreeMinuteWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToATRF2014Api()

var body = ; // {DecimalDegreeMinuteWithEpochRequest} 


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

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

namespace Example
{
    public class gda2020ToAtrf2014DdmDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToATRF2014Api();
            var body = new DecimalDegreeMinuteWithEpochRequest(); // DecimalDegreeMinuteWithEpochRequest | 

            try
            {
                // Input: Degrees decimal minutes / Output: Degrees decimal minutes
                DecimalDegreeMinuteWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdmDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToATRF2014Api.gda2020ToAtrf2014DdmDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToATRF2014Api();
$body = ; // DecimalDegreeMinuteWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToATRF2014Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeMinuteWithEpochRequest->new(); # DecimalDegreeMinuteWithEpochRequest | 

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

try: 
    # Input: Degrees decimal minutes / Output: Degrees decimal minutes
    api_response = api_instance.gda2020_to_atrf2014_ddm_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToATRF2014Api->gda2020ToAtrf2014DdmDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToAtrf2014DdmDmsPost

Input: Degrees decimal minutes / Output: Degrees minutes seconds

/gda2020_to_atrf2014/ddm/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_atrf2014/ddm/dms"

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

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

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DecimalDegreeMinuteWithEpochRequest body = ; // DecimalDegreeMinuteWithEpochRequest | 
        try {
            DegreeMinuteSecondWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdmDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DdmDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToATRF2014Api;

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DecimalDegreeMinuteWithEpochRequest body = ; // DecimalDegreeMinuteWithEpochRequest | 
        try {
            DegreeMinuteSecondWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdmDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DdmDmsPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeMinuteWithEpochRequest *body = ; // 

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

// Input: Degrees decimal minutes / Output: Degrees minutes seconds
[apiInstance gda2020ToAtrf2014DdmDmsPostWith:body
              completionHandler: ^(DegreeMinuteSecondWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToATRF2014Api()

var body = ; // {DecimalDegreeMinuteWithEpochRequest} 


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

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

namespace Example
{
    public class gda2020ToAtrf2014DdmDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToATRF2014Api();
            var body = new DecimalDegreeMinuteWithEpochRequest(); // DecimalDegreeMinuteWithEpochRequest | 

            try
            {
                // Input: Degrees decimal minutes / Output: Degrees minutes seconds
                DegreeMinuteSecondWithEpochResponse result = apiInstance.gda2020ToAtrf2014DdmDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToATRF2014Api.gda2020ToAtrf2014DdmDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToATRF2014Api();
$body = ; // DecimalDegreeMinuteWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToATRF2014Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeMinuteWithEpochRequest->new(); # DecimalDegreeMinuteWithEpochRequest | 

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

try: 
    # Input: Degrees decimal minutes / Output: Degrees minutes seconds
    api_response = api_instance.gda2020_to_atrf2014_ddm_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToATRF2014Api->gda2020ToAtrf2014DdmDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToAtrf2014DmsDdPost

Input: Degrees minutes seconds / Output: Decimal degrees

/gda2020_to_atrf2014/dms/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_atrf2014/dms/dd"

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

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

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DegreeMinuteSecondWithEpochRequest body = ; // DegreeMinuteSecondWithEpochRequest | 
        try {
            DecimalDegreeWithEpochResponse result = apiInstance.gda2020ToAtrf2014DmsDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DmsDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToATRF2014Api;

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DegreeMinuteSecondWithEpochRequest body = ; // DegreeMinuteSecondWithEpochRequest | 
        try {
            DecimalDegreeWithEpochResponse result = apiInstance.gda2020ToAtrf2014DmsDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DmsDdPost");
            e.printStackTrace();
        }
    }
}

DegreeMinuteSecondWithEpochRequest *body = ; // 

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

// Input: Degrees minutes seconds / Output: Decimal degrees
[apiInstance gda2020ToAtrf2014DmsDdPostWith:body
              completionHandler: ^(DecimalDegreeWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToATRF2014Api()

var body = ; // {DegreeMinuteSecondWithEpochRequest} 


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

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

namespace Example
{
    public class gda2020ToAtrf2014DmsDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToATRF2014Api();
            var body = new DegreeMinuteSecondWithEpochRequest(); // DegreeMinuteSecondWithEpochRequest | 

            try
            {
                // Input: Degrees minutes seconds / Output: Decimal degrees
                DecimalDegreeWithEpochResponse result = apiInstance.gda2020ToAtrf2014DmsDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToATRF2014Api.gda2020ToAtrf2014DmsDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToATRF2014Api();
$body = ; // DegreeMinuteSecondWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToATRF2014Api->new();
my $body = WWW::SwaggerClient::Object::DegreeMinuteSecondWithEpochRequest->new(); # DegreeMinuteSecondWithEpochRequest | 

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

try: 
    # Input: Degrees minutes seconds / Output: Decimal degrees
    api_response = api_instance.gda2020_to_atrf2014_dms_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToATRF2014Api->gda2020ToAtrf2014DmsDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToAtrf2014DmsDdmPost

Input: Degrees minutes seconds / Output: Degrees decimal minutes

/gda2020_to_atrf2014/dms/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_atrf2014/dms/ddm"

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

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

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DegreeMinuteSecondWithEpochRequest body = ; // DegreeMinuteSecondWithEpochRequest | 
        try {
            DecimalDegreeMinuteWithEpochResponse result = apiInstance.gda2020ToAtrf2014DmsDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DmsDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToATRF2014Api;

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DegreeMinuteSecondWithEpochRequest body = ; // DegreeMinuteSecondWithEpochRequest | 
        try {
            DecimalDegreeMinuteWithEpochResponse result = apiInstance.gda2020ToAtrf2014DmsDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DmsDdmPost");
            e.printStackTrace();
        }
    }
}

DegreeMinuteSecondWithEpochRequest *body = ; // 

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

// Input: Degrees minutes seconds / Output: Degrees decimal minutes
[apiInstance gda2020ToAtrf2014DmsDdmPostWith:body
              completionHandler: ^(DecimalDegreeMinuteWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToATRF2014Api()

var body = ; // {DegreeMinuteSecondWithEpochRequest} 


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

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

namespace Example
{
    public class gda2020ToAtrf2014DmsDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToATRF2014Api();
            var body = new DegreeMinuteSecondWithEpochRequest(); // DegreeMinuteSecondWithEpochRequest | 

            try
            {
                // Input: Degrees minutes seconds / Output: Degrees decimal minutes
                DecimalDegreeMinuteWithEpochResponse result = apiInstance.gda2020ToAtrf2014DmsDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToATRF2014Api.gda2020ToAtrf2014DmsDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToATRF2014Api();
$body = ; // DegreeMinuteSecondWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToATRF2014Api->new();
my $body = WWW::SwaggerClient::Object::DegreeMinuteSecondWithEpochRequest->new(); # DegreeMinuteSecondWithEpochRequest | 

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

try: 
    # Input: Degrees minutes seconds / Output: Degrees decimal minutes
    api_response = api_instance.gda2020_to_atrf2014_dms_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToATRF2014Api->gda2020ToAtrf2014DmsDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToAtrf2014DmsDmsPost

Input: Degrees minutes seconds / Output: Degrees minutes seconds

/gda2020_to_atrf2014/dms/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_atrf2014/dms/dms"

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

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

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DegreeMinuteSecondWithEpochRequest body = ; // DegreeMinuteSecondWithEpochRequest | 
        try {
            DegreeMinuteSecondWithEpochResponse result = apiInstance.gda2020ToAtrf2014DmsDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DmsDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToATRF2014Api;

public class GDA2020ToATRF2014ApiExample {

    public static void main(String[] args) {
        GDA2020ToATRF2014Api apiInstance = new GDA2020ToATRF2014Api();
        DegreeMinuteSecondWithEpochRequest body = ; // DegreeMinuteSecondWithEpochRequest | 
        try {
            DegreeMinuteSecondWithEpochResponse result = apiInstance.gda2020ToAtrf2014DmsDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToATRF2014Api#gda2020ToAtrf2014DmsDmsPost");
            e.printStackTrace();
        }
    }
}

DegreeMinuteSecondWithEpochRequest *body = ; // 

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

// Input: Degrees minutes seconds / Output: Degrees minutes seconds
[apiInstance gda2020ToAtrf2014DmsDmsPostWith:body
              completionHandler: ^(DegreeMinuteSecondWithEpochResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToATRF2014Api()

var body = ; // {DegreeMinuteSecondWithEpochRequest} 


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

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

namespace Example
{
    public class gda2020ToAtrf2014DmsDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToATRF2014Api();
            var body = new DegreeMinuteSecondWithEpochRequest(); // DegreeMinuteSecondWithEpochRequest | 

            try
            {
                // Input: Degrees minutes seconds / Output: Degrees minutes seconds
                DegreeMinuteSecondWithEpochResponse result = apiInstance.gda2020ToAtrf2014DmsDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToATRF2014Api.gda2020ToAtrf2014DmsDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToATRF2014Api();
$body = ; // DegreeMinuteSecondWithEpochRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToATRF2014Api->new();
my $body = WWW::SwaggerClient::Object::DegreeMinuteSecondWithEpochRequest->new(); # DegreeMinuteSecondWithEpochRequest | 

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

try: 
    # Input: Degrees minutes seconds / Output: Degrees minutes seconds
    api_response = api_instance.gda2020_to_atrf2014_dms_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToATRF2014Api->gda2020ToAtrf2014DmsDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

GDA2020ToGDA94

gda2020ToGda94DdDdPost

Input: Decimal degrees / Output: Decimal degrees

/gda2020_to_gda94/dd/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_gda94/dd/dd"

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

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

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DecimalDegreeRequest body = ; // DecimalDegreeRequest | 
        try {
            DecimalDegreeResponse result = apiInstance.gda2020ToGda94DdDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DdDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToGDA94Api;

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DecimalDegreeRequest body = ; // DecimalDegreeRequest | 
        try {
            DecimalDegreeResponse result = apiInstance.gda2020ToGda94DdDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DdDdPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeRequest *body = ; // 

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

// Input: Decimal degrees / Output: Decimal degrees
[apiInstance gda2020ToGda94DdDdPostWith:body
              completionHandler: ^(DecimalDegreeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToGDA94Api()

var body = ; // {DecimalDegreeRequest} 


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

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

namespace Example
{
    public class gda2020ToGda94DdDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToGDA94Api();
            var body = new DecimalDegreeRequest(); // DecimalDegreeRequest | 

            try
            {
                // Input: Decimal degrees / Output: Decimal degrees
                DecimalDegreeResponse result = apiInstance.gda2020ToGda94DdDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToGDA94Api.gda2020ToGda94DdDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToGDA94Api();
$body = ; // DecimalDegreeRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToGDA94Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeRequest->new(); # DecimalDegreeRequest | 

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

try: 
    # Input: Decimal degrees / Output: Decimal degrees
    api_response = api_instance.gda2020_to_gda94_dd_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToGDA94Api->gda2020ToGda94DdDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToGda94DdDdmPost

Input: Decimal degrees / Output: Degrees decimal minutes

/gda2020_to_gda94/dd/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_gda94/dd/ddm"

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

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

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DecimalDegreeRequest body = ; // DecimalDegreeRequest | 
        try {
            DecimalDegreeMinuteResponse result = apiInstance.gda2020ToGda94DdDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DdDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToGDA94Api;

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DecimalDegreeRequest body = ; // DecimalDegreeRequest | 
        try {
            DecimalDegreeMinuteResponse result = apiInstance.gda2020ToGda94DdDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DdDdmPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeRequest *body = ; // 

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

// Input: Decimal degrees / Output: Degrees decimal minutes
[apiInstance gda2020ToGda94DdDdmPostWith:body
              completionHandler: ^(DecimalDegreeMinuteResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToGDA94Api()

var body = ; // {DecimalDegreeRequest} 


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

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

namespace Example
{
    public class gda2020ToGda94DdDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToGDA94Api();
            var body = new DecimalDegreeRequest(); // DecimalDegreeRequest | 

            try
            {
                // Input: Decimal degrees / Output: Degrees decimal minutes
                DecimalDegreeMinuteResponse result = apiInstance.gda2020ToGda94DdDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToGDA94Api.gda2020ToGda94DdDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToGDA94Api();
$body = ; // DecimalDegreeRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToGDA94Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeRequest->new(); # DecimalDegreeRequest | 

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

try: 
    # Input: Decimal degrees / Output: Degrees decimal minutes
    api_response = api_instance.gda2020_to_gda94_dd_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToGDA94Api->gda2020ToGda94DdDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToGda94DdDmsPost

Input: Decimal degrees / Output: Degrees minutes seconds

/gda2020_to_gda94/dd/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_gda94/dd/dms"

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

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

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DecimalDegreeRequest body = ; // DecimalDegreeRequest | 
        try {
            DegreeMinuteSecondResponse result = apiInstance.gda2020ToGda94DdDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DdDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToGDA94Api;

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DecimalDegreeRequest body = ; // DecimalDegreeRequest | 
        try {
            DegreeMinuteSecondResponse result = apiInstance.gda2020ToGda94DdDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DdDmsPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeRequest *body = ; // 

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

// Input: Decimal degrees / Output: Degrees minutes seconds
[apiInstance gda2020ToGda94DdDmsPostWith:body
              completionHandler: ^(DegreeMinuteSecondResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToGDA94Api()

var body = ; // {DecimalDegreeRequest} 


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

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

namespace Example
{
    public class gda2020ToGda94DdDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToGDA94Api();
            var body = new DecimalDegreeRequest(); // DecimalDegreeRequest | 

            try
            {
                // Input: Decimal degrees / Output: Degrees minutes seconds
                DegreeMinuteSecondResponse result = apiInstance.gda2020ToGda94DdDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToGDA94Api.gda2020ToGda94DdDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToGDA94Api();
$body = ; // DecimalDegreeRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToGDA94Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeRequest->new(); # DecimalDegreeRequest | 

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

try: 
    # Input: Decimal degrees / Output: Degrees minutes seconds
    api_response = api_instance.gda2020_to_gda94_dd_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToGDA94Api->gda2020ToGda94DdDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToGda94DdmDdPost

Input: Degrees decimal minutes / Output: Decimal degrees

/gda2020_to_gda94/ddm/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_gda94/ddm/dd"

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

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

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DecimalDegreeMinuteRequest body = ; // DecimalDegreeMinuteRequest | 
        try {
            DecimalDegreeResponse result = apiInstance.gda2020ToGda94DdmDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DdmDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToGDA94Api;

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DecimalDegreeMinuteRequest body = ; // DecimalDegreeMinuteRequest | 
        try {
            DecimalDegreeResponse result = apiInstance.gda2020ToGda94DdmDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DdmDdPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeMinuteRequest *body = ; // 

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

// Input: Degrees decimal minutes / Output: Decimal degrees
[apiInstance gda2020ToGda94DdmDdPostWith:body
              completionHandler: ^(DecimalDegreeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToGDA94Api()

var body = ; // {DecimalDegreeMinuteRequest} 


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

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

namespace Example
{
    public class gda2020ToGda94DdmDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToGDA94Api();
            var body = new DecimalDegreeMinuteRequest(); // DecimalDegreeMinuteRequest | 

            try
            {
                // Input: Degrees decimal minutes / Output: Decimal degrees
                DecimalDegreeResponse result = apiInstance.gda2020ToGda94DdmDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToGDA94Api.gda2020ToGda94DdmDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToGDA94Api();
$body = ; // DecimalDegreeMinuteRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToGDA94Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeMinuteRequest->new(); # DecimalDegreeMinuteRequest | 

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

try: 
    # Input: Degrees decimal minutes / Output: Decimal degrees
    api_response = api_instance.gda2020_to_gda94_ddm_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToGDA94Api->gda2020ToGda94DdmDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToGda94DdmDdmPost

Input: Degrees decimal minutes / Output: Degrees decimal minutes

/gda2020_to_gda94/ddm/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_gda94/ddm/ddm"

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

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

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DecimalDegreeMinuteRequest body = ; // DecimalDegreeMinuteRequest | 
        try {
            DecimalDegreeMinuteResponse result = apiInstance.gda2020ToGda94DdmDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DdmDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToGDA94Api;

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DecimalDegreeMinuteRequest body = ; // DecimalDegreeMinuteRequest | 
        try {
            DecimalDegreeMinuteResponse result = apiInstance.gda2020ToGda94DdmDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DdmDdmPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeMinuteRequest *body = ; // 

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

// Input: Degrees decimal minutes / Output: Degrees decimal minutes
[apiInstance gda2020ToGda94DdmDdmPostWith:body
              completionHandler: ^(DecimalDegreeMinuteResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToGDA94Api()

var body = ; // {DecimalDegreeMinuteRequest} 


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

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

namespace Example
{
    public class gda2020ToGda94DdmDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToGDA94Api();
            var body = new DecimalDegreeMinuteRequest(); // DecimalDegreeMinuteRequest | 

            try
            {
                // Input: Degrees decimal minutes / Output: Degrees decimal minutes
                DecimalDegreeMinuteResponse result = apiInstance.gda2020ToGda94DdmDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToGDA94Api.gda2020ToGda94DdmDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToGDA94Api();
$body = ; // DecimalDegreeMinuteRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToGDA94Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeMinuteRequest->new(); # DecimalDegreeMinuteRequest | 

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

try: 
    # Input: Degrees decimal minutes / Output: Degrees decimal minutes
    api_response = api_instance.gda2020_to_gda94_ddm_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToGDA94Api->gda2020ToGda94DdmDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToGda94DdmDmsPost

Input: Degrees decimal minutes / Output: Degrees minutes seconds

/gda2020_to_gda94/ddm/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_gda94/ddm/dms"

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

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

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DecimalDegreeMinuteRequest body = ; // DecimalDegreeMinuteRequest | 
        try {
            DegreeMinuteSecondResponse result = apiInstance.gda2020ToGda94DdmDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DdmDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToGDA94Api;

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DecimalDegreeMinuteRequest body = ; // DecimalDegreeMinuteRequest | 
        try {
            DegreeMinuteSecondResponse result = apiInstance.gda2020ToGda94DdmDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DdmDmsPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeMinuteRequest *body = ; // 

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

// Input: Degrees decimal minutes / Output: Degrees minutes seconds
[apiInstance gda2020ToGda94DdmDmsPostWith:body
              completionHandler: ^(DegreeMinuteSecondResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToGDA94Api()

var body = ; // {DecimalDegreeMinuteRequest} 


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

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

namespace Example
{
    public class gda2020ToGda94DdmDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToGDA94Api();
            var body = new DecimalDegreeMinuteRequest(); // DecimalDegreeMinuteRequest | 

            try
            {
                // Input: Degrees decimal minutes / Output: Degrees minutes seconds
                DegreeMinuteSecondResponse result = apiInstance.gda2020ToGda94DdmDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToGDA94Api.gda2020ToGda94DdmDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToGDA94Api();
$body = ; // DecimalDegreeMinuteRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToGDA94Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeMinuteRequest->new(); # DecimalDegreeMinuteRequest | 

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

try: 
    # Input: Degrees decimal minutes / Output: Degrees minutes seconds
    api_response = api_instance.gda2020_to_gda94_ddm_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToGDA94Api->gda2020ToGda94DdmDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToGda94DmsDdPost

Input: Degrees minutes seconds / Output: Decimal degrees

/gda2020_to_gda94/dms/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_gda94/dms/dd"

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

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

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DegreeMinuteSecondRequest body = ; // DegreeMinuteSecondRequest | 
        try {
            DecimalDegreeResponse result = apiInstance.gda2020ToGda94DmsDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DmsDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToGDA94Api;

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DegreeMinuteSecondRequest body = ; // DegreeMinuteSecondRequest | 
        try {
            DecimalDegreeResponse result = apiInstance.gda2020ToGda94DmsDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DmsDdPost");
            e.printStackTrace();
        }
    }
}

DegreeMinuteSecondRequest *body = ; // 

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

// Input: Degrees minutes seconds / Output: Decimal degrees
[apiInstance gda2020ToGda94DmsDdPostWith:body
              completionHandler: ^(DecimalDegreeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToGDA94Api()

var body = ; // {DegreeMinuteSecondRequest} 


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

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

namespace Example
{
    public class gda2020ToGda94DmsDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToGDA94Api();
            var body = new DegreeMinuteSecondRequest(); // DegreeMinuteSecondRequest | 

            try
            {
                // Input: Degrees minutes seconds / Output: Decimal degrees
                DecimalDegreeResponse result = apiInstance.gda2020ToGda94DmsDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToGDA94Api.gda2020ToGda94DmsDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToGDA94Api();
$body = ; // DegreeMinuteSecondRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToGDA94Api->new();
my $body = WWW::SwaggerClient::Object::DegreeMinuteSecondRequest->new(); # DegreeMinuteSecondRequest | 

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

try: 
    # Input: Degrees minutes seconds / Output: Decimal degrees
    api_response = api_instance.gda2020_to_gda94_dms_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToGDA94Api->gda2020ToGda94DmsDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToGda94DmsDdmPost

Input: Degrees minutes seconds / Output: Degrees decimal minutes

/gda2020_to_gda94/dms/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_gda94/dms/ddm"

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

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

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DegreeMinuteSecondRequest body = ; // DegreeMinuteSecondRequest | 
        try {
            DecimalDegreeMinuteResponse result = apiInstance.gda2020ToGda94DmsDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DmsDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToGDA94Api;

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DegreeMinuteSecondRequest body = ; // DegreeMinuteSecondRequest | 
        try {
            DecimalDegreeMinuteResponse result = apiInstance.gda2020ToGda94DmsDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DmsDdmPost");
            e.printStackTrace();
        }
    }
}

DegreeMinuteSecondRequest *body = ; // 

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

// Input: Degrees minutes seconds / Output: Degrees decimal minutes
[apiInstance gda2020ToGda94DmsDdmPostWith:body
              completionHandler: ^(DecimalDegreeMinuteResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToGDA94Api()

var body = ; // {DegreeMinuteSecondRequest} 


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

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

namespace Example
{
    public class gda2020ToGda94DmsDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToGDA94Api();
            var body = new DegreeMinuteSecondRequest(); // DegreeMinuteSecondRequest | 

            try
            {
                // Input: Degrees minutes seconds / Output: Degrees decimal minutes
                DecimalDegreeMinuteResponse result = apiInstance.gda2020ToGda94DmsDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToGDA94Api.gda2020ToGda94DmsDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToGDA94Api();
$body = ; // DegreeMinuteSecondRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToGDA94Api->new();
my $body = WWW::SwaggerClient::Object::DegreeMinuteSecondRequest->new(); # DegreeMinuteSecondRequest | 

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

try: 
    # Input: Degrees minutes seconds / Output: Degrees decimal minutes
    api_response = api_instance.gda2020_to_gda94_dms_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToGDA94Api->gda2020ToGda94DmsDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda2020ToGda94DmsDmsPost

Input: Degrees minutes seconds / Output: Degrees minutes seconds

/gda2020_to_gda94/dms/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda2020_to_gda94/dms/dms"

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

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

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DegreeMinuteSecondRequest body = ; // DegreeMinuteSecondRequest | 
        try {
            DegreeMinuteSecondResponse result = apiInstance.gda2020ToGda94DmsDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DmsDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA2020ToGDA94Api;

public class GDA2020ToGDA94ApiExample {

    public static void main(String[] args) {
        GDA2020ToGDA94Api apiInstance = new GDA2020ToGDA94Api();
        DegreeMinuteSecondRequest body = ; // DegreeMinuteSecondRequest | 
        try {
            DegreeMinuteSecondResponse result = apiInstance.gda2020ToGda94DmsDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA2020ToGDA94Api#gda2020ToGda94DmsDmsPost");
            e.printStackTrace();
        }
    }
}

DegreeMinuteSecondRequest *body = ; // 

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

// Input: Degrees minutes seconds / Output: Degrees minutes seconds
[apiInstance gda2020ToGda94DmsDmsPostWith:body
              completionHandler: ^(DegreeMinuteSecondResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA2020ToGDA94Api()

var body = ; // {DegreeMinuteSecondRequest} 


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

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

namespace Example
{
    public class gda2020ToGda94DmsDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA2020ToGDA94Api();
            var body = new DegreeMinuteSecondRequest(); // DegreeMinuteSecondRequest | 

            try
            {
                // Input: Degrees minutes seconds / Output: Degrees minutes seconds
                DegreeMinuteSecondResponse result = apiInstance.gda2020ToGda94DmsDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA2020ToGDA94Api.gda2020ToGda94DmsDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA2020ToGDA94Api();
$body = ; // DegreeMinuteSecondRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA2020ToGDA94Api->new();
my $body = WWW::SwaggerClient::Object::DegreeMinuteSecondRequest->new(); # DegreeMinuteSecondRequest | 

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

try: 
    # Input: Degrees minutes seconds / Output: Degrees minutes seconds
    api_response = api_instance.gda2020_to_gda94_dms_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA2020ToGDA94Api->gda2020ToGda94DmsDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

GDA94ToGDA2020

gda94ToGda2020DdDdPost

Input: Decimal degrees / Output: Decimal degrees

/gda94_to_gda2020/dd/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda94_to_gda2020/dd/dd"

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

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

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DecimalDegreeRequest body = ; // DecimalDegreeRequest | 
        try {
            DecimalDegreeResponse result = apiInstance.gda94ToGda2020DdDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DdDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA94ToGDA2020Api;

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DecimalDegreeRequest body = ; // DecimalDegreeRequest | 
        try {
            DecimalDegreeResponse result = apiInstance.gda94ToGda2020DdDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DdDdPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeRequest *body = ; // 

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

// Input: Decimal degrees / Output: Decimal degrees
[apiInstance gda94ToGda2020DdDdPostWith:body
              completionHandler: ^(DecimalDegreeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA94ToGDA2020Api()

var body = ; // {DecimalDegreeRequest} 


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

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

namespace Example
{
    public class gda94ToGda2020DdDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA94ToGDA2020Api();
            var body = new DecimalDegreeRequest(); // DecimalDegreeRequest | 

            try
            {
                // Input: Decimal degrees / Output: Decimal degrees
                DecimalDegreeResponse result = apiInstance.gda94ToGda2020DdDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA94ToGDA2020Api.gda94ToGda2020DdDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA94ToGDA2020Api();
$body = ; // DecimalDegreeRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA94ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeRequest->new(); # DecimalDegreeRequest | 

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

try: 
    # Input: Decimal degrees / Output: Decimal degrees
    api_response = api_instance.gda94_to_gda2020_dd_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA94ToGDA2020Api->gda94ToGda2020DdDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda94ToGda2020DdDdmPost

Input: Decimal degrees / Output: Degrees decimal minutes

/gda94_to_gda2020/dd/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda94_to_gda2020/dd/ddm"

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

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

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DecimalDegreeRequest body = ; // DecimalDegreeRequest | 
        try {
            DecimalDegreeMinuteResponse result = apiInstance.gda94ToGda2020DdDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DdDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA94ToGDA2020Api;

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DecimalDegreeRequest body = ; // DecimalDegreeRequest | 
        try {
            DecimalDegreeMinuteResponse result = apiInstance.gda94ToGda2020DdDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DdDdmPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeRequest *body = ; // 

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

// Input: Decimal degrees / Output: Degrees decimal minutes
[apiInstance gda94ToGda2020DdDdmPostWith:body
              completionHandler: ^(DecimalDegreeMinuteResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA94ToGDA2020Api()

var body = ; // {DecimalDegreeRequest} 


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

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

namespace Example
{
    public class gda94ToGda2020DdDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA94ToGDA2020Api();
            var body = new DecimalDegreeRequest(); // DecimalDegreeRequest | 

            try
            {
                // Input: Decimal degrees / Output: Degrees decimal minutes
                DecimalDegreeMinuteResponse result = apiInstance.gda94ToGda2020DdDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA94ToGDA2020Api.gda94ToGda2020DdDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA94ToGDA2020Api();
$body = ; // DecimalDegreeRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA94ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeRequest->new(); # DecimalDegreeRequest | 

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

try: 
    # Input: Decimal degrees / Output: Degrees decimal minutes
    api_response = api_instance.gda94_to_gda2020_dd_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA94ToGDA2020Api->gda94ToGda2020DdDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda94ToGda2020DdDmsPost

Input: Decimal degrees / Output: Degrees minutes seconds

/gda94_to_gda2020/dd/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda94_to_gda2020/dd/dms"

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

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

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DecimalDegreeRequest body = ; // DecimalDegreeRequest | 
        try {
            DegreeMinuteSecondResponse result = apiInstance.gda94ToGda2020DdDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DdDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA94ToGDA2020Api;

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DecimalDegreeRequest body = ; // DecimalDegreeRequest | 
        try {
            DegreeMinuteSecondResponse result = apiInstance.gda94ToGda2020DdDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DdDmsPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeRequest *body = ; // 

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

// Input: Decimal degrees / Output: Degrees minutes seconds
[apiInstance gda94ToGda2020DdDmsPostWith:body
              completionHandler: ^(DegreeMinuteSecondResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA94ToGDA2020Api()

var body = ; // {DecimalDegreeRequest} 


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

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

namespace Example
{
    public class gda94ToGda2020DdDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA94ToGDA2020Api();
            var body = new DecimalDegreeRequest(); // DecimalDegreeRequest | 

            try
            {
                // Input: Decimal degrees / Output: Degrees minutes seconds
                DegreeMinuteSecondResponse result = apiInstance.gda94ToGda2020DdDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA94ToGDA2020Api.gda94ToGda2020DdDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA94ToGDA2020Api();
$body = ; // DecimalDegreeRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA94ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeRequest->new(); # DecimalDegreeRequest | 

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

try: 
    # Input: Decimal degrees / Output: Degrees minutes seconds
    api_response = api_instance.gda94_to_gda2020_dd_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA94ToGDA2020Api->gda94ToGda2020DdDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda94ToGda2020DdmDdPost

Input: Degrees decimal minutes / Output: Decimal degrees

/gda94_to_gda2020/ddm/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda94_to_gda2020/ddm/dd"

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

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

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DecimalDegreeMinuteRequest body = ; // DecimalDegreeMinuteRequest | 
        try {
            DecimalDegreeResponse result = apiInstance.gda94ToGda2020DdmDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DdmDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA94ToGDA2020Api;

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DecimalDegreeMinuteRequest body = ; // DecimalDegreeMinuteRequest | 
        try {
            DecimalDegreeResponse result = apiInstance.gda94ToGda2020DdmDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DdmDdPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeMinuteRequest *body = ; // 

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

// Input: Degrees decimal minutes / Output: Decimal degrees
[apiInstance gda94ToGda2020DdmDdPostWith:body
              completionHandler: ^(DecimalDegreeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA94ToGDA2020Api()

var body = ; // {DecimalDegreeMinuteRequest} 


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

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

namespace Example
{
    public class gda94ToGda2020DdmDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA94ToGDA2020Api();
            var body = new DecimalDegreeMinuteRequest(); // DecimalDegreeMinuteRequest | 

            try
            {
                // Input: Degrees decimal minutes / Output: Decimal degrees
                DecimalDegreeResponse result = apiInstance.gda94ToGda2020DdmDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA94ToGDA2020Api.gda94ToGda2020DdmDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA94ToGDA2020Api();
$body = ; // DecimalDegreeMinuteRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA94ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeMinuteRequest->new(); # DecimalDegreeMinuteRequest | 

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

try: 
    # Input: Degrees decimal minutes / Output: Decimal degrees
    api_response = api_instance.gda94_to_gda2020_ddm_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA94ToGDA2020Api->gda94ToGda2020DdmDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda94ToGda2020DdmDdmPost

Input: Degrees decimal minutes / Output: Degrees decimal minutes

/gda94_to_gda2020/ddm/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda94_to_gda2020/ddm/ddm"

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

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

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DecimalDegreeMinuteRequest body = ; // DecimalDegreeMinuteRequest | 
        try {
            DecimalDegreeMinuteResponse result = apiInstance.gda94ToGda2020DdmDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DdmDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA94ToGDA2020Api;

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DecimalDegreeMinuteRequest body = ; // DecimalDegreeMinuteRequest | 
        try {
            DecimalDegreeMinuteResponse result = apiInstance.gda94ToGda2020DdmDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DdmDdmPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeMinuteRequest *body = ; // 

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

// Input: Degrees decimal minutes / Output: Degrees decimal minutes
[apiInstance gda94ToGda2020DdmDdmPostWith:body
              completionHandler: ^(DecimalDegreeMinuteResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA94ToGDA2020Api()

var body = ; // {DecimalDegreeMinuteRequest} 


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

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

namespace Example
{
    public class gda94ToGda2020DdmDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA94ToGDA2020Api();
            var body = new DecimalDegreeMinuteRequest(); // DecimalDegreeMinuteRequest | 

            try
            {
                // Input: Degrees decimal minutes / Output: Degrees decimal minutes
                DecimalDegreeMinuteResponse result = apiInstance.gda94ToGda2020DdmDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA94ToGDA2020Api.gda94ToGda2020DdmDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA94ToGDA2020Api();
$body = ; // DecimalDegreeMinuteRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA94ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeMinuteRequest->new(); # DecimalDegreeMinuteRequest | 

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

try: 
    # Input: Degrees decimal minutes / Output: Degrees decimal minutes
    api_response = api_instance.gda94_to_gda2020_ddm_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA94ToGDA2020Api->gda94ToGda2020DdmDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda94ToGda2020DdmDmsPost

Input: Degrees decimal minutes / Output: Degrees minutes seconds

/gda94_to_gda2020/ddm/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda94_to_gda2020/ddm/dms"

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

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

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DecimalDegreeMinuteRequest body = ; // DecimalDegreeMinuteRequest | 
        try {
            DegreeMinuteSecondResponse result = apiInstance.gda94ToGda2020DdmDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DdmDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA94ToGDA2020Api;

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DecimalDegreeMinuteRequest body = ; // DecimalDegreeMinuteRequest | 
        try {
            DegreeMinuteSecondResponse result = apiInstance.gda94ToGda2020DdmDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DdmDmsPost");
            e.printStackTrace();
        }
    }
}

DecimalDegreeMinuteRequest *body = ; // 

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

// Input: Degrees decimal minutes / Output: Degrees minutes seconds
[apiInstance gda94ToGda2020DdmDmsPostWith:body
              completionHandler: ^(DegreeMinuteSecondResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA94ToGDA2020Api()

var body = ; // {DecimalDegreeMinuteRequest} 


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

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

namespace Example
{
    public class gda94ToGda2020DdmDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA94ToGDA2020Api();
            var body = new DecimalDegreeMinuteRequest(); // DecimalDegreeMinuteRequest | 

            try
            {
                // Input: Degrees decimal minutes / Output: Degrees minutes seconds
                DegreeMinuteSecondResponse result = apiInstance.gda94ToGda2020DdmDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA94ToGDA2020Api.gda94ToGda2020DdmDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA94ToGDA2020Api();
$body = ; // DecimalDegreeMinuteRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA94ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DecimalDegreeMinuteRequest->new(); # DecimalDegreeMinuteRequest | 

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

try: 
    # Input: Degrees decimal minutes / Output: Degrees minutes seconds
    api_response = api_instance.gda94_to_gda2020_ddm_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA94ToGDA2020Api->gda94ToGda2020DdmDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda94ToGda2020DmsDdPost

Input: Degrees minutes seconds / Output: Decimal degrees

/gda94_to_gda2020/dms/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda94_to_gda2020/dms/dd"

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

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

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DegreeMinuteSecondRequest body = ; // DegreeMinuteSecondRequest | 
        try {
            DecimalDegreeResponse result = apiInstance.gda94ToGda2020DmsDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DmsDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA94ToGDA2020Api;

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DegreeMinuteSecondRequest body = ; // DegreeMinuteSecondRequest | 
        try {
            DecimalDegreeResponse result = apiInstance.gda94ToGda2020DmsDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DmsDdPost");
            e.printStackTrace();
        }
    }
}

DegreeMinuteSecondRequest *body = ; // 

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

// Input: Degrees minutes seconds / Output: Decimal degrees
[apiInstance gda94ToGda2020DmsDdPostWith:body
              completionHandler: ^(DecimalDegreeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA94ToGDA2020Api()

var body = ; // {DegreeMinuteSecondRequest} 


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

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

namespace Example
{
    public class gda94ToGda2020DmsDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA94ToGDA2020Api();
            var body = new DegreeMinuteSecondRequest(); // DegreeMinuteSecondRequest | 

            try
            {
                // Input: Degrees minutes seconds / Output: Decimal degrees
                DecimalDegreeResponse result = apiInstance.gda94ToGda2020DmsDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA94ToGDA2020Api.gda94ToGda2020DmsDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA94ToGDA2020Api();
$body = ; // DegreeMinuteSecondRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA94ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DegreeMinuteSecondRequest->new(); # DegreeMinuteSecondRequest | 

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

try: 
    # Input: Degrees minutes seconds / Output: Decimal degrees
    api_response = api_instance.gda94_to_gda2020_dms_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA94ToGDA2020Api->gda94ToGda2020DmsDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda94ToGda2020DmsDdmPost

Input: Decrees minutes seconds / Output: Degrees decimal minutes

/gda94_to_gda2020/dms/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda94_to_gda2020/dms/ddm"

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

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

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DegreeMinuteSecondRequest body = ; // DegreeMinuteSecondRequest | 
        try {
            DecimalDegreeMinuteResponse result = apiInstance.gda94ToGda2020DmsDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DmsDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA94ToGDA2020Api;

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DegreeMinuteSecondRequest body = ; // DegreeMinuteSecondRequest | 
        try {
            DecimalDegreeMinuteResponse result = apiInstance.gda94ToGda2020DmsDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DmsDdmPost");
            e.printStackTrace();
        }
    }
}

DegreeMinuteSecondRequest *body = ; // 

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

// Input: Decrees minutes seconds / Output: Degrees decimal minutes
[apiInstance gda94ToGda2020DmsDdmPostWith:body
              completionHandler: ^(DecimalDegreeMinuteResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA94ToGDA2020Api()

var body = ; // {DegreeMinuteSecondRequest} 


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

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

namespace Example
{
    public class gda94ToGda2020DmsDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA94ToGDA2020Api();
            var body = new DegreeMinuteSecondRequest(); // DegreeMinuteSecondRequest | 

            try
            {
                // Input: Decrees minutes seconds / Output: Degrees decimal minutes
                DecimalDegreeMinuteResponse result = apiInstance.gda94ToGda2020DmsDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA94ToGDA2020Api.gda94ToGda2020DmsDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA94ToGDA2020Api();
$body = ; // DegreeMinuteSecondRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA94ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DegreeMinuteSecondRequest->new(); # DegreeMinuteSecondRequest | 

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

try: 
    # Input: Decrees minutes seconds / Output: Degrees decimal minutes
    api_response = api_instance.gda94_to_gda2020_dms_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA94ToGDA2020Api->gda94ToGda2020DmsDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

gda94ToGda2020DmsDmsPost

Input: Degrees minutes seconds / Output: Degrees minutes seconds

/gda94_to_gda2020/dms/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/gda94_to_gda2020/dms/dms"

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

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

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DegreeMinuteSecondRequest body = ; // DegreeMinuteSecondRequest | 
        try {
            DegreeMinuteSecondResponse result = apiInstance.gda94ToGda2020DmsDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DmsDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GDA94ToGDA2020Api;

public class GDA94ToGDA2020ApiExample {

    public static void main(String[] args) {
        GDA94ToGDA2020Api apiInstance = new GDA94ToGDA2020Api();
        DegreeMinuteSecondRequest body = ; // DegreeMinuteSecondRequest | 
        try {
            DegreeMinuteSecondResponse result = apiInstance.gda94ToGda2020DmsDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GDA94ToGDA2020Api#gda94ToGda2020DmsDmsPost");
            e.printStackTrace();
        }
    }
}

DegreeMinuteSecondRequest *body = ; // 

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

// Input: Degrees minutes seconds / Output: Degrees minutes seconds
[apiInstance gda94ToGda2020DmsDmsPostWith:body
              completionHandler: ^(DegreeMinuteSecondResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GDA94ToGDA2020Api()

var body = ; // {DegreeMinuteSecondRequest} 


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

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

namespace Example
{
    public class gda94ToGda2020DmsDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new GDA94ToGDA2020Api();
            var body = new DegreeMinuteSecondRequest(); // DegreeMinuteSecondRequest | 

            try
            {
                // Input: Degrees minutes seconds / Output: Degrees minutes seconds
                DegreeMinuteSecondResponse result = apiInstance.gda94ToGda2020DmsDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GDA94ToGDA2020Api.gda94ToGda2020DmsDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GDA94ToGDA2020Api();
$body = ; // DegreeMinuteSecondRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GDA94ToGDA2020Api->new();
my $body = WWW::SwaggerClient::Object::DegreeMinuteSecondRequest->new(); # DegreeMinuteSecondRequest | 

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

try: 
    # Input: Degrees minutes seconds / Output: Degrees minutes seconds
    api_response = api_instance.gda94_to_gda2020_dms_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GDA94ToGDA2020Api->gda94ToGda2020DmsDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

GeographicToGrid

geo2gridDdPost

Input: Decimal degrees

/geo2grid/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/geo2grid/dd"

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

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

public class GeographicToGridApiExample {

    public static void main(String[] args) {
        
        GeographicToGridApi apiInstance = new GeographicToGridApi();
        Geo2GridDDRequest body = ; // Geo2GridDDRequest | 
        try {
            Geo2GridDDResponse result = apiInstance.geo2gridDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GeographicToGridApi#geo2gridDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GeographicToGridApi;

public class GeographicToGridApiExample {

    public static void main(String[] args) {
        GeographicToGridApi apiInstance = new GeographicToGridApi();
        Geo2GridDDRequest body = ; // Geo2GridDDRequest | 
        try {
            Geo2GridDDResponse result = apiInstance.geo2gridDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GeographicToGridApi#geo2gridDdPost");
            e.printStackTrace();
        }
    }
}

Geo2GridDDRequest *body = ; // 

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

// Input: Decimal degrees
[apiInstance geo2gridDdPostWith:body
              completionHandler: ^(Geo2GridDDResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GeographicToGridApi()

var body = ; // {Geo2GridDDRequest} 


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

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

namespace Example
{
    public class geo2gridDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new GeographicToGridApi();
            var body = new Geo2GridDDRequest(); // Geo2GridDDRequest | 

            try
            {
                // Input: Decimal degrees
                Geo2GridDDResponse result = apiInstance.geo2gridDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GeographicToGridApi.geo2gridDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GeographicToGridApi();
$body = ; // Geo2GridDDRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GeographicToGridApi->new();
my $body = WWW::SwaggerClient::Object::Geo2GridDDRequest->new(); # Geo2GridDDRequest | 

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

try: 
    # Input: Decimal degrees
    api_response = api_instance.geo2grid_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GeographicToGridApi->geo2gridDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - Transformed coordinate

Schema

geo2gridDdmPost

Input: Degrees decimal minutes

/geo2grid/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/geo2grid/ddm"

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

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

public class GeographicToGridApiExample {

    public static void main(String[] args) {
        
        GeographicToGridApi apiInstance = new GeographicToGridApi();
        Geo2GridDDMRequest body = ; // Geo2GridDDMRequest | 
        try {
            Geo2GridDMSResponse result = apiInstance.geo2gridDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GeographicToGridApi#geo2gridDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GeographicToGridApi;

public class GeographicToGridApiExample {

    public static void main(String[] args) {
        GeographicToGridApi apiInstance = new GeographicToGridApi();
        Geo2GridDDMRequest body = ; // Geo2GridDDMRequest | 
        try {
            Geo2GridDMSResponse result = apiInstance.geo2gridDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GeographicToGridApi#geo2gridDdmPost");
            e.printStackTrace();
        }
    }
}

Geo2GridDDMRequest *body = ; // 

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

// Input: Degrees decimal minutes
[apiInstance geo2gridDdmPostWith:body
              completionHandler: ^(Geo2GridDMSResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GeographicToGridApi()

var body = ; // {Geo2GridDDMRequest} 


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

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

namespace Example
{
    public class geo2gridDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new GeographicToGridApi();
            var body = new Geo2GridDDMRequest(); // Geo2GridDDMRequest | 

            try
            {
                // Input: Degrees decimal minutes
                Geo2GridDMSResponse result = apiInstance.geo2gridDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GeographicToGridApi.geo2gridDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GeographicToGridApi();
$body = ; // Geo2GridDDMRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GeographicToGridApi->new();
my $body = WWW::SwaggerClient::Object::Geo2GridDDMRequest->new(); # Geo2GridDDMRequest | 

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

try: 
    # Input: Degrees decimal minutes
    api_response = api_instance.geo2grid_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GeographicToGridApi->geo2gridDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - Transformed coordinate

Schema

geo2gridDmsPost

Input: Degrees minutes seconds

/geo2grid/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/geo2grid/dms"

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

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

public class GeographicToGridApiExample {

    public static void main(String[] args) {
        
        GeographicToGridApi apiInstance = new GeographicToGridApi();
        Geo2GridDMSRequest body = ; // Geo2GridDMSRequest | 
        try {
            Geo2GridDMSResponse result = apiInstance.geo2gridDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GeographicToGridApi#geo2gridDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GeographicToGridApi;

public class GeographicToGridApiExample {

    public static void main(String[] args) {
        GeographicToGridApi apiInstance = new GeographicToGridApi();
        Geo2GridDMSRequest body = ; // Geo2GridDMSRequest | 
        try {
            Geo2GridDMSResponse result = apiInstance.geo2gridDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GeographicToGridApi#geo2gridDmsPost");
            e.printStackTrace();
        }
    }
}

Geo2GridDMSRequest *body = ; // 

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

// Input: Degrees minutes seconds
[apiInstance geo2gridDmsPostWith:body
              completionHandler: ^(Geo2GridDMSResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GeographicToGridApi()

var body = ; // {Geo2GridDMSRequest} 


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

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

namespace Example
{
    public class geo2gridDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new GeographicToGridApi();
            var body = new Geo2GridDMSRequest(); // Geo2GridDMSRequest | 

            try
            {
                // Input: Degrees minutes seconds
                Geo2GridDMSResponse result = apiInstance.geo2gridDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GeographicToGridApi.geo2gridDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GeographicToGridApi();
$body = ; // Geo2GridDMSRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GeographicToGridApi->new();
my $body = WWW::SwaggerClient::Object::Geo2GridDMSRequest->new(); # Geo2GridDMSRequest | 

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

try: 
    # Input: Degrees minutes seconds
    api_response = api_instance.geo2grid_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GeographicToGridApi->geo2gridDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - Transformed coordinate

Schema

GridToGeographic

grid2geoDdPost

Input: Decimal degrees

/grid2geo/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/grid2geo/dd"

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

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

public class GridToGeographicApiExample {

    public static void main(String[] args) {
        
        GridToGeographicApi apiInstance = new GridToGeographicApi();
        Grid2GeoRequest body = ; // Grid2GeoRequest | 
        try {
            Grid2GeoDDResponse result = apiInstance.grid2geoDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GridToGeographicApi#grid2geoDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GridToGeographicApi;

public class GridToGeographicApiExample {

    public static void main(String[] args) {
        GridToGeographicApi apiInstance = new GridToGeographicApi();
        Grid2GeoRequest body = ; // Grid2GeoRequest | 
        try {
            Grid2GeoDDResponse result = apiInstance.grid2geoDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GridToGeographicApi#grid2geoDdPost");
            e.printStackTrace();
        }
    }
}

Grid2GeoRequest *body = ; // 

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

// Input: Decimal degrees
[apiInstance grid2geoDdPostWith:body
              completionHandler: ^(Grid2GeoDDResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GridToGeographicApi()

var body = ; // {Grid2GeoRequest} 


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

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

namespace Example
{
    public class grid2geoDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new GridToGeographicApi();
            var body = new Grid2GeoRequest(); // Grid2GeoRequest | 

            try
            {
                // Input: Decimal degrees
                Grid2GeoDDResponse result = apiInstance.grid2geoDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GridToGeographicApi.grid2geoDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GridToGeographicApi();
$body = ; // Grid2GeoRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GridToGeographicApi->new();
my $body = WWW::SwaggerClient::Object::Grid2GeoRequest->new(); # Grid2GeoRequest | 

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

try: 
    # Input: Decimal degrees
    api_response = api_instance.grid2geo_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GridToGeographicApi->grid2geoDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - Transformed coordinate

Schema

grid2geoDdmPost

Input: Degrees decimal minutes

/grid2geo/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/grid2geo/ddm"

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

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

public class GridToGeographicApiExample {

    public static void main(String[] args) {
        
        GridToGeographicApi apiInstance = new GridToGeographicApi();
        Grid2GeoRequest body = ; // Grid2GeoRequest | 
        try {
            Grid2GeoDDMResponse result = apiInstance.grid2geoDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GridToGeographicApi#grid2geoDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GridToGeographicApi;

public class GridToGeographicApiExample {

    public static void main(String[] args) {
        GridToGeographicApi apiInstance = new GridToGeographicApi();
        Grid2GeoRequest body = ; // Grid2GeoRequest | 
        try {
            Grid2GeoDDMResponse result = apiInstance.grid2geoDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GridToGeographicApi#grid2geoDdmPost");
            e.printStackTrace();
        }
    }
}

Grid2GeoRequest *body = ; // 

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

// Input: Degrees decimal minutes
[apiInstance grid2geoDdmPostWith:body
              completionHandler: ^(Grid2GeoDDMResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GridToGeographicApi()

var body = ; // {Grid2GeoRequest} 


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

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

namespace Example
{
    public class grid2geoDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new GridToGeographicApi();
            var body = new Grid2GeoRequest(); // Grid2GeoRequest | 

            try
            {
                // Input: Degrees decimal minutes
                Grid2GeoDDMResponse result = apiInstance.grid2geoDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GridToGeographicApi.grid2geoDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GridToGeographicApi();
$body = ; // Grid2GeoRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GridToGeographicApi->new();
my $body = WWW::SwaggerClient::Object::Grid2GeoRequest->new(); # Grid2GeoRequest | 

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

try: 
    # Input: Degrees decimal minutes
    api_response = api_instance.grid2geo_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GridToGeographicApi->grid2geoDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - Transformed coordinate

Schema

grid2geoDmsPost

Input: Degrees minutes seconds

/grid2geo/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/grid2geo/dms"

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

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

public class GridToGeographicApiExample {

    public static void main(String[] args) {
        
        GridToGeographicApi apiInstance = new GridToGeographicApi();
        Grid2GeoRequest body = ; // Grid2GeoRequest | 
        try {
            Grid2GeoDMSResponse result = apiInstance.grid2geoDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GridToGeographicApi#grid2geoDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GridToGeographicApi;

public class GridToGeographicApiExample {

    public static void main(String[] args) {
        GridToGeographicApi apiInstance = new GridToGeographicApi();
        Grid2GeoRequest body = ; // Grid2GeoRequest | 
        try {
            Grid2GeoDMSResponse result = apiInstance.grid2geoDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GridToGeographicApi#grid2geoDmsPost");
            e.printStackTrace();
        }
    }
}

Grid2GeoRequest *body = ; // 

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

// Input: Degrees minutes seconds
[apiInstance grid2geoDmsPostWith:body
              completionHandler: ^(Grid2GeoDMSResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.GridToGeographicApi()

var body = ; // {Grid2GeoRequest} 


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

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

namespace Example
{
    public class grid2geoDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new GridToGeographicApi();
            var body = new Grid2GeoRequest(); // Grid2GeoRequest | 

            try
            {
                // Input: Degrees minutes seconds
                Grid2GeoDMSResponse result = apiInstance.grid2geoDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GridToGeographicApi.grid2geoDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GridToGeographicApi();
$body = ; // Grid2GeoRequest | 

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

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

my $api_instance = WWW::SwaggerClient::GridToGeographicApi->new();
my $body = WWW::SwaggerClient::Object::Grid2GeoRequest->new(); # Grid2GeoRequest | 

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

try: 
    # Input: Degrees minutes seconds
    api_response = api_instance.grid2geo_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GridToGeographicApi->grid2geoDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - Transformed coordinate

Schema

MGA2020ToMGA94

mga2020ToMga94Post

/mga2020_to_mga94

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/mga2020_to_mga94"

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

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

public class MGA2020ToMGA94ApiExample {

    public static void main(String[] args) {
        
        MGA2020ToMGA94Api apiInstance = new MGA2020ToMGA94Api();
        GridWithHeightRequest body = ; // GridWithHeightRequest | 
        try {
            GridWithHeightResponse result = apiInstance.mga2020ToMga94Post(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MGA2020ToMGA94Api#mga2020ToMga94Post");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MGA2020ToMGA94Api;

public class MGA2020ToMGA94ApiExample {

    public static void main(String[] args) {
        MGA2020ToMGA94Api apiInstance = new MGA2020ToMGA94Api();
        GridWithHeightRequest body = ; // GridWithHeightRequest | 
        try {
            GridWithHeightResponse result = apiInstance.mga2020ToMga94Post(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MGA2020ToMGA94Api#mga2020ToMga94Post");
            e.printStackTrace();
        }
    }
}

GridWithHeightRequest *body = ; // 

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

// 
[apiInstance mga2020ToMga94PostWith:body
              completionHandler: ^(GridWithHeightResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.MGA2020ToMGA94Api()

var body = ; // {GridWithHeightRequest} 


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

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

namespace Example
{
    public class mga2020ToMga94PostExample
    {
        public void main()
        {
            
            var apiInstance = new MGA2020ToMGA94Api();
            var body = new GridWithHeightRequest(); // GridWithHeightRequest | 

            try
            {
                // 
                GridWithHeightResponse result = apiInstance.mga2020ToMga94Post(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MGA2020ToMGA94Api.mga2020ToMga94Post: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MGA2020ToMGA94Api();
$body = ; // GridWithHeightRequest | 

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

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

my $api_instance = WWW::SwaggerClient::MGA2020ToMGA94Api->new();
my $body = WWW::SwaggerClient::Object::GridWithHeightRequest->new(); # GridWithHeightRequest | 

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

try: 
    # 
    api_response = api_instance.mga2020_to_mga94_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MGA2020ToMGA94Api->mga2020ToMga94Post: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

MGA94ToMGA2020

mga94ToMga2020Post

/mga94_to_mga2020

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/mga94_to_mga2020"

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

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

public class MGA94ToMGA2020ApiExample {

    public static void main(String[] args) {
        
        MGA94ToMGA2020Api apiInstance = new MGA94ToMGA2020Api();
        GridWithHeightRequest body = ; // GridWithHeightRequest | 
        try {
            GridWithHeightResponse result = apiInstance.mga94ToMga2020Post(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MGA94ToMGA2020Api#mga94ToMga2020Post");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MGA94ToMGA2020Api;

public class MGA94ToMGA2020ApiExample {

    public static void main(String[] args) {
        MGA94ToMGA2020Api apiInstance = new MGA94ToMGA2020Api();
        GridWithHeightRequest body = ; // GridWithHeightRequest | 
        try {
            GridWithHeightResponse result = apiInstance.mga94ToMga2020Post(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MGA94ToMGA2020Api#mga94ToMga2020Post");
            e.printStackTrace();
        }
    }
}

GridWithHeightRequest *body = ; // 

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

// 
[apiInstance mga94ToMga2020PostWith:body
              completionHandler: ^(GridWithHeightResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.MGA94ToMGA2020Api()

var body = ; // {GridWithHeightRequest} 


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

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

namespace Example
{
    public class mga94ToMga2020PostExample
    {
        public void main()
        {
            
            var apiInstance = new MGA94ToMGA2020Api();
            var body = new GridWithHeightRequest(); // GridWithHeightRequest | 

            try
            {
                // 
                GridWithHeightResponse result = apiInstance.mga94ToMga2020Post(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MGA94ToMGA2020Api.mga94ToMga2020Post: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MGA94ToMGA2020Api();
$body = ; // GridWithHeightRequest | 

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

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

my $api_instance = WWW::SwaggerClient::MGA94ToMGA2020Api->new();
my $body = WWW::SwaggerClient::Object::GridWithHeightRequest->new(); # GridWithHeightRequest | 

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

try: 
    # 
    api_response = api_instance.mga94_to_mga2020_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MGA94ToMGA2020Api->mga94ToMga2020Post: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

VincentysDirect

vincdirDdPost

Input: Decimal degrees

/vincdir/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/vincdir/dd"

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

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

public class VincentysDirectApiExample {

    public static void main(String[] args) {
        
        VincentysDirectApi apiInstance = new VincentysDirectApi();
        VincentysDirectDDRequest body = ; // VincentysDirectDDRequest | 
        try {
            VincentysDirectDDResponse result = apiInstance.vincdirDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysDirectApi#vincdirDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.VincentysDirectApi;

public class VincentysDirectApiExample {

    public static void main(String[] args) {
        VincentysDirectApi apiInstance = new VincentysDirectApi();
        VincentysDirectDDRequest body = ; // VincentysDirectDDRequest | 
        try {
            VincentysDirectDDResponse result = apiInstance.vincdirDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysDirectApi#vincdirDdPost");
            e.printStackTrace();
        }
    }
}

VincentysDirectDDRequest *body = ; // 

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

// Input: Decimal degrees
[apiInstance vincdirDdPostWith:body
              completionHandler: ^(VincentysDirectDDResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.VincentysDirectApi()

var body = ; // {VincentysDirectDDRequest} 


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

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

namespace Example
{
    public class vincdirDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new VincentysDirectApi();
            var body = new VincentysDirectDDRequest(); // VincentysDirectDDRequest | 

            try
            {
                // Input: Decimal degrees
                VincentysDirectDDResponse result = apiInstance.vincdirDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling VincentysDirectApi.vincdirDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\VincentysDirectApi();
$body = ; // VincentysDirectDDRequest | 

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

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

my $api_instance = WWW::SwaggerClient::VincentysDirectApi->new();
my $body = WWW::SwaggerClient::Object::VincentysDirectDDRequest->new(); # VincentysDirectDDRequest | 

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

try: 
    # Input: Decimal degrees
    api_response = api_instance.vincdir_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VincentysDirectApi->vincdirDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

vincdirDdmPost

Input: Degrees decimal minutes

/vincdir/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/vincdir/ddm"

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

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

public class VincentysDirectApiExample {

    public static void main(String[] args) {
        
        VincentysDirectApi apiInstance = new VincentysDirectApi();
        VincentysDirectDDMRequest body = ; // VincentysDirectDDMRequest | 
        try {
            VincentysDirectDDMResponse result = apiInstance.vincdirDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysDirectApi#vincdirDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.VincentysDirectApi;

public class VincentysDirectApiExample {

    public static void main(String[] args) {
        VincentysDirectApi apiInstance = new VincentysDirectApi();
        VincentysDirectDDMRequest body = ; // VincentysDirectDDMRequest | 
        try {
            VincentysDirectDDMResponse result = apiInstance.vincdirDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysDirectApi#vincdirDdmPost");
            e.printStackTrace();
        }
    }
}

VincentysDirectDDMRequest *body = ; // 

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

// Input: Degrees decimal minutes
[apiInstance vincdirDdmPostWith:body
              completionHandler: ^(VincentysDirectDDMResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.VincentysDirectApi()

var body = ; // {VincentysDirectDDMRequest} 


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

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

namespace Example
{
    public class vincdirDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new VincentysDirectApi();
            var body = new VincentysDirectDDMRequest(); // VincentysDirectDDMRequest | 

            try
            {
                // Input: Degrees decimal minutes
                VincentysDirectDDMResponse result = apiInstance.vincdirDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling VincentysDirectApi.vincdirDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\VincentysDirectApi();
$body = ; // VincentysDirectDDMRequest | 

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

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

my $api_instance = WWW::SwaggerClient::VincentysDirectApi->new();
my $body = WWW::SwaggerClient::Object::VincentysDirectDDMRequest->new(); # VincentysDirectDDMRequest | 

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

try: 
    # Input: Degrees decimal minutes
    api_response = api_instance.vincdir_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VincentysDirectApi->vincdirDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

vincdirDmsPost

Input: Degrees minutes seconds

/vincdir/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/vincdir/dms"

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

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

public class VincentysDirectApiExample {

    public static void main(String[] args) {
        
        VincentysDirectApi apiInstance = new VincentysDirectApi();
        VincentysDirectDMSRequest body = ; // VincentysDirectDMSRequest | 
        try {
            VincentysDirectDMSResponse result = apiInstance.vincdirDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysDirectApi#vincdirDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.VincentysDirectApi;

public class VincentysDirectApiExample {

    public static void main(String[] args) {
        VincentysDirectApi apiInstance = new VincentysDirectApi();
        VincentysDirectDMSRequest body = ; // VincentysDirectDMSRequest | 
        try {
            VincentysDirectDMSResponse result = apiInstance.vincdirDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysDirectApi#vincdirDmsPost");
            e.printStackTrace();
        }
    }
}

VincentysDirectDMSRequest *body = ; // 

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

// Input: Degrees minutes seconds
[apiInstance vincdirDmsPostWith:body
              completionHandler: ^(VincentysDirectDMSResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.VincentysDirectApi()

var body = ; // {VincentysDirectDMSRequest} 


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

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

namespace Example
{
    public class vincdirDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new VincentysDirectApi();
            var body = new VincentysDirectDMSRequest(); // VincentysDirectDMSRequest | 

            try
            {
                // Input: Degrees minutes seconds
                VincentysDirectDMSResponse result = apiInstance.vincdirDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling VincentysDirectApi.vincdirDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\VincentysDirectApi();
$body = ; // VincentysDirectDMSRequest | 

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

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

my $api_instance = WWW::SwaggerClient::VincentysDirectApi->new();
my $body = WWW::SwaggerClient::Object::VincentysDirectDMSRequest->new(); # VincentysDirectDMSRequest | 

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

try: 
    # Input: Degrees minutes seconds
    api_response = api_instance.vincdir_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VincentysDirectApi->vincdirDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

vincdirUtmPost

Input: Universal transverse mercator (UTM)

/vincdir/utm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/vincdir/utm"

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

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

public class VincentysDirectApiExample {

    public static void main(String[] args) {
        
        VincentysDirectApi apiInstance = new VincentysDirectApi();
        VincentysDirectUTMRequest body = ; // VincentysDirectUTMRequest | 
        try {
            VincentysDirectUTMResponse result = apiInstance.vincdirUtmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysDirectApi#vincdirUtmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.VincentysDirectApi;

public class VincentysDirectApiExample {

    public static void main(String[] args) {
        VincentysDirectApi apiInstance = new VincentysDirectApi();
        VincentysDirectUTMRequest body = ; // VincentysDirectUTMRequest | 
        try {
            VincentysDirectUTMResponse result = apiInstance.vincdirUtmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysDirectApi#vincdirUtmPost");
            e.printStackTrace();
        }
    }
}

VincentysDirectUTMRequest *body = ; // 

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

// Input: Universal transverse mercator (UTM)
[apiInstance vincdirUtmPostWith:body
              completionHandler: ^(VincentysDirectUTMResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.VincentysDirectApi()

var body = ; // {VincentysDirectUTMRequest} 


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

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

namespace Example
{
    public class vincdirUtmPostExample
    {
        public void main()
        {
            
            var apiInstance = new VincentysDirectApi();
            var body = new VincentysDirectUTMRequest(); // VincentysDirectUTMRequest | 

            try
            {
                // Input: Universal transverse mercator (UTM)
                VincentysDirectUTMResponse result = apiInstance.vincdirUtmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling VincentysDirectApi.vincdirUtmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\VincentysDirectApi();
$body = ; // VincentysDirectUTMRequest | 

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

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

my $api_instance = WWW::SwaggerClient::VincentysDirectApi->new();
my $body = WWW::SwaggerClient::Object::VincentysDirectUTMRequest->new(); # VincentysDirectUTMRequest | 

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

try: 
    # Input: Universal transverse mercator (UTM)
    api_response = api_instance.vincdir_utm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VincentysDirectApi->vincdirUtmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

VincentysInverse

vincinvDdPost

Input: Decimal degrees

/vincinv/dd

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/vincinv/dd"

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

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

public class VincentysInverseApiExample {

    public static void main(String[] args) {
        
        VincentysInverseApi apiInstance = new VincentysInverseApi();
        VincentysInverseDDRequest body = ; // VincentysInverseDDRequest | 
        try {
            VincentysInverseDDResponse result = apiInstance.vincinvDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysInverseApi#vincinvDdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.VincentysInverseApi;

public class VincentysInverseApiExample {

    public static void main(String[] args) {
        VincentysInverseApi apiInstance = new VincentysInverseApi();
        VincentysInverseDDRequest body = ; // VincentysInverseDDRequest | 
        try {
            VincentysInverseDDResponse result = apiInstance.vincinvDdPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysInverseApi#vincinvDdPost");
            e.printStackTrace();
        }
    }
}

VincentysInverseDDRequest *body = ; // 

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

// Input: Decimal degrees
[apiInstance vincinvDdPostWith:body
              completionHandler: ^(VincentysInverseDDResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.VincentysInverseApi()

var body = ; // {VincentysInverseDDRequest} 


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

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

namespace Example
{
    public class vincinvDdPostExample
    {
        public void main()
        {
            
            var apiInstance = new VincentysInverseApi();
            var body = new VincentysInverseDDRequest(); // VincentysInverseDDRequest | 

            try
            {
                // Input: Decimal degrees
                VincentysInverseDDResponse result = apiInstance.vincinvDdPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling VincentysInverseApi.vincinvDdPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\VincentysInverseApi();
$body = ; // VincentysInverseDDRequest | 

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

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

my $api_instance = WWW::SwaggerClient::VincentysInverseApi->new();
my $body = WWW::SwaggerClient::Object::VincentysInverseDDRequest->new(); # VincentysInverseDDRequest | 

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

try: 
    # Input: Decimal degrees
    api_response = api_instance.vincinv_dd_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VincentysInverseApi->vincinvDdPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

vincinvDdmPost

Input: Degrees decimal minutes

/vincinv/ddm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/vincinv/ddm"

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

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

public class VincentysInverseApiExample {

    public static void main(String[] args) {
        
        VincentysInverseApi apiInstance = new VincentysInverseApi();
        VincentysInverseDDMRequest body = ; // VincentysInverseDDMRequest | 
        try {
            VincentysInverseDDMResponse result = apiInstance.vincinvDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysInverseApi#vincinvDdmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.VincentysInverseApi;

public class VincentysInverseApiExample {

    public static void main(String[] args) {
        VincentysInverseApi apiInstance = new VincentysInverseApi();
        VincentysInverseDDMRequest body = ; // VincentysInverseDDMRequest | 
        try {
            VincentysInverseDDMResponse result = apiInstance.vincinvDdmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysInverseApi#vincinvDdmPost");
            e.printStackTrace();
        }
    }
}

VincentysInverseDDMRequest *body = ; // 

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

// Input: Degrees decimal minutes
[apiInstance vincinvDdmPostWith:body
              completionHandler: ^(VincentysInverseDDMResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.VincentysInverseApi()

var body = ; // {VincentysInverseDDMRequest} 


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

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

namespace Example
{
    public class vincinvDdmPostExample
    {
        public void main()
        {
            
            var apiInstance = new VincentysInverseApi();
            var body = new VincentysInverseDDMRequest(); // VincentysInverseDDMRequest | 

            try
            {
                // Input: Degrees decimal minutes
                VincentysInverseDDMResponse result = apiInstance.vincinvDdmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling VincentysInverseApi.vincinvDdmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\VincentysInverseApi();
$body = ; // VincentysInverseDDMRequest | 

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

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

my $api_instance = WWW::SwaggerClient::VincentysInverseApi->new();
my $body = WWW::SwaggerClient::Object::VincentysInverseDDMRequest->new(); # VincentysInverseDDMRequest | 

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

try: 
    # Input: Degrees decimal minutes
    api_response = api_instance.vincinv_ddm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VincentysInverseApi->vincinvDdmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

vincinvDmsPost

Input: Degrees minutes seconds

/vincinv/dms

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/vincinv/dms"

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

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

public class VincentysInverseApiExample {

    public static void main(String[] args) {
        
        VincentysInverseApi apiInstance = new VincentysInverseApi();
        VincentysInverseDMSRequest body = ; // VincentysInverseDMSRequest | 
        try {
            VincentysInverseDMSResponse result = apiInstance.vincinvDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysInverseApi#vincinvDmsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.VincentysInverseApi;

public class VincentysInverseApiExample {

    public static void main(String[] args) {
        VincentysInverseApi apiInstance = new VincentysInverseApi();
        VincentysInverseDMSRequest body = ; // VincentysInverseDMSRequest | 
        try {
            VincentysInverseDMSResponse result = apiInstance.vincinvDmsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysInverseApi#vincinvDmsPost");
            e.printStackTrace();
        }
    }
}

VincentysInverseDMSRequest *body = ; // 

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

// Input: Degrees minutes seconds
[apiInstance vincinvDmsPostWith:body
              completionHandler: ^(VincentysInverseDMSResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.VincentysInverseApi()

var body = ; // {VincentysInverseDMSRequest} 


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

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

namespace Example
{
    public class vincinvDmsPostExample
    {
        public void main()
        {
            
            var apiInstance = new VincentysInverseApi();
            var body = new VincentysInverseDMSRequest(); // VincentysInverseDMSRequest | 

            try
            {
                // Input: Degrees minutes seconds
                VincentysInverseDMSResponse result = apiInstance.vincinvDmsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling VincentysInverseApi.vincinvDmsPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\VincentysInverseApi();
$body = ; // VincentysInverseDMSRequest | 

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

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

my $api_instance = WWW::SwaggerClient::VincentysInverseApi->new();
my $body = WWW::SwaggerClient::Object::VincentysInverseDMSRequest->new(); # VincentysInverseDMSRequest | 

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

try: 
    # Input: Degrees minutes seconds
    api_response = api_instance.vincinv_dms_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VincentysInverseApi->vincinvDmsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

vincinvUtmPost

Input: Universal transverse mercator (UTM)

/vincinv/utm

Usage and SDK Samples

curl -X POST "https://api.geodesyapps.ga.gov.au/vincinv/utm"

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

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

public class VincentysInverseApiExample {

    public static void main(String[] args) {
        
        VincentysInverseApi apiInstance = new VincentysInverseApi();
        VincentysInverseUTMRequest body = ; // VincentysInverseUTMRequest | 
        try {
            VincentysInverseUTMResponse result = apiInstance.vincinvUtmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysInverseApi#vincinvUtmPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.VincentysInverseApi;

public class VincentysInverseApiExample {

    public static void main(String[] args) {
        VincentysInverseApi apiInstance = new VincentysInverseApi();
        VincentysInverseUTMRequest body = ; // VincentysInverseUTMRequest | 
        try {
            VincentysInverseUTMResponse result = apiInstance.vincinvUtmPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VincentysInverseApi#vincinvUtmPost");
            e.printStackTrace();
        }
    }
}

VincentysInverseUTMRequest *body = ; // 

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

// Input: Universal transverse mercator (UTM)
[apiInstance vincinvUtmPostWith:body
              completionHandler: ^(VincentysInverseUTMResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GeodeticCalculatorsApi = require('geodetic_calculators_api');

var api = new GeodeticCalculatorsApi.VincentysInverseApi()

var body = ; // {VincentysInverseUTMRequest} 


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

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

namespace Example
{
    public class vincinvUtmPostExample
    {
        public void main()
        {
            
            var apiInstance = new VincentysInverseApi();
            var body = new VincentysInverseUTMRequest(); // VincentysInverseUTMRequest | 

            try
            {
                // Input: Universal transverse mercator (UTM)
                VincentysInverseUTMResponse result = apiInstance.vincinvUtmPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling VincentysInverseApi.vincinvUtmPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\VincentysInverseApi();
$body = ; // VincentysInverseUTMRequest | 

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

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

my $api_instance = WWW::SwaggerClient::VincentysInverseApi->new();
my $body = WWW::SwaggerClient::Object::VincentysInverseUTMRequest->new(); # VincentysInverseUTMRequest | 

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

try: 
    # Input: Universal transverse mercator (UTM)
    api_response = api_instance.vincinv_utm_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VincentysInverseApi->vincinvUtmPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

Generated 2024-11-25T00:07:20.699Z

Geodetic Calculators API

API and SDK Documentation

ATRF2014ToGDA2020

atrf2014ToGda2020DdDdPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

atrf2014ToGda2020DdDdmPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

atrf2014ToGda2020DdDmsPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

atrf2014ToGda2020DdmDdPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

atrf2014ToGda2020DdmDdmPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

atrf2014ToGda2020DdmDmsPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

atrf2014ToGda2020DmsDdPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

atrf2014ToGda2020DmsDdmPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

atrf2014ToGda2020DmsDmsPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

AUSGeoid

ausgeoidPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

AVWS

avwsPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

GDA2020ToATRF2014

gda2020ToAtrf2014DdDdPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

gda2020ToAtrf2014DdDdmPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

gda2020ToAtrf2014DdDmsPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

gda2020ToAtrf2014DdmDdPost

Usage and SDK Samples

Parameters

Responses