AWS Docs API

Default

createFormReviewWorkflowTag

create a form review workflow tag


/tags

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/tags" \
 -d '{
  "tagText" : "tagText"
}'

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        CreateFormReviewWorkflowTagInput createFormReviewWorkflowTagInput = ; // CreateFormReviewWorkflowTagInput | 

        try {
            FormReviewWorkflowTag result = apiInstance.createFormReviewWorkflowTag(createFormReviewWorkflowTagInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createFormReviewWorkflowTag");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        CreateFormReviewWorkflowTagInput createFormReviewWorkflowTagInput = ; // CreateFormReviewWorkflowTagInput | 

        try {
            FormReviewWorkflowTag result = apiInstance.createFormReviewWorkflowTag(createFormReviewWorkflowTagInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createFormReviewWorkflowTag");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
CreateFormReviewWorkflowTagInput *createFormReviewWorkflowTagInput = ; // 

[apiInstance createFormReviewWorkflowTagWith:createFormReviewWorkflowTagInput
              completionHandler: ^(FormReviewWorkflowTag output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var createFormReviewWorkflowTagInput = ; // {CreateFormReviewWorkflowTagInput} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var createFormReviewWorkflowTagInput = new CreateFormReviewWorkflowTagInput(); // CreateFormReviewWorkflowTagInput | 

            try {
                FormReviewWorkflowTag result = apiInstance.createFormReviewWorkflowTag(createFormReviewWorkflowTagInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.createFormReviewWorkflowTag: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$createFormReviewWorkflowTagInput = ; // CreateFormReviewWorkflowTagInput | 

try {
    $result = $api_instance->createFormReviewWorkflowTag($createFormReviewWorkflowTagInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createFormReviewWorkflowTag: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    my $result = $api_instance->createFormReviewWorkflowTag(createFormReviewWorkflowTagInput => $createFormReviewWorkflowTagInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createFormReviewWorkflowTag: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
createFormReviewWorkflowTagInput =  # CreateFormReviewWorkflowTagInput | 

try:
    api_response = api_instance.create_form_review_workflow_tag(createFormReviewWorkflowTagInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createFormReviewWorkflowTag: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let createFormReviewWorkflowTagInput = ; // CreateFormReviewWorkflowTagInput

    let mut context = DefaultApi::Context::default();
    let result = client.createFormReviewWorkflowTag(createFormReviewWorkflowTagInput, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
createFormReviewWorkflowTagInput *

Responses

createFormSchema

Create a new form schema


/schemas

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/schemas" \
 -d '{
  "schema" : {
    "writeOnly" : false,
    "nullable" : false,
    "minLength" : 0,
    "deprecated" : false,
    "pattern" : "pattern",
    "description" : "description",
    "title" : "title",
    "required" : [ "required", "required" ],
    "example" : "",
    "exclusiveMaximum" : false,
    "allOf" : [ null, null ],
    "oneOf" : [ null, null ],
    "default" : "",
    "maxProperties" : 0,
    "exclusiveMinimum" : false,
    "formatType" : "formatType",
    "order" : 7,
    "multipleOf" : 0.4145608029883936,
    "maxItems" : 0,
    "anyOf" : [ null, null ],
    "readOnly" : false,
    "enum" : [ "", "" ],
    "minProperties" : 0,
    "minItems" : 0,
    "extractionMetadata" : {
      "tablePosition" : 9,
      "formKey" : "formKey",
      "columnPosition" : 2,
      "textractQuery" : "textractQuery",
      "rowPosition" : 3
    },
    "uniqueItems" : false,
    "maximum" : 7.386281948385884,
    "additionalProperties" : true,
    "minimum" : 1.2315135367772556,
    "maxLength" : 0,
    "typeOf" : "array",
    "properties" : { }
  },
  "description" : "description",
  "title" : "title"
}'

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        FormSchemaInput formSchemaInput = ; // FormSchemaInput | 

        try {
            FormSchema result = apiInstance.createFormSchema(formSchemaInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createFormSchema");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        FormSchemaInput formSchemaInput = ; // FormSchemaInput | 

        try {
            FormSchema result = apiInstance.createFormSchema(formSchemaInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createFormSchema");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
FormSchemaInput *formSchemaInput = ; // 

[apiInstance createFormSchemaWith:formSchemaInput
              completionHandler: ^(FormSchema output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var formSchemaInput = ; // {FormSchemaInput} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var formSchemaInput = new FormSchemaInput(); // FormSchemaInput | 

            try {
                FormSchema result = apiInstance.createFormSchema(formSchemaInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.createFormSchema: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$formSchemaInput = ; // FormSchemaInput | 

try {
    $result = $api_instance->createFormSchema($formSchemaInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createFormSchema: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    my $result = $api_instance->createFormSchema(formSchemaInput => $formSchemaInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createFormSchema: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
formSchemaInput =  # FormSchemaInput | 

try:
    api_response = api_instance.create_form_schema(formSchemaInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createFormSchema: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let formSchemaInput = ; // FormSchemaInput

    let mut context = DefaultApi::Context::default();
    let result = client.createFormSchema(formSchemaInput, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
formSchemaInput *

Responses

deleteFormSchema

Delete a form schema


/schemas/{schemaId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/schemas/{schemaId}"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String schemaId = schemaId_example; // String | 

        try {
            FormSchema result = apiInstance.deleteFormSchema(schemaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteFormSchema");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String schemaId = schemaId_example; // String | 

        try {
            FormSchema result = apiInstance.deleteFormSchema(schemaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteFormSchema");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *schemaId = schemaId_example; //  (default to null)

[apiInstance deleteFormSchemaWith:schemaId
              completionHandler: ^(FormSchema output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var schemaId = schemaId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var schemaId = schemaId_example;  // String |  (default to null)

            try {
                FormSchema result = apiInstance.deleteFormSchema(schemaId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteFormSchema: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$schemaId = schemaId_example; // String | 

try {
    $result = $api_instance->deleteFormSchema($schemaId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteFormSchema: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $schemaId = schemaId_example; # String | 

eval {
    my $result = $api_instance->deleteFormSchema(schemaId => $schemaId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteFormSchema: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
schemaId = schemaId_example # String |  (default to null)

try:
    api_response = api_instance.delete_form_schema(schemaId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteFormSchema: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let schemaId = schemaId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.deleteFormSchema(schemaId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
schemaId*
String
Required

Responses

getDocument

Get details about a document being ingested


/documents/{documentId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/documents/{documentId}"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String documentId = documentId_example; // String | 

        try {
            DocumentMetadata result = apiInstance.getDocument(documentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getDocument");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String documentId = documentId_example; // String | 

        try {
            DocumentMetadata result = apiInstance.getDocument(documentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getDocument");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *documentId = documentId_example; //  (default to null)

[apiInstance getDocumentWith:documentId
              completionHandler: ^(DocumentMetadata output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var documentId = documentId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var documentId = documentId_example;  // String |  (default to null)

            try {
                DocumentMetadata result = apiInstance.getDocument(documentId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getDocument: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$documentId = documentId_example; // String | 

try {
    $result = $api_instance->getDocument($documentId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getDocument: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $documentId = documentId_example; # String | 

eval {
    my $result = $api_instance->getDocument(documentId => $documentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getDocument: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
documentId = documentId_example # String |  (default to null)

try:
    api_response = api_instance.get_document(documentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getDocument: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let documentId = documentId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getDocument(documentId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
documentId*
String
Required

Responses

getDocumentForm

Get details about a form within a processed document


/documents/{documentId}/forms/{formId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/documents/{documentId}/forms/{formId}"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String documentId = documentId_example; // String | 
        String formId = formId_example; // String | 

        try {
            FormMetadata result = apiInstance.getDocumentForm(documentId, formId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getDocumentForm");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String documentId = documentId_example; // String | 
        String formId = formId_example; // String | 

        try {
            FormMetadata result = apiInstance.getDocumentForm(documentId, formId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getDocumentForm");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *documentId = documentId_example; //  (default to null)
String *formId = formId_example; //  (default to null)

[apiInstance getDocumentFormWith:documentId
    formId:formId
              completionHandler: ^(FormMetadata output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var documentId = documentId_example; // {String} 
var formId = formId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var documentId = documentId_example;  // String |  (default to null)
            var formId = formId_example;  // String |  (default to null)

            try {
                FormMetadata result = apiInstance.getDocumentForm(documentId, formId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getDocumentForm: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$documentId = documentId_example; // String | 
$formId = formId_example; // String | 

try {
    $result = $api_instance->getDocumentForm($documentId, $formId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getDocumentForm: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $documentId = documentId_example; # String | 
my $formId = formId_example; # String | 

eval {
    my $result = $api_instance->getDocumentForm(documentId => $documentId, formId => $formId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getDocumentForm: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
documentId = documentId_example # String |  (default to null)
formId = formId_example # String |  (default to null)

try:
    api_response = api_instance.get_document_form(documentId, formId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getDocumentForm: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let documentId = documentId_example; // String
    let formId = formId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getDocumentForm(documentId, formId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
documentId*
String
Required
formId*
String
Required

Responses

getDocumentUploadUrl

Get a presigned url for uploading a document


/documents/upload-url

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/documents/upload-url?fileName=fileName_example&contentType=contentType_example"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String fileName = fileName_example; // String | 
        String contentType = contentType_example; // String | 

        try {
            GetDocumentUploadUrlResponse result = apiInstance.getDocumentUploadUrl(fileName, contentType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getDocumentUploadUrl");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String fileName = fileName_example; // String | 
        String contentType = contentType_example; // String | 

        try {
            GetDocumentUploadUrlResponse result = apiInstance.getDocumentUploadUrl(fileName, contentType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getDocumentUploadUrl");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *fileName = fileName_example; //  (default to null)
String *contentType = contentType_example; //  (default to null)

[apiInstance getDocumentUploadUrlWith:fileName
    contentType:contentType
              completionHandler: ^(GetDocumentUploadUrlResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var fileName = fileName_example; // {String} 
var contentType = contentType_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var fileName = fileName_example;  // String |  (default to null)
            var contentType = contentType_example;  // String |  (default to null)

            try {
                GetDocumentUploadUrlResponse result = apiInstance.getDocumentUploadUrl(fileName, contentType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getDocumentUploadUrl: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$fileName = fileName_example; // String | 
$contentType = contentType_example; // String | 

try {
    $result = $api_instance->getDocumentUploadUrl($fileName, $contentType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getDocumentUploadUrl: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $fileName = fileName_example; # String | 
my $contentType = contentType_example; # String | 

eval {
    my $result = $api_instance->getDocumentUploadUrl(fileName => $fileName, contentType => $contentType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getDocumentUploadUrl: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
fileName = fileName_example # String |  (default to null)
contentType = contentType_example # String |  (default to null)

try:
    api_response = api_instance.get_document_upload_url(fileName, contentType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getDocumentUploadUrl: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let fileName = fileName_example; // String
    let contentType = contentType_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getDocumentUploadUrl(fileName, contentType, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
fileName*
String
Required
contentType*
String
Required

Responses

getFormSchema

Retrieve a specific form schema


/schemas/{schemaId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/schemas/{schemaId}"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String schemaId = schemaId_example; // String | 

        try {
            FormSchema result = apiInstance.getFormSchema(schemaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getFormSchema");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String schemaId = schemaId_example; // String | 

        try {
            FormSchema result = apiInstance.getFormSchema(schemaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getFormSchema");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *schemaId = schemaId_example; //  (default to null)

[apiInstance getFormSchemaWith:schemaId
              completionHandler: ^(FormSchema output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var schemaId = schemaId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var schemaId = schemaId_example;  // String |  (default to null)

            try {
                FormSchema result = apiInstance.getFormSchema(schemaId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getFormSchema: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$schemaId = schemaId_example; // String | 

try {
    $result = $api_instance->getFormSchema($schemaId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getFormSchema: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $schemaId = schemaId_example; # String | 

eval {
    my $result = $api_instance->getFormSchema(schemaId => $schemaId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getFormSchema: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
schemaId = schemaId_example # String |  (default to null)

try:
    api_response = api_instance.get_form_schema(schemaId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getFormSchema: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let schemaId = schemaId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getFormSchema(schemaId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
schemaId*
String
Required

Responses

getMetrics

Retrieve average aggregate metrics for disclosure data extraction for the given time period


/metrics

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/metrics?startTimestamp=startTimestamp_example&endTimestamp=endTimestamp_example"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String startTimestamp = startTimestamp_example; // String | 
        String endTimestamp = endTimestamp_example; // String | 

        try {
            AggregateMetrics result = apiInstance.getMetrics(startTimestamp, endTimestamp);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getMetrics");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String startTimestamp = startTimestamp_example; // String | 
        String endTimestamp = endTimestamp_example; // String | 

        try {
            AggregateMetrics result = apiInstance.getMetrics(startTimestamp, endTimestamp);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getMetrics");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *startTimestamp = startTimestamp_example; //  (default to null)
String *endTimestamp = endTimestamp_example; //  (default to null)

[apiInstance getMetricsWith:startTimestamp
    endTimestamp:endTimestamp
              completionHandler: ^(AggregateMetrics output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var startTimestamp = startTimestamp_example; // {String} 
var endTimestamp = endTimestamp_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var startTimestamp = startTimestamp_example;  // String |  (default to null)
            var endTimestamp = endTimestamp_example;  // String |  (default to null)

            try {
                AggregateMetrics result = apiInstance.getMetrics(startTimestamp, endTimestamp);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getMetrics: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$startTimestamp = startTimestamp_example; // String | 
$endTimestamp = endTimestamp_example; // String | 

try {
    $result = $api_instance->getMetrics($startTimestamp, $endTimestamp);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getMetrics: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $startTimestamp = startTimestamp_example; # String | 
my $endTimestamp = endTimestamp_example; # String | 

eval {
    my $result = $api_instance->getMetrics(startTimestamp => $startTimestamp, endTimestamp => $endTimestamp);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getMetrics: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
startTimestamp = startTimestamp_example # String |  (default to null)
endTimestamp = endTimestamp_example # String |  (default to null)

try:
    api_response = api_instance.get_metrics(startTimestamp, endTimestamp)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getMetrics: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let startTimestamp = startTimestamp_example; // String
    let endTimestamp = endTimestamp_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getMetrics(startTimestamp, endTimestamp, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
startTimestamp*
String
Required
endTimestamp*
String
Required

Responses

listDocumentForms

Get details about the forms within a processed document


/documents/{documentId}/forms

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/documents/{documentId}/forms?pageSize=56&nextToken=nextToken_example"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String documentId = documentId_example; // String | 
        Integer pageSize = 56; // Integer | The number of results to return in a page
        String nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

        try {
            ListFormsResponse result = apiInstance.listDocumentForms(documentId, pageSize, nextToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listDocumentForms");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String documentId = documentId_example; // String | 
        Integer pageSize = 56; // Integer | The number of results to return in a page
        String nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

        try {
            ListFormsResponse result = apiInstance.listDocumentForms(documentId, pageSize, nextToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listDocumentForms");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *documentId = documentId_example; //  (default to null)
Integer *pageSize = 56; // The number of results to return in a page (default to null)
String *nextToken = nextToken_example; // Passed to continue retrieving pages of results (optional) (default to null)

[apiInstance listDocumentFormsWith:documentId
    pageSize:pageSize
    nextToken:nextToken
              completionHandler: ^(ListFormsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var documentId = documentId_example; // {String} 
var pageSize = 56; // {Integer} The number of results to return in a page
var opts = {
  'nextToken': nextToken_example // {String} Passed to continue retrieving pages of results
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var documentId = documentId_example;  // String |  (default to null)
            var pageSize = 56;  // Integer | The number of results to return in a page (default to null)
            var nextToken = nextToken_example;  // String | Passed to continue retrieving pages of results (optional)  (default to null)

            try {
                ListFormsResponse result = apiInstance.listDocumentForms(documentId, pageSize, nextToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.listDocumentForms: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$documentId = documentId_example; // String | 
$pageSize = 56; // Integer | The number of results to return in a page
$nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

try {
    $result = $api_instance->listDocumentForms($documentId, $pageSize, $nextToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->listDocumentForms: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $documentId = documentId_example; # String | 
my $pageSize = 56; # Integer | The number of results to return in a page
my $nextToken = nextToken_example; # String | Passed to continue retrieving pages of results

eval {
    my $result = $api_instance->listDocumentForms(documentId => $documentId, pageSize => $pageSize, nextToken => $nextToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->listDocumentForms: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
documentId = documentId_example # String |  (default to null)
pageSize = 56 # Integer | The number of results to return in a page (default to null)
nextToken = nextToken_example # String | Passed to continue retrieving pages of results (optional) (default to null)

try:
    api_response = api_instance.list_document_forms(documentId, pageSize, nextToken=nextToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->listDocumentForms: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let documentId = documentId_example; // String
    let pageSize = 56; // Integer
    let nextToken = nextToken_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.listDocumentForms(documentId, pageSize, nextToken, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
documentId*
String
Required
Query parameters
Name Description
pageSize*
Integer
The number of results to return in a page
Required
nextToken
String
Passed to continue retrieving pages of results

Responses

listDocuments

List all documents


/documents

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/documents?pageSize=56&nextToken=nextToken_example"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Integer pageSize = 56; // Integer | The number of results to return in a page
        String nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

        try {
            ListDocumentsResponse result = apiInstance.listDocuments(pageSize, nextToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listDocuments");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer pageSize = 56; // Integer | The number of results to return in a page
        String nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

        try {
            ListDocumentsResponse result = apiInstance.listDocuments(pageSize, nextToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listDocuments");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Integer *pageSize = 56; // The number of results to return in a page (default to null)
String *nextToken = nextToken_example; // Passed to continue retrieving pages of results (optional) (default to null)

[apiInstance listDocumentsWith:pageSize
    nextToken:nextToken
              completionHandler: ^(ListDocumentsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var pageSize = 56; // {Integer} The number of results to return in a page
var opts = {
  'nextToken': nextToken_example // {String} Passed to continue retrieving pages of results
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var pageSize = 56;  // Integer | The number of results to return in a page (default to null)
            var nextToken = nextToken_example;  // String | Passed to continue retrieving pages of results (optional)  (default to null)

            try {
                ListDocumentsResponse result = apiInstance.listDocuments(pageSize, nextToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.listDocuments: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$pageSize = 56; // Integer | The number of results to return in a page
$nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

try {
    $result = $api_instance->listDocuments($pageSize, $nextToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->listDocuments: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $pageSize = 56; # Integer | The number of results to return in a page
my $nextToken = nextToken_example; # String | Passed to continue retrieving pages of results

eval {
    my $result = $api_instance->listDocuments(pageSize => $pageSize, nextToken => $nextToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->listDocuments: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
pageSize = 56 # Integer | The number of results to return in a page (default to null)
nextToken = nextToken_example # String | Passed to continue retrieving pages of results (optional) (default to null)

try:
    api_response = api_instance.list_documents(pageSize, nextToken=nextToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->listDocuments: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let pageSize = 56; // Integer
    let nextToken = nextToken_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.listDocuments(pageSize, nextToken, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
pageSize*
Integer
The number of results to return in a page
Required
nextToken
String
Passed to continue retrieving pages of results

Responses

listFormReviewWorkflowTags

List all form review workflow tags


/tags

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/tags?pageSize=56&nextToken=nextToken_example"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Integer pageSize = 56; // Integer | The number of results to return in a page
        String nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

        try {
            ListFormReviewWorkflowTagsResponse result = apiInstance.listFormReviewWorkflowTags(pageSize, nextToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listFormReviewWorkflowTags");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer pageSize = 56; // Integer | The number of results to return in a page
        String nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

        try {
            ListFormReviewWorkflowTagsResponse result = apiInstance.listFormReviewWorkflowTags(pageSize, nextToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listFormReviewWorkflowTags");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Integer *pageSize = 56; // The number of results to return in a page (default to null)
String *nextToken = nextToken_example; // Passed to continue retrieving pages of results (optional) (default to null)

[apiInstance listFormReviewWorkflowTagsWith:pageSize
    nextToken:nextToken
              completionHandler: ^(ListFormReviewWorkflowTagsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var pageSize = 56; // {Integer} The number of results to return in a page
var opts = {
  'nextToken': nextToken_example // {String} Passed to continue retrieving pages of results
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var pageSize = 56;  // Integer | The number of results to return in a page (default to null)
            var nextToken = nextToken_example;  // String | Passed to continue retrieving pages of results (optional)  (default to null)

            try {
                ListFormReviewWorkflowTagsResponse result = apiInstance.listFormReviewWorkflowTags(pageSize, nextToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.listFormReviewWorkflowTags: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$pageSize = 56; // Integer | The number of results to return in a page
$nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

try {
    $result = $api_instance->listFormReviewWorkflowTags($pageSize, $nextToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->listFormReviewWorkflowTags: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $pageSize = 56; # Integer | The number of results to return in a page
my $nextToken = nextToken_example; # String | Passed to continue retrieving pages of results

eval {
    my $result = $api_instance->listFormReviewWorkflowTags(pageSize => $pageSize, nextToken => $nextToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->listFormReviewWorkflowTags: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
pageSize = 56 # Integer | The number of results to return in a page (default to null)
nextToken = nextToken_example # String | Passed to continue retrieving pages of results (optional) (default to null)

try:
    api_response = api_instance.list_form_review_workflow_tags(pageSize, nextToken=nextToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->listFormReviewWorkflowTags: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let pageSize = 56; // Integer
    let nextToken = nextToken_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.listFormReviewWorkflowTags(pageSize, nextToken, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
pageSize*
Integer
The number of results to return in a page
Required
nextToken
String
Passed to continue retrieving pages of results

Responses

listFormSchemas

List all schemas for forms


/schemas

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/schemas?pageSize=56&nextToken=nextToken_example"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Integer pageSize = 56; // Integer | The number of results to return in a page
        String nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

        try {
            ListFormSchemasResponse result = apiInstance.listFormSchemas(pageSize, nextToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listFormSchemas");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer pageSize = 56; // Integer | The number of results to return in a page
        String nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

        try {
            ListFormSchemasResponse result = apiInstance.listFormSchemas(pageSize, nextToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listFormSchemas");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Integer *pageSize = 56; // The number of results to return in a page (default to null)
String *nextToken = nextToken_example; // Passed to continue retrieving pages of results (optional) (default to null)

[apiInstance listFormSchemasWith:pageSize
    nextToken:nextToken
              completionHandler: ^(ListFormSchemasResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var pageSize = 56; // {Integer} The number of results to return in a page
var opts = {
  'nextToken': nextToken_example // {String} Passed to continue retrieving pages of results
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var pageSize = 56;  // Integer | The number of results to return in a page (default to null)
            var nextToken = nextToken_example;  // String | Passed to continue retrieving pages of results (optional)  (default to null)

            try {
                ListFormSchemasResponse result = apiInstance.listFormSchemas(pageSize, nextToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.listFormSchemas: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$pageSize = 56; // Integer | The number of results to return in a page
$nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

try {
    $result = $api_instance->listFormSchemas($pageSize, $nextToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->listFormSchemas: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $pageSize = 56; # Integer | The number of results to return in a page
my $nextToken = nextToken_example; # String | Passed to continue retrieving pages of results

eval {
    my $result = $api_instance->listFormSchemas(pageSize => $pageSize, nextToken => $nextToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->listFormSchemas: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
pageSize = 56 # Integer | The number of results to return in a page (default to null)
nextToken = nextToken_example # String | Passed to continue retrieving pages of results (optional) (default to null)

try:
    api_response = api_instance.list_form_schemas(pageSize, nextToken=nextToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->listFormSchemas: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let pageSize = 56; // Integer
    let nextToken = nextToken_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.listFormSchemas(pageSize, nextToken, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
pageSize*
Integer
The number of results to return in a page
Required
nextToken
String
Passed to continue retrieving pages of results

Responses

listForms

List all forms within documents


/forms

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/forms?pageSize=56&nextToken=nextToken_example"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Integer pageSize = 56; // Integer | The number of results to return in a page
        String nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

        try {
            ListFormsResponse result = apiInstance.listForms(pageSize, nextToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listForms");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer pageSize = 56; // Integer | The number of results to return in a page
        String nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

        try {
            ListFormsResponse result = apiInstance.listForms(pageSize, nextToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#listForms");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Integer *pageSize = 56; // The number of results to return in a page (default to null)
String *nextToken = nextToken_example; // Passed to continue retrieving pages of results (optional) (default to null)

[apiInstance listFormsWith:pageSize
    nextToken:nextToken
              completionHandler: ^(ListFormsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var pageSize = 56; // {Integer} The number of results to return in a page
var opts = {
  'nextToken': nextToken_example // {String} Passed to continue retrieving pages of results
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var pageSize = 56;  // Integer | The number of results to return in a page (default to null)
            var nextToken = nextToken_example;  // String | Passed to continue retrieving pages of results (optional)  (default to null)

            try {
                ListFormsResponse result = apiInstance.listForms(pageSize, nextToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.listForms: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$pageSize = 56; // Integer | The number of results to return in a page
$nextToken = nextToken_example; // String | Passed to continue retrieving pages of results

try {
    $result = $api_instance->listForms($pageSize, $nextToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->listForms: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $pageSize = 56; # Integer | The number of results to return in a page
my $nextToken = nextToken_example; # String | Passed to continue retrieving pages of results

eval {
    my $result = $api_instance->listForms(pageSize => $pageSize, nextToken => $nextToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->listForms: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
pageSize = 56 # Integer | The number of results to return in a page (default to null)
nextToken = nextToken_example # String | Passed to continue retrieving pages of results (optional) (default to null)

try:
    api_response = api_instance.list_forms(pageSize, nextToken=nextToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->listForms: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let pageSize = 56; // Integer
    let nextToken = nextToken_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.listForms(pageSize, nextToken, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
pageSize*
Integer
The number of results to return in a page
Required
nextToken
String
Passed to continue retrieving pages of results

Responses

submitSourceDocument

Submit a document for processing


/sources/document

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/sources/document" \
 -d '{
  "schemaId" : "schemaId",
  "name" : "name",
  "documentId" : "documentId",
  "location" : {
    "bucket" : "bucket",
    "objectKey" : "objectKey"
  }
}'

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        SubmitSourceDocumentInput submitSourceDocumentInput = ; // SubmitSourceDocumentInput | 

        try {
            DocumentMetadata result = apiInstance.submitSourceDocument(submitSourceDocumentInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#submitSourceDocument");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        SubmitSourceDocumentInput submitSourceDocumentInput = ; // SubmitSourceDocumentInput | 

        try {
            DocumentMetadata result = apiInstance.submitSourceDocument(submitSourceDocumentInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#submitSourceDocument");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
SubmitSourceDocumentInput *submitSourceDocumentInput = ; // 

[apiInstance submitSourceDocumentWith:submitSourceDocumentInput
              completionHandler: ^(DocumentMetadata output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var submitSourceDocumentInput = ; // {SubmitSourceDocumentInput} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var submitSourceDocumentInput = new SubmitSourceDocumentInput(); // SubmitSourceDocumentInput | 

            try {
                DocumentMetadata result = apiInstance.submitSourceDocument(submitSourceDocumentInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.submitSourceDocument: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$submitSourceDocumentInput = ; // SubmitSourceDocumentInput | 

try {
    $result = $api_instance->submitSourceDocument($submitSourceDocumentInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->submitSourceDocument: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    my $result = $api_instance->submitSourceDocument(submitSourceDocumentInput => $submitSourceDocumentInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->submitSourceDocument: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
submitSourceDocumentInput =  # SubmitSourceDocumentInput | 

try:
    api_response = api_instance.submit_source_document(submitSourceDocumentInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->submitSourceDocument: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let submitSourceDocumentInput = ; // SubmitSourceDocumentInput

    let mut context = DefaultApi::Context::default();
    let result = client.submitSourceDocument(submitSourceDocumentInput, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
submitSourceDocumentInput *

Responses

updateFormReview

Update the extracted data details object from a document form


/documents/{documentId}/forms/{formId}/review

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/documents/{documentId}/forms/{formId}/review" \
 -d '{
  "notes" : "notes",
  "extractedData" : "{}",
  "tags" : [ "tags", "tags" ]
}'

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String documentId = documentId_example; // String | 
        String formId = formId_example; // String | 
        UpdateFormInput updateFormInput = ; // UpdateFormInput | 

        try {
            FormMetadata result = apiInstance.updateFormReview(documentId, formId, updateFormInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateFormReview");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String documentId = documentId_example; // String | 
        String formId = formId_example; // String | 
        UpdateFormInput updateFormInput = ; // UpdateFormInput | 

        try {
            FormMetadata result = apiInstance.updateFormReview(documentId, formId, updateFormInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateFormReview");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *documentId = documentId_example; //  (default to null)
String *formId = formId_example; //  (default to null)
UpdateFormInput *updateFormInput = ; // 

[apiInstance updateFormReviewWith:documentId
    formId:formId
    updateFormInput:updateFormInput
              completionHandler: ^(FormMetadata output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var documentId = documentId_example; // {String} 
var formId = formId_example; // {String} 
var updateFormInput = ; // {UpdateFormInput} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var documentId = documentId_example;  // String |  (default to null)
            var formId = formId_example;  // String |  (default to null)
            var updateFormInput = new UpdateFormInput(); // UpdateFormInput | 

            try {
                FormMetadata result = apiInstance.updateFormReview(documentId, formId, updateFormInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateFormReview: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$documentId = documentId_example; // String | 
$formId = formId_example; // String | 
$updateFormInput = ; // UpdateFormInput | 

try {
    $result = $api_instance->updateFormReview($documentId, $formId, $updateFormInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateFormReview: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $documentId = documentId_example; # String | 
my $formId = formId_example; # String | 
my $updateFormInput = WWW::OPenAPIClient::Object::UpdateFormInput->new(); # UpdateFormInput | 

eval {
    my $result = $api_instance->updateFormReview(documentId => $documentId, formId => $formId, updateFormInput => $updateFormInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateFormReview: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
documentId = documentId_example # String |  (default to null)
formId = formId_example # String |  (default to null)
updateFormInput =  # UpdateFormInput | 

try:
    api_response = api_instance.update_form_review(documentId, formId, updateFormInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateFormReview: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let documentId = documentId_example; // String
    let formId = formId_example; // String
    let updateFormInput = ; // UpdateFormInput

    let mut context = DefaultApi::Context::default();
    let result = client.updateFormReview(documentId, formId, updateFormInput, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
documentId*
String
Required
formId*
String
Required
Body parameters
Name Description
updateFormInput *

Responses

updateFormSchema

Update an existing form schema


/schemas/{schemaId}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/schemas/{schemaId}" \
 -d '{
  "schemaId" : "schemaId"
}'

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String schemaId = schemaId_example; // String | 
        FormSchema formSchema = ; // FormSchema | 

        try {
            FormSchema result = apiInstance.updateFormSchema(schemaId, formSchema);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateFormSchema");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String schemaId = schemaId_example; // String | 
        FormSchema formSchema = ; // FormSchema | 

        try {
            FormSchema result = apiInstance.updateFormSchema(schemaId, formSchema);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateFormSchema");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *schemaId = schemaId_example; //  (default to null)
FormSchema *formSchema = ; // 

[apiInstance updateFormSchemaWith:schemaId
    formSchema:formSchema
              completionHandler: ^(FormSchema output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var schemaId = schemaId_example; // {String} 
var formSchema = ; // {FormSchema} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var schemaId = schemaId_example;  // String |  (default to null)
            var formSchema = new FormSchema(); // FormSchema | 

            try {
                FormSchema result = apiInstance.updateFormSchema(schemaId, formSchema);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateFormSchema: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$schemaId = schemaId_example; // String | 
$formSchema = ; // FormSchema | 

try {
    $result = $api_instance->updateFormSchema($schemaId, $formSchema);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateFormSchema: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $schemaId = schemaId_example; # String | 
my $formSchema = WWW::OPenAPIClient::Object::FormSchema->new(); # FormSchema | 

eval {
    my $result = $api_instance->updateFormSchema(schemaId => $schemaId, formSchema => $formSchema);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateFormSchema: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
schemaId = schemaId_example # String |  (default to null)
formSchema =  # FormSchema | 

try:
    api_response = api_instance.update_form_schema(schemaId, formSchema)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateFormSchema: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let schemaId = schemaId_example; // String
    let formSchema = ; // FormSchema

    let mut context = DefaultApi::Context::default();
    let result = client.updateFormSchema(schemaId, formSchema, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
schemaId*
String
Required
Body parameters
Name Description
formSchema *

Responses

updateStatus

start a new review


/documents/{documentId}/forms/{formId}/status

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/documents/{documentId}/forms/{formId}/status" \
 -d '{
  "newStatus" : "newStatus"
}'

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String documentId = documentId_example; // String | 
        String formId = formId_example; // String | 
        UpdateStatusInput updateStatusInput = ; // UpdateStatusInput | 

        try {
            FormMetadata result = apiInstance.updateStatus(documentId, formId, updateStatusInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateStatus");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String documentId = documentId_example; // String | 
        String formId = formId_example; // String | 
        UpdateStatusInput updateStatusInput = ; // UpdateStatusInput | 

        try {
            FormMetadata result = apiInstance.updateStatus(documentId, formId, updateStatusInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateStatus");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *documentId = documentId_example; //  (default to null)
String *formId = formId_example; //  (default to null)
UpdateStatusInput *updateStatusInput = ; // 

[apiInstance updateStatusWith:documentId
    formId:formId
    updateStatusInput:updateStatusInput
              completionHandler: ^(FormMetadata output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AwsDocsApi = require('aws_docs_api');

// Create an instance of the API class
var api = new AwsDocsApi.DefaultApi()
var documentId = documentId_example; // {String} 
var formId = formId_example; // {String} 
var updateStatusInput = ; // {UpdateStatusInput} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var documentId = documentId_example;  // String |  (default to null)
            var formId = formId_example;  // String |  (default to null)
            var updateStatusInput = new UpdateStatusInput(); // UpdateStatusInput | 

            try {
                FormMetadata result = apiInstance.updateStatus(documentId, formId, updateStatusInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateStatus: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$documentId = documentId_example; // String | 
$formId = formId_example; // String | 
$updateStatusInput = ; // UpdateStatusInput | 

try {
    $result = $api_instance->updateStatus($documentId, $formId, $updateStatusInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $documentId = documentId_example; # String | 
my $formId = formId_example; # String | 
my $updateStatusInput = WWW::OPenAPIClient::Object::UpdateStatusInput->new(); # UpdateStatusInput | 

eval {
    my $result = $api_instance->updateStatus(documentId => $documentId, formId => $formId, updateStatusInput => $updateStatusInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateStatus: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
documentId = documentId_example # String |  (default to null)
formId = formId_example # String |  (default to null)
updateStatusInput =  # UpdateStatusInput | 

try:
    api_response = api_instance.update_status(documentId, formId, updateStatusInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateStatus: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let documentId = documentId_example; // String
    let formId = formId_example; // String
    let updateStatusInput = ; // UpdateStatusInput

    let mut context = DefaultApi::Context::default();
    let result = client.updateStatus(documentId, formId, updateStatusInput, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
documentId*
String
Required
formId*
String
Required
Body parameters
Name Description
updateStatusInput *

Responses