lilt.CreateApi

All URIs are relative to https://api.lilt.com

Method	HTTP request	Description
delete_lilt_create_content	DELETE /v2/create/{contentId}	Delete Lilt Create content
generate_lilt_create_content	POST /v2/create	Generate new Lilt Create content
get_lilt_create_by_id	GET /v2/create/{contentId}	Get Lilt Create content by ID.
get_lilt_create_content	GET /v2/create	Get Lilt Create content
get_lilt_create_preferences	GET /v2/create/preferences	Get Lilt Create preferences
regenerate_lilt_create_content	GET /v2/create/{contentId}/create	Regenerate Lilt Create content
sign_lilt_create_terms	POST /v2/create/terms-and-conditions	Sign the Lilt Create terms and conditions
update_lilt_create_content	PUT /v2/create/{contentId}	Update Lilt Create content
update_lilt_create_preferences	PUT /v2/create/preferences	Update Lilt Create preferences

delete_lilt_create_content

InlineResponse200 delete_lilt_create_content(content_id)

Delete Lilt Create content

Delete a piece of Lilt Create content. Example CURL: bash curl -X DELETE 'https://api.lilt.com/v2/create/1234?key=API_KEY'

Example

Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client) content_id = 56 # int | The content ID.

try:
    # Delete Lilt Create content
    api_response = api_instance.delete_lilt_create_content(content_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CreateApi->delete_lilt_create_content: %s\n" % e) ```

Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client) content_id = 56 # int | The content ID.

try:
    # Delete Lilt Create content
    api_response = api_instance.delete_lilt_create_content(content_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CreateApi->delete_lilt_create_content: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
content_id	int	The content ID.

Return type

InlineResponse200

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json, application/octet-stream, text/plain

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 200 | The Delete Lilt Create Content Response. | - | 401 | Unauthorized | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

generate_lilt_create_content

generate_lilt_create_content(template_params)

Generate new Lilt Create content

Generate new Lilt Create content with the given parameters. Example CURL: bash curl -X POST 'https://api.lilt.com/v2/create?key=API_KEY' \\ --header 'Content-Type: application/json' \\ --data-raw '{ \"language\":\"en-US\", \"template\":\"blog-post\", \"templateParams\":{ \"contentLength\":\"100\", \"language\":\"en-US\", \"sections\":[], \"summary\":\"a blog post about hiking\" }, \"preferences\":{\"tone\":\"formal\",\"styleguide\":\"\"} }'

Example

Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client) template_params = lilt.LiltCreateContentRequest() # LiltCreateContentRequest | Input parameters that determine what content will be generated.

try:
    # Generate new Lilt Create content
    api_instance.generate_lilt_create_content(template_params)
except ApiException as e:
    print("Exception when calling CreateApi->generate_lilt_create_content: %s\n" % e) ```

Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

try:
    # Generate new Lilt Create content
    api_instance.generate_lilt_create_content(template_params)
except ApiException as e:
    print("Exception when calling CreateApi->generate_lilt_create_content: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
template_params	LiltCreateContentRequest	Input parameters that determine what content will be generated.

Return type

void (empty response body)

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: application/json
Accept: application/octet-stream, text/plain, application/json

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 200 | An event stream produced by Server Side Events. The following events are supported. - message: an object with the newly generated text (e.g. {\"text\": \"hello\"}) - message: upon completion of events the string \"[DONE]\" will be emitted - fullcontent: an object containing the full response | - | 401 | Unauthorized | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

get_lilt_create_by_id

LiltCreateContent get_lilt_create_by_id(content_id)

Get Lilt Create content by ID.

Get Lilt Create content by ID. Example CURL: bash curl -X GET 'https://api.lilt.com/v2/create/1234?key=API_KEY'

Example

Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client) content_id = 56 # int | The content ID.

try:
    # Get Lilt Create content by ID.
    api_response = api_instance.get_lilt_create_by_id(content_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CreateApi->get_lilt_create_by_id: %s\n" % e) ```

Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client) content_id = 56 # int | The content ID.

try:
    # Get Lilt Create content by ID.
    api_response = api_instance.get_lilt_create_by_id(content_id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CreateApi->get_lilt_create_by_id: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
content_id	int	The content ID.

Return type

LiltCreateContent

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json, application/octet-stream, text/plain

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 200 | The Lilt Create content. | - | 401 | Unauthorized | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

get_lilt_create_content

GetLiltCreateContentResponse get_lilt_create_content()

Get Lilt Create content

Get a list of all content that has been generated by Lilt Create. Example CURL: bash curl -X GET 'https://api.lilt.com/v2/create?key=API_KEY'

Example

Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client)

try:
    # Get Lilt Create content
    api_response = api_instance.get_lilt_create_content()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CreateApi->get_lilt_create_content: %s\n" % e) ```

Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client)

try:
    # Get Lilt Create content
    api_response = api_instance.get_lilt_create_content()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CreateApi->get_lilt_create_content: %s\n" % e) ```

Parameters

This endpoint does not need any parameter.

Return type

GetLiltCreateContentResponse

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json, application/octet-stream, text/plain

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 200 | An object with a documents next task Workflow metadata. | - | 401 | Unauthorized | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

get_lilt_create_preferences

get_lilt_create_preferences()

Get Lilt Create preferences

Get the stored preferences for Lilt Create. Example CURL: bash curl -X POST 'https://api.lilt.com/v2/create/preferences?key=API_KEY'

Example

Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client)

try:
    # Get Lilt Create preferences
    api_instance.get_lilt_create_preferences()
except ApiException as e:
    print("Exception when calling CreateApi->get_lilt_create_preferences: %s\n" % e) ```

Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client)

try:
    # Get Lilt Create preferences
    api_instance.get_lilt_create_preferences()
except ApiException as e:
    print("Exception when calling CreateApi->get_lilt_create_preferences: %s\n" % e) ```

Parameters

This endpoint does not need any parameter.

Return type

void (empty response body)

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: Not defined
Accept: application/octet-stream, text/plain, application/json

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 200 | An object describing the stored preferences. | - | 401 | Unauthorized | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

regenerate_lilt_create_content

regenerate_lilt_create_content(content_id)

Regenerate Lilt Create content

Regenerate the given piece of content with the current parameters. Example CURL: bash curl -X GET 'https://api.lilt.com/v2/create/1234/create?key=API_KEY'

Example

Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client) content_id = 56 # int | The content ID.

try:
    # Regenerate Lilt Create content
    api_instance.regenerate_lilt_create_content(content_id)
except ApiException as e:
    print("Exception when calling CreateApi->regenerate_lilt_create_content: %s\n" % e) ```

Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client) content_id = 56 # int | The content ID.

try:
    # Regenerate Lilt Create content
    api_instance.regenerate_lilt_create_content(content_id)
except ApiException as e:
    print("Exception when calling CreateApi->regenerate_lilt_create_content: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
content_id	int	The content ID.

Return type

void (empty response body)

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: Not defined
Accept: application/octet-stream, text/plain, application/json

HTTP response details

[Back to top] [Back to API list] [Back to Model list] [Back to README]

sign_lilt_create_terms

SignLiltCreateTermsResponse sign_lilt_create_terms(signed_agreement)

Sign the Lilt Create terms and conditions

Lilt Create requires that the terms and conditions are signed first before using it. The terms and conditions can be signed by using this endpoint. Example CURL: bash curl -X POST 'https://api.lilt.com/v2/create/terms-and-conditions?key=API_KEY' \\ --header 'Content-Type: application/json' \\ --data-raw '{\"signedAgreement\": true}'

Example

Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client) signed_agreement = lilt.CreateConverterConfigParameters() # CreateConverterConfigParameters |

try:
    # Sign the Lilt Create terms and conditions
    api_response = api_instance.sign_lilt_create_terms(signed_agreement)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CreateApi->sign_lilt_create_terms: %s\n" % e) ```

Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

try:
    # Sign the Lilt Create terms and conditions
    api_response = api_instance.sign_lilt_create_terms(signed_agreement)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CreateApi->sign_lilt_create_terms: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
signed_agreement	CreateConverterConfigParameters

Return type

SignLiltCreateTermsResponse

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: application/json
Accept: application/json, application/octet-stream, text/plain

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 200 | An object indicating whether the agreement has been signed or not. | - | 401 | Unauthorized | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

update_lilt_create_content

LiltCreateContent update_lilt_create_content(content_id, body=body)

Update Lilt Create content

Update a piece of Lilt Create content. Example CURL: bash curl -X PUT 'https://api.lilt.com/v2/create/1234?key=API_KEY' \\ --header 'Content-Type: application/json' \\ --data-raw '{\"language\":\"de-DE\"}'

Example

Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client) content_id = 56 # int | The content ID. body = lilt.LiltCreateContent() # LiltCreateContent | (optional)

try:
    # Update Lilt Create content
    api_response = api_instance.update_lilt_create_content(content_id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CreateApi->update_lilt_create_content: %s\n" % e) ```

Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

try:
    # Update Lilt Create content
    api_response = api_instance.update_lilt_create_content(content_id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CreateApi->update_lilt_create_content: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
content_id	int	The content ID.
body	LiltCreateContent		[optional]

Return type

LiltCreateContent

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: application/json
Accept: application/json, application/octet-stream, text/plain

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 200 | The updated Lilt Create content. | - | 401 | Unauthorized | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

update_lilt_create_preferences

update_lilt_create_preferences(styleguide=styleguide)

Update Lilt Create preferences

Update the stored preferences for Lilt Create. Example CURL: bash curl -X PUT 'https://api.lilt.com/v2/create/preferences?key=API_KEY' \\ --header 'Content-Type: application/json' \\ --data-raw '{\"tone\": \"formal\", \"styleguide\": \"\"}'

Example

Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.CreateApi(api_client) styleguide = lilt.LiltCreateContent() # LiltCreateContent | Which styleguide to use. (optional)

try:
    # Update Lilt Create preferences
    api_instance.update_lilt_create_preferences(styleguide=styleguide)
except ApiException as e:
    print("Exception when calling CreateApi->update_lilt_create_preferences: %s\n" % e) ```

Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint
Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

configuration = lilt.Configuration( host = “https://api.lilt.com” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://api.lilt.com”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

try:
    # Update Lilt Create preferences
    api_instance.update_lilt_create_preferences(styleguide=styleguide)
except ApiException as e:
    print("Exception when calling CreateApi->update_lilt_create_preferences: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
styleguide	LiltCreateContent	Which styleguide to use.	[optional]

Return type

void (empty response body)

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: application/json
Accept: application/octet-stream, text/plain, application/json

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 200 | The updated Lilt Create preferences. | - | 401 | Unauthorized | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

lilt.CreateApi

delete_lilt_create_content

Example

Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

Enter a context with an instance of the API client

Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

Enter a context with an instance of the API client

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

generate_lilt_create_content

Example

Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

Enter a context with an instance of the API client

Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

Enter a context with an instance of the API client

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

get_lilt_create_by_id

Example

Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

Enter a context with an instance of the API client

Defining the host is optional and defaults to https://api.lilt.com

See configuration.py for a list of all supported configuration parameters.

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed