MENU navbar-image

Introduction

This documentation aims to provide all the information you need to work with our API.

Authenticating requests

To authenticate requests, include an Authorization header with the value "Bearer {YOUR_AUTH_KEY}".

All authenticated endpoints are marked with a requires authentication badge in the documentation below.

Admin Dashboard

All other endpoints

Retrieve various metrics for the admin dashboard (Stability Score: 0.1)

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/dashboard" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/dashboard"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/dashboard

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Crudy Endpoints

All Crudy endpoints

Salary warning

Fetch a Salary warning by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/salary-warnings/hic?include=employee%2CsalaryRule" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/salary-warnings/hic"
);

const params = {
    "include": "employee,salaryRule",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "SalaryWarning [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/salary-warnings/{salaryWarningId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

salaryWarningId   string   

Example: hic

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: employee,salaryRule

Fetch a list of Salary warnings with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/salary-warnings?page=1&pageSize=15&withSoftDeletes=1&include=employee%2CsalaryRule" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/salary-warnings"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "employee,salaryRule",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/salary-warnings

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: employee,salaryRule

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/salary-warnings/search?page=1&pageSize=15&withSoftDeletes=1&include=employee%2CsalaryRule" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"confirmedBy\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"salaryRuleId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"employeeId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"salaryPeriod\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/salary-warnings/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "employee,salaryRule",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "confirmedBy",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "salaryRuleId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "employeeId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "salaryPeriod",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Company integration

Create a new Company integration

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company-integrations?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"externalIntegrationId\": \"eos\",
    \"companyId\": \"sit\"
}"

const url = new URL(
    "http://localhost/api/v1/company-integrations"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "externalIntegrationId": "eos",
    "companyId": "sit"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/company-integrations

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

externalIntegrationId   string   

Example: eos

companyId   string   

Example: sit

settings   object  optional  

Batch create new Company integrations

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company-integrations/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"externalIntegrationId\": \"id\",
            \"companyId\": \"laborum\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-integrations/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "externalIntegrationId": "id",
            "companyId": "laborum"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/company-integrations/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
externalIntegrationId   string   

Example: id

companyId   string   

Example: laborum

settings   object  optional  

Fetch a Company integration by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/company-integrations/iusto?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/company-integrations/iusto"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "CompanyIntegration [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/company-integrations/{companyIntegrationId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyIntegrationId   string   

Example: iusto

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Batch update Company integrations

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/company-integrations/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "http://localhost/api/v1/company-integrations/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Request      

PATCH api/v1/company-integrations/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
externalIntegrationId   string  optional  
companyId   string  optional  
settings   object  optional  

Update a Company integration by its ID (Stability Score: 0.5)

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/company-integrations/voluptates?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "http://localhost/api/v1/company-integrations/voluptates"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "CompanyIntegration [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/company-integrations/{companyIntegrationId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyIntegrationId   string   

Example: voluptates

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

externalIntegrationId   string  optional  
companyId   string  optional  
settings   object  optional  

Batch delete Company integrations by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/company-integrations/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"sunt\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-integrations/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "sunt"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/company-integrations/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   string[]  optional  

Delete a Company integration by its ID (Stability Score: 0.5)

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/company-integrations/voluptatibus?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/company-integrations/voluptatibus"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "CompanyIntegration [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/company-integrations/{companyIntegrationId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyIntegrationId   string   

Example: voluptatibus

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Fetch a list of Company integrations with pagination (Stability Score: 0.5)

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/company-integrations?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/company-integrations"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/company-integrations

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company-integrations/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"externalIntegrationId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"companyId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-integrations/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "externalIntegrationId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "companyId",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Integration type

Fetch a list of Integration types with pagination (Stability Score: 0.5)

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/integration-types?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/integration-types"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/integration-types

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/integration-types/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"name\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/integration-types/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "name",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

User

Fetch a list of Users with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/users?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/users"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/users

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/users/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/users/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Notification

Fetch a list of Notifications with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/notifications?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/notifications"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/notifications

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/notifications/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"readAt\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/notifications/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "readAt",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Employee field

Create a new Employee field

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employee-fields?include=combinedFields" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": true,
    \"isMandatory\": false,
    \"salarySensitive\": true,
    \"sensitive\": false,
    \"allowNewValue\": true,
    \"observe\": true,
    \"importExcluded\": true,
    \"manualInput\": false,
    \"fieldType\": \"number\",
    \"dataType\": \"date\",
    \"maxInput\": 96,
    \"minInput\": 5.262827656,
    \"maxLength\": 4857812.8,
    \"minLength\": 439003.0755778,
    \"fieldName\": \"fczchmxmqlrpvf\",
    \"combinedFieldIds\": [
        \"animi\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/employee-fields"
);

const params = {
    "include": "combinedFields",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": true,
    "isMandatory": false,
    "salarySensitive": true,
    "sensitive": false,
    "allowNewValue": true,
    "observe": true,
    "importExcluded": true,
    "manualInput": false,
    "fieldType": "number",
    "dataType": "date",
    "maxInput": 96,
    "minInput": 5.262827656,
    "maxLength": 4857812.8,
    "minLength": 439003.0755778,
    "fieldName": "fczchmxmqlrpvf",
    "combinedFieldIds": [
        "animi"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/employee-fields

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: combinedFields

Body Parameters

isGlobal   string  optional  
parentId   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean   

Example: true

isMandatory   boolean  optional  

Example: false

salarySensitive   boolean  optional  

Example: true

sensitive   boolean  optional  

Example: false

allowNewValue   boolean  optional  

Example: true

observe   boolean  optional  

Example: true

importExcluded   boolean  optional  

Example: true

manualInput   boolean  optional  

Example: false

fieldType   string  optional  

Example: number

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: date

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

This field is required when dataType is string. Example: 96

minInput   number  optional  

This field is required when dataType is string. Example: 5.262827656

maxLength   number  optional  

Example: 4857812.8

minLength   number  optional  

Example: 439003.0755778

fieldName   string   

Must not be greater than 255 characters. Example: fczchmxmqlrpvf

combinedFieldIds   string[]   

Fetch a Employee field by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/employee-fields/est?include=combinedFields" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/employee-fields/est"
);

const params = {
    "include": "combinedFields",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "EmployeeField [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/employee-fields/{employeeFieldId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeFieldId   string   

Example: est

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: combinedFields

Update a Employee field by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/employee-fields/iure?include=combinedFields" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": true,
    \"isMandatory\": true,
    \"salarySensitive\": true,
    \"sensitive\": true,
    \"allowNewValue\": false,
    \"observe\": false,
    \"importExcluded\": true,
    \"manualInput\": true,
    \"fieldType\": \"checkbox\",
    \"dataType\": \"string\",
    \"maxInput\": 6239,
    \"minInput\": 87812023,
    \"maxLength\": 4819160.833784439,
    \"minLength\": 308791.909123419,
    \"combinedFieldIds\": [
        \"consequatur\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/employee-fields/iure"
);

const params = {
    "include": "combinedFields",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": true,
    "isMandatory": true,
    "salarySensitive": true,
    "sensitive": true,
    "allowNewValue": false,
    "observe": false,
    "importExcluded": true,
    "manualInput": true,
    "fieldType": "checkbox",
    "dataType": "string",
    "maxInput": 6239,
    "minInput": 87812023,
    "maxLength": 4819160.833784439,
    "minLength": 308791.909123419,
    "combinedFieldIds": [
        "consequatur"
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "EmployeeField [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/employee-fields/{employeeFieldId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeFieldId   string   

Example: iure

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: combinedFields

Body Parameters

isGlobal   string  optional  
parentId   string  optional  
companyId   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: true

isMandatory   boolean  optional  

Example: true

salarySensitive   boolean  optional  

Example: true

sensitive   boolean  optional  

Example: true

allowNewValue   boolean  optional  

Example: false

observe   boolean  optional  

Example: false

importExcluded   boolean  optional  

Example: true

manualInput   boolean  optional  

Example: true

fieldName   string  optional  
fieldType   string  optional  

Example: checkbox

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: string

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 6239

minInput   number  optional  

Example: 87812023

maxLength   number  optional  

Example: 4819160.8337844

minLength   number  optional  

Example: 308791.90912342

combinedFieldIds   string[]   

Delete a Employee field by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/employee-fields/voluptas?include=combinedFields" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/employee-fields/voluptas"
);

const params = {
    "include": "combinedFields",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "EmployeeField [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/employee-fields/{employeeFieldId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeFieldId   string   

Example: voluptas

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: combinedFields

Fetch a list of Employee fields with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/employee-fields?page=1&pageSize=15&withSoftDeletes=1&include=combinedFields" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/employee-fields"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "combinedFields",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/employee-fields

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: combinedFields

Log entity

Fetch a list of Log entities with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/log-entities?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/log-entities"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/log-entities

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/log-entities/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"entity\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"entityId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"action\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"createdBy\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"createdAt\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/log-entities/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "entity",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "entityId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "action",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "createdBy",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "createdAt",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Variable type

Create a new Variable type

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/variable-types?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"description\": \"Eius maiores quod et dolor qui occaecati.\"
}"

const url = new URL(
    "http://localhost/api/v1/variable-types"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "description": "Eius maiores quod et dolor qui occaecati."
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/variable-types

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

translations   object  optional  

The data must be a valid translation object.

description   string   

Example: Eius maiores quod et dolor qui occaecati.

Batch create new Variable types

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/variable-types/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"description\": \"Voluptas et sed consectetur itaque placeat sed id.\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/variable-types/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "description": "Voluptas et sed consectetur itaque placeat sed id."
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/variable-types/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
translations   object  optional  

The data must be a valid translation object.

description   string   

Example: Voluptas et sed consectetur itaque placeat sed id.

Fetch a Variable type by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/variable-types/quo?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/variable-types/quo"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "VariableType [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/variable-types/{variableTypeId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

variableTypeId   string   

Example: quo

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Batch update Variable types

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/variable-types/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"description\": \"Molestiae voluptas accusamus inventore id.\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/variable-types/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "description": "Molestiae voluptas accusamus inventore id."
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/variable-types/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
translations   object  optional  

The data must be a valid translation object.

description   string  optional  

Example: Molestiae voluptas accusamus inventore id.

Update a Variable type by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/variable-types/perspiciatis?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"description\": \"Non repellendus quas autem dolore omnis.\"
}"

const url = new URL(
    "http://localhost/api/v1/variable-types/perspiciatis"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "description": "Non repellendus quas autem dolore omnis."
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "VariableType [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/variable-types/{variableTypeId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

variableTypeId   string   

Example: perspiciatis

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

translations   object  optional  

The data must be a valid translation object.

description   string  optional  

Example: Non repellendus quas autem dolore omnis.

Batch delete Variable types by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/variable-types/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"et\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/variable-types/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "et"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/variable-types/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   string[]  optional  

Delete a Variable type by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/variable-types/quis?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/variable-types/quis"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "VariableType [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/variable-types/{variableTypeId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

variableTypeId   string   

Example: quis

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Fetch a list of Variable types with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/variable-types?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/variable-types"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/variable-types

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/variable-types/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"description\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/variable-types/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "description",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Salary rule

Create a new Salary rule

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/salary-rules?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"companyId\": \"fuga\",
    \"warning\": \"quae\",
    \"solutionDescription\": \"molestiae\",
    \"ruleExpression\": [
        {
            \"type\": \"logical_operator\",
            \"payCodeIds\": [
                13
            ],
            \"previous_periods\": 1,
            \"diff_type\": \"real\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/salary-rules"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "companyId": "fuga",
    "warning": "quae",
    "solutionDescription": "molestiae",
    "ruleExpression": [
        {
            "type": "logical_operator",
            "payCodeIds": [
                13
            ],
            "previous_periods": 1,
            "diff_type": "real"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/salary-rules

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

companyId   string  optional  

Example: fuga

selections   object  optional  
warning   string   

Example: quae

solutionDescription   string   

Example: molestiae

ruleExpression   object[]   

Must have at least 1 items.
type   string   

Example: logical_operator

Must be one of:
  • comparison_operator
  • logical_operator
  • logical
  • logical_missing
  • logical_diff
payCodeIds   integer[]  optional  
previous_periods   integer  optional  

This field is required when ruleExpression.*.type is logical_diff. Must be between 1 and 12. Example: 1

diff_type   string  optional  

This field is required when ruleExpression.*.type is logical_diff. Example: real

Must be one of:
  • real
  • percentage
conditions   object  optional  

This field is required when ruleExpression.*.type is logical or logical_diff. Must have at least 1 items.

Fetch a Salary rule by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/salary-rules/veniam?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/salary-rules/veniam"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "SalaryRule [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/salary-rules/{salaryRuleId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

salaryRuleId   string   

Example: veniam

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Update a Salary rule by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/salary-rules/omnis?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"warning\": \"quia\",
    \"solutionDescription\": \"necessitatibus\",
    \"ruleExpression\": [
        {
            \"type\": \"logical_operator\",
            \"payCodeIds\": [
                \"earum\"
            ],
            \"previous_periods\": 1,
            \"diff_type\": \"real\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/salary-rules/omnis"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "warning": "quia",
    "solutionDescription": "necessitatibus",
    "ruleExpression": [
        {
            "type": "logical_operator",
            "payCodeIds": [
                "earum"
            ],
            "previous_periods": 1,
            "diff_type": "real"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "SalaryRule [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/salary-rules/{salaryRuleId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

salaryRuleId   string   

Example: omnis

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

companyId   string  optional  
warning   string  optional  

Example: quia

selections   object  optional  
solutionDescription   string  optional  

Example: necessitatibus

ruleExpression   object[]   

Must have at least 1 items.
type   string   

Example: logical_operator

Must be one of:
  • comparison_operator
  • logical_operator
  • logical
  • logical_missing
  • logical_diff
payCodeIds   string[]  optional  
previous_periods   integer  optional  

This field is required when ruleExpression.*.type is logical_diff. Must be between 1 and 12. Example: 1

diff_type   string  optional  

This field is required when ruleExpression.*.type is logical_diff. Example: real

Must be one of:
  • real
  • percentage
conditions   object  optional  

This field is required when ruleExpression.*.type is logical or logical_diff. Must have at least 1 items.

Delete a Salary rule by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/salary-rules/architecto?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/salary-rules/architecto"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "SalaryRule [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/salary-rules/{salaryRuleId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

salaryRuleId   string   

Example: architecto

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Fetch a list of Salary rules with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/salary-rules?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/salary-rules"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/salary-rules

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/salary-rules/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/salary-rules/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Org integrations mapping

Create a new Org integrations mapping

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/org-integrations-mappings?include=externalIntegration%2Corganization" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"externalIntegrationId\": \"labore\",
    \"organizationId\": \"unde\",
    \"notes\": \"deserunt\",
    \"status\": \"inactive\"
}"

const url = new URL(
    "http://localhost/api/v1/org-integrations-mappings"
);

const params = {
    "include": "externalIntegration,organization",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "externalIntegrationId": "labore",
    "organizationId": "unde",
    "notes": "deserunt",
    "status": "inactive"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/org-integrations-mappings

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: externalIntegration,organization

Body Parameters

externalIntegrationId   string   

Example: labore

organizationId   string   

Example: unde

notes   string   

Example: deserunt

status   string   

Example: inactive

Must be one of:
  • active
  • inactive

Batch create new Org integrations mappings

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/org-integrations-mappings/batch?include=externalIntegration%2Corganization" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"externalIntegrationId\": \"quasi\",
            \"organizationId\": \"aut\",
            \"notes\": \"quia\",
            \"status\": \"active\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/org-integrations-mappings/batch"
);

const params = {
    "include": "externalIntegration,organization",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "externalIntegrationId": "quasi",
            "organizationId": "aut",
            "notes": "quia",
            "status": "active"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/org-integrations-mappings/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: externalIntegration,organization

Body Parameters

resources   object[]  optional  
externalIntegrationId   string   

Example: quasi

organizationId   string   

Example: aut

notes   string   

Example: quia

status   string   

Example: active

Must be one of:
  • active
  • inactive

Fetch a Org integrations mapping by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/org-integrations-mappings/ea?include=externalIntegration%2Corganization" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/org-integrations-mappings/ea"
);

const params = {
    "include": "externalIntegration,organization",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/org-integrations-mappings/{orgIntegrationsMappingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

orgIntegrationsMappingId   string   

Example: ea

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: externalIntegration,organization

Batch update Org integrations mappings

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/org-integrations-mappings/batch?include=externalIntegration%2Corganization" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"notes\": \"sit\",
            \"status\": \"inactive\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/org-integrations-mappings/batch"
);

const params = {
    "include": "externalIntegration,organization",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "notes": "sit",
            "status": "inactive"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/org-integrations-mappings/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: externalIntegration,organization

Body Parameters

resources   object[]  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
notes   string  optional  

Example: sit

status   string  optional  

Example: inactive

Must be one of:
  • active
  • inactive

Update a Org integrations mapping by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/org-integrations-mappings/rerum?include=externalIntegration%2Corganization" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"notes\": \"magnam\",
    \"status\": \"inactive\"
}"

const url = new URL(
    "http://localhost/api/v1/org-integrations-mappings/rerum"
);

const params = {
    "include": "externalIntegration,organization",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "notes": "magnam",
    "status": "inactive"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/org-integrations-mappings/{orgIntegrationsMappingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

orgIntegrationsMappingId   string   

Example: rerum

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: externalIntegration,organization

Body Parameters

externalIntegrationId   string  optional  
organizationId   string  optional  
notes   string  optional  

Example: magnam

status   string  optional  

Example: inactive

Must be one of:
  • active
  • inactive

Batch delete Org integrations mappings by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/org-integrations-mappings/batch?include=externalIntegration%2Corganization" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"eum\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/org-integrations-mappings/batch"
);

const params = {
    "include": "externalIntegration,organization",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "eum"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/org-integrations-mappings/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: externalIntegration,organization

Body Parameters

resources   string[]  optional  

Delete a Org integrations mapping by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/org-integrations-mappings/culpa?include=externalIntegration%2Corganization" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/org-integrations-mappings/culpa"
);

const params = {
    "include": "externalIntegration,organization",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Request      

DELETE api/v1/org-integrations-mappings/{orgIntegrationsMappingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

orgIntegrationsMappingId   string   

Example: culpa

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: externalIntegration,organization

Fetch a list of Org integrations mappings with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/org-integrations-mappings?page=1&pageSize=15&withSoftDeletes=1&include=externalIntegration%2Corganization" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/org-integrations-mappings"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "externalIntegration,organization",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/org-integrations-mappings

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: externalIntegration,organization

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/org-integrations-mappings/search?page=1&pageSize=15&withSoftDeletes=1&include=externalIntegration%2Corganization" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"externalIntegrationId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"organizationId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"status\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/org-integrations-mappings/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "externalIntegration,organization",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "externalIntegrationId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "organizationId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "status",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Field value matrix

Create a new Field value matrix

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/field-value-matrices?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"cupiditate\",
    \"description\": \"Ut sed eius dolores rerum reprehenderit doloribus mollitia.\",
    \"keyFieldValue\": \"est\",
    \"keyFieldId\": \"est\",
    \"matrixFields\": [
        {
            \"fieldId\": \"ab\",
            \"fieldValue\": \"aut\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/field-value-matrices"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "cupiditate",
    "description": "Ut sed eius dolores rerum reprehenderit doloribus mollitia.",
    "keyFieldValue": "est",
    "keyFieldId": "est",
    "matrixFields": [
        {
            "fieldId": "ab",
            "fieldValue": "aut"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/field-value-matrices

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

name   string   

Example: cupiditate

description   string   

Example: Ut sed eius dolores rerum reprehenderit doloribus mollitia.

keyFieldValue   string   

Example: est

keyFieldId   string   

Example: est

matrixFields   object[]  optional  
fieldId   string   

Example: ab

fieldValue   string   

Example: aut

Batch create new Field value matrices

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/field-value-matrices/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"name\": \"quae\",
            \"description\": \"Quo repellat eveniet pariatur quod perferendis et.\",
            \"keyFieldValue\": \"ut\",
            \"keyFieldId\": \"labore\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/field-value-matrices/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "name": "quae",
            "description": "Quo repellat eveniet pariatur quod perferendis et.",
            "keyFieldValue": "ut",
            "keyFieldId": "labore"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/field-value-matrices/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
name   string   

Example: quae

description   string   

Example: Quo repellat eveniet pariatur quod perferendis et.

keyFieldValue   string   

Example: ut

keyFieldId   string   

Example: labore

matrixFields   object  optional  

Fetch a Field value matrix by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/field-value-matrices/praesentium?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/field-value-matrices/praesentium"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "FieldValueMatrix [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/field-value-matrices/{fieldValueMatrixId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

fieldValueMatrixId   string   

Example: praesentium

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Batch update Field value matrices

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/field-value-matrices/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"name\": \"ipsa\",
            \"description\": \"Quo qui est quidem aspernatur non repudiandae.\",
            \"keyFieldValue\": \"at\",
            \"keyFieldId\": \"eligendi\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/field-value-matrices/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "name": "ipsa",
            "description": "Quo qui est quidem aspernatur non repudiandae.",
            "keyFieldValue": "at",
            "keyFieldId": "eligendi"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/field-value-matrices/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
name   string  optional  

Example: ipsa

description   string  optional  

Example: Quo qui est quidem aspernatur non repudiandae.

keyFieldValue   string  optional  

Example: at

keyFieldId   string  optional  

Example: eligendi

matrixFields   object  optional  

Update a Field value matrix by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/field-value-matrices/quae?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"consectetur\",
    \"description\": \"Repellendus at illo eos ut pariatur atque.\",
    \"keyFieldValue\": \"excepturi\",
    \"keyFieldId\": \"omnis\",
    \"matrixFields\": [
        {
            \"fieldId\": \"vero\",
            \"fieldValue\": \"blanditiis\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/field-value-matrices/quae"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "consectetur",
    "description": "Repellendus at illo eos ut pariatur atque.",
    "keyFieldValue": "excepturi",
    "keyFieldId": "omnis",
    "matrixFields": [
        {
            "fieldId": "vero",
            "fieldValue": "blanditiis"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "FieldValueMatrix [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/field-value-matrices/{fieldValueMatrixId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

fieldValueMatrixId   string   

Example: quae

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

name   string  optional  

Example: consectetur

description   string  optional  

Example: Repellendus at illo eos ut pariatur atque.

keyFieldValue   string  optional  

Example: excepturi

keyFieldId   string  optional  

Example: omnis

matrixFields   object[]  optional  
fieldId   string   

Example: vero

fieldValue   string   

Example: blanditiis

Batch delete Field value matrices by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/field-value-matrices/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"totam\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/field-value-matrices/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "totam"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/field-value-matrices/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   string[]  optional  

Delete a Field value matrix by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/field-value-matrices/possimus?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/field-value-matrices/possimus"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "FieldValueMatrix [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/field-value-matrices/{fieldValueMatrixId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

fieldValueMatrixId   string   

Example: possimus

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Fetch a list of Field value matrices with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/field-value-matrices?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/field-value-matrices"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/field-value-matrices

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/field-value-matrices/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"name\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"description\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"keyFieldValue\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"keyFieldId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/field-value-matrices/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "name",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "description",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "keyFieldValue",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "keyFieldId",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Organization

Create a new Organization

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/organizations?include=companies" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"quod\",
    \"orgNumber\": \"sed\"
}"

const url = new URL(
    "http://localhost/api/v1/organizations"
);

const params = {
    "include": "companies",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "quod",
    "orgNumber": "sed"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/organizations

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies

Body Parameters

name   string   

Example: quod

orgNumber   string   

Example: sed

Batch create new Organizations

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/organizations/batch?include=companies" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"name\": \"unde\",
            \"orgNumber\": \"minus\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/organizations/batch"
);

const params = {
    "include": "companies",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "name": "unde",
            "orgNumber": "minus"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/organizations/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies

Body Parameters

resources   object[]  optional  
name   string   

Example: unde

orgNumber   string   

Example: minus

Fetch a Organization by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/organizations/ut?include=companies" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/organizations/ut"
);

const params = {
    "include": "companies",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "Organization [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/organizations/{organizationId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: ut

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies

Batch update Organizations

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/organizations/batch?include=companies" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"name\": \"et\",
            \"orgNumber\": \"ut\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/organizations/batch"
);

const params = {
    "include": "companies",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "name": "et",
            "orgNumber": "ut"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/organizations/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies

Body Parameters

resources   object[]  optional  
name   string  optional  

Example: et

orgNumber   string  optional  

Example: ut

Update a Organization by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/organizations/ipsum?include=companies" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"quis\",
    \"orgNumber\": \"sit\"
}"

const url = new URL(
    "http://localhost/api/v1/organizations/ipsum"
);

const params = {
    "include": "companies",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "quis",
    "orgNumber": "sit"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "Organization [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/organizations/{organizationId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: ipsum

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies

Body Parameters

name   string  optional  

Example: quis

orgNumber   string  optional  

Example: sit

Batch delete Organizations by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/organizations/batch?include=companies" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"vitae\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/organizations/batch"
);

const params = {
    "include": "companies",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "vitae"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/organizations/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies

Body Parameters

resources   string[]  optional  

Delete a Organization by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/organizations/ut?include=companies" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/organizations/ut"
);

const params = {
    "include": "companies",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "Organization [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/organizations/{organizationId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: ut

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies

Fetch a list of Organizations with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/organizations?page=1&pageSize=15&withSoftDeletes=1&include=companies" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/organizations"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "companies",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/organizations

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/organizations/search?page=1&pageSize=15&withSoftDeletes=1&include=companies" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"name\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"orgNumber\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/organizations/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "companies",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "name",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "orgNumber",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Menu

Create a new Menu

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/menus?include=parent" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"jarclvkqmggqqlhtjfq\",
    \"icon\": \"vflz\",
    \"url\": \"http:\\/\\/yundt.com\\/magni-excepturi-voluptas-voluptatem-omnis\",
    \"parentId\": \"maxime\"
}"

const url = new URL(
    "http://localhost/api/v1/menus"
);

const params = {
    "include": "parent",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "jarclvkqmggqqlhtjfq",
    "icon": "vflz",
    "url": "http:\/\/yundt.com\/magni-excepturi-voluptas-voluptatem-omnis",
    "parentId": "maxime"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/menus

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: parent

Body Parameters

name   string   

Must not be greater than 255 characters. Example: jarclvkqmggqqlhtjfq

icon   string   

Must not be greater than 255 characters. Example: vflz

url   string   

Must not be greater than 255 characters. Example: http://yundt.com/magni-excepturi-voluptas-voluptatem-omnis

parentId   string  optional  

Example: maxime

Batch create new Menus

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/menus/batch?include=parent" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"name\": \"lhbnysmjmrmviydachmhjdo\",
            \"icon\": \"gnpvp\",
            \"url\": \"http:\\/\\/www.smitham.com\\/voluptatem-expedita-maxime-et-officiis-non\",
            \"parentId\": \"quasi\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/menus/batch"
);

const params = {
    "include": "parent",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "name": "lhbnysmjmrmviydachmhjdo",
            "icon": "gnpvp",
            "url": "http:\/\/www.smitham.com\/voluptatem-expedita-maxime-et-officiis-non",
            "parentId": "quasi"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/menus/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: parent

Body Parameters

resources   object[]  optional  
name   string   

Must not be greater than 255 characters. Example: lhbnysmjmrmviydachmhjdo

icon   string   

Must not be greater than 255 characters. Example: gnpvp

url   string   

Must not be greater than 255 characters. Example: http://www.smitham.com/voluptatem-expedita-maxime-et-officiis-non

parentId   string  optional  

Example: quasi

Fetch a Menu by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/menus/non?include=parent" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/menus/non"
);

const params = {
    "include": "parent",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "Menu [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/menus/{menuId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

menuId   string   

Example: non

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: parent

Batch update Menus

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/menus/batch?include=parent" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"name\": \"qobtdzfkkgdkmlmfpxxrywrs\",
            \"icon\": \"zkokdkyeraiccuilgewzhfde\",
            \"url\": \"https:\\/\\/rippin.com\\/quod-consequatur-voluptatem-omnis-totam-unde-fugiat.html\",
            \"parentId\": \"beatae\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/menus/batch"
);

const params = {
    "include": "parent",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "name": "qobtdzfkkgdkmlmfpxxrywrs",
            "icon": "zkokdkyeraiccuilgewzhfde",
            "url": "https:\/\/rippin.com\/quod-consequatur-voluptatem-omnis-totam-unde-fugiat.html",
            "parentId": "beatae"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/menus/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: parent

Body Parameters

resources   object[]  optional  
name   string  optional  

Must not be greater than 255 characters. Example: qobtdzfkkgdkmlmfpxxrywrs

icon   string  optional  

Must not be greater than 255 characters. Example: zkokdkyeraiccuilgewzhfde

url   string  optional  

Must not be greater than 255 characters. Example: https://rippin.com/quod-consequatur-voluptatem-omnis-totam-unde-fugiat.html

parentId   string  optional  

Example: beatae

Update a Menu by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/menus/necessitatibus?include=parent" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"tcdcckhilvxhvas\",
    \"icon\": \"ssyav\",
    \"url\": \"http:\\/\\/goyette.biz\\/laboriosam-eum-velit-aut-sint-et-eligendi\",
    \"parentId\": \"quo\"
}"

const url = new URL(
    "http://localhost/api/v1/menus/necessitatibus"
);

const params = {
    "include": "parent",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "tcdcckhilvxhvas",
    "icon": "ssyav",
    "url": "http:\/\/goyette.biz\/laboriosam-eum-velit-aut-sint-et-eligendi",
    "parentId": "quo"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "Menu [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/menus/{menuId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

menuId   string   

Example: necessitatibus

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: parent

Body Parameters

name   string  optional  

Must not be greater than 255 characters. Example: tcdcckhilvxhvas

icon   string  optional  

Must not be greater than 255 characters. Example: ssyav

url   string  optional  

Must not be greater than 255 characters. Example: http://goyette.biz/laboriosam-eum-velit-aut-sint-et-eligendi

parentId   string  optional  

Example: quo

Batch delete Menus by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/menus/batch?include=parent" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"repellat\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/menus/batch"
);

const params = {
    "include": "parent",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "repellat"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/menus/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: parent

Body Parameters

resources   string[]  optional  

Delete a Menu by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/menus/et?include=parent" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/menus/et"
);

const params = {
    "include": "parent",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "Menu [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/menus/{menuId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

menuId   string   

Example: et

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: parent

Fetch a list of Menus with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/menus?page=1&pageSize=15&withSoftDeletes=1&include=parent" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/menus"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "parent",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/menus

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: parent

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/menus/search?page=1&pageSize=15&withSoftDeletes=1&include=parent" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"name\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"icon\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"url\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"parentId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/menus/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "parent",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "name",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "icon",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "url",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "parentId",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Company field map

Create a new Company field map

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company-field-maps?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"externalCompanyFieldId\": \"nemo\",
    \"companyFieldId\": \"amet\",
    \"companyId\": \"incidunt\",
    \"externalIntegrationId\": \"hic\"
}"

const url = new URL(
    "http://localhost/api/v1/company-field-maps"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "externalCompanyFieldId": "nemo",
    "companyFieldId": "amet",
    "companyId": "incidunt",
    "externalIntegrationId": "hic"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/company-field-maps

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

externalCompanyFieldId   string   

Example: nemo

companyFieldId   string   

Example: amet

companyId   string  optional  

Example: incidunt

externalIntegrationId   string   

Example: hic

Batch create new Company field maps

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company-field-maps/batch?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"externalCompanyFieldId\": \"similique\",
            \"companyFieldId\": \"dignissimos\",
            \"companyId\": \"architecto\",
            \"externalIntegrationId\": \"ut\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-field-maps/batch"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "externalCompanyFieldId": "similique",
            "companyFieldId": "dignissimos",
            "companyId": "architecto",
            "externalIntegrationId": "ut"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/company-field-maps/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

resources   object[]  optional  
externalCompanyFieldId   string   

Example: similique

companyFieldId   string   

Example: dignissimos

companyId   string  optional  

Example: architecto

externalIntegrationId   string   

Example: ut

Fetch a Company field map by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/company-field-maps/quia?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/company-field-maps/quia"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "CompanyFieldMap [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/company-field-maps/{companyFieldMapId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyFieldMapId   string   

Example: quia

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Batch update Company field maps

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/company-field-maps/batch?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"externalCompanyFieldId\": \"deserunt\",
            \"companyFieldId\": \"quasi\",
            \"companyId\": \"omnis\",
            \"externalIntegrationId\": \"blanditiis\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-field-maps/batch"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "externalCompanyFieldId": "deserunt",
            "companyFieldId": "quasi",
            "companyId": "omnis",
            "externalIntegrationId": "blanditiis"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/company-field-maps/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

resources   object[]  optional  
externalCompanyFieldId   string   

Example: deserunt

companyFieldId   string   

Example: quasi

companyId   string  optional  

Example: omnis

externalIntegrationId   string  optional  

Example: blanditiis

Update a Company field map by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/company-field-maps/minima?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"externalCompanyFieldId\": \"sint\",
    \"companyFieldId\": \"aut\",
    \"companyId\": \"unde\",
    \"externalIntegrationId\": \"consequatur\"
}"

const url = new URL(
    "http://localhost/api/v1/company-field-maps/minima"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "externalCompanyFieldId": "sint",
    "companyFieldId": "aut",
    "companyId": "unde",
    "externalIntegrationId": "consequatur"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "CompanyFieldMap [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/company-field-maps/{companyFieldMapId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyFieldMapId   string   

Example: minima

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

externalCompanyFieldId   string   

Example: sint

companyFieldId   string   

Example: aut

companyId   string  optional  

Example: unde

externalIntegrationId   string  optional  

Example: consequatur

Batch delete Company field maps by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/company-field-maps/batch?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"quidem\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-field-maps/batch"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "quidem"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/company-field-maps/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

resources   string[]  optional  

Delete a Company field map by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/company-field-maps/tempore?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/company-field-maps/tempore"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "CompanyFieldMap [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/company-field-maps/{companyFieldMapId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyFieldMapId   string   

Example: tempore

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Fetch a list of Company field maps with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/company-field-maps?page=1&pageSize=15&withSoftDeletes=1&include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/company-field-maps"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/company-field-maps

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company-field-maps/search?page=1&pageSize=15&withSoftDeletes=1&include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"companyId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-field-maps/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "companyId",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Pay code variable

Create a new Pay code variable

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-code-variables?include=variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"variableTypeId\": \"quas\"
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-variables"
);

const params = {
    "include": "variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "variableTypeId": "quas"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/pay-code-variables

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: variableType

Body Parameters

translations   object  optional  

The data must be a valid translation object.

variableTypeId   string   

Example: quas

Batch create new Pay code variables

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-code-variables/batch?include=variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"variableTypeId\": \"quaerat\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-variables/batch"
);

const params = {
    "include": "variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "variableTypeId": "quaerat"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/pay-code-variables/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: variableType

Body Parameters

resources   object[]  optional  
translations   object  optional  

The data must be a valid translation object.

variableTypeId   string   

Example: quaerat

Fetch a Pay code variable by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/pay-code-variables/nobis?include=variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-code-variables/nobis"
);

const params = {
    "include": "variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCodeVariable [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/pay-code-variables/{payCodeVariableId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeVariableId   string   

Example: nobis

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: variableType

Batch update Pay code variables

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/pay-code-variables/batch?include=variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "http://localhost/api/v1/pay-code-variables/batch"
);

const params = {
    "include": "variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Request      

PATCH api/v1/pay-code-variables/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: variableType

Body Parameters

resources   object[]  optional  
translations   object  optional  

The data must be a valid translation object.

variableTypeId   string  optional  

Update a Pay code variable by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/pay-code-variables/placeat?include=variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "http://localhost/api/v1/pay-code-variables/placeat"
);

const params = {
    "include": "variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCodeVariable [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/pay-code-variables/{payCodeVariableId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeVariableId   string   

Example: placeat

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: variableType

Body Parameters

translations   object  optional  

The data must be a valid translation object.

variableTypeId   string  optional  

Batch delete Pay code variables by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/pay-code-variables/batch?include=variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"fugit\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-variables/batch"
);

const params = {
    "include": "variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "fugit"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/pay-code-variables/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: variableType

Body Parameters

resources   string[]  optional  

Delete a Pay code variable by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/pay-code-variables/omnis?include=variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-code-variables/omnis"
);

const params = {
    "include": "variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCodeVariable [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/pay-code-variables/{payCodeVariableId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeVariableId   string   

Example: omnis

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: variableType

Fetch a list of Pay code variables with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/pay-code-variables?page=1&pageSize=15&withSoftDeletes=1&include=variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-code-variables"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/pay-code-variables

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: variableType

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-code-variables/search?page=1&pageSize=15&withSoftDeletes=1&include=variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"variableTypeId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-variables/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "variableTypeId",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Pay code type

Create a new Pay code type

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-code-types?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"payCodeTypeNumber\": 2094130.7694592583
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-types"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "payCodeTypeNumber": 2094130.7694592583
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/pay-code-types

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

payCodeTypeNumber   number   

Example: 2094130.7694593

translations   object  optional  

The data must be a valid translation object.

Batch create new Pay code types

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-code-types/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"payCodeTypeNumber\": 432167161.360392
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-types/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "payCodeTypeNumber": 432167161.360392
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/pay-code-types/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
payCodeTypeNumber   number   

Example: 432167161.36039

translations   object  optional  

The data must be a valid translation object.

Fetch a Pay code type by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/pay-code-types/ea?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-code-types/ea"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCodeType [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/pay-code-types/{payCodeTypeId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeTypeId   string   

Example: ea

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Batch update Pay code types

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/pay-code-types/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"payCodeTypeNumber\": 568836.377564563
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-types/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "payCodeTypeNumber": 568836.377564563
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/pay-code-types/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
payCodeTypeNumber   number  optional  

Example: 568836.37756456

translations   object  optional  

The data must be a valid translation object.

Update a Pay code type by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/pay-code-types/pariatur?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"payCodeTypeNumber\": 301.16458
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-types/pariatur"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "payCodeTypeNumber": 301.16458
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCodeType [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/pay-code-types/{payCodeTypeId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeTypeId   string   

Example: pariatur

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

payCodeTypeNumber   number  optional  

Example: 301.16458

translations   object  optional  

The data must be a valid translation object.

Batch delete Pay code types by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/pay-code-types/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"totam\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-types/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "totam"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/pay-code-types/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   string[]  optional  

Delete a Pay code type by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/pay-code-types/soluta?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-code-types/soluta"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCodeType [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/pay-code-types/{payCodeTypeId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeTypeId   string   

Example: soluta

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Fetch a list of Pay code types with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/pay-code-types?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-code-types"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/pay-code-types

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-code-types/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"payCodeTypeNumber\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-types/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "payCodeTypeNumber",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Pay code mapping

Create a new Pay code mapping

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-code-mappings?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"companyId\": \"nisi\",
    \"organizationId\": \"laboriosam\",
    \"isGlobal\": true,
    \"isGroup\": true,
    \"notes\": \"velit\"
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-mappings"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "companyId": "nisi",
    "organizationId": "laboriosam",
    "isGlobal": true,
    "isGroup": true,
    "notes": "velit"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/pay-code-mappings

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

whiteListedPayCodeIds   object  optional  
companyId   string  optional  

This field is required when organizationId is not present. Example: nisi

organizationId   string  optional  

This field is required when companyId is not present. Example: laboriosam

isGlobal   boolean   

Example: true

isGroup   boolean   

Example: true

mappings   string[]  optional  
payCodeId   string   

Example: commodi

companyPayCodeId   string   

Example: sunt

notes   string  optional  

Example: sunt

notes   string  optional  

Example: velit

Batch create new Pay code mappings

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-code-mappings/batch?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"companyId\": \"pariatur\",
            \"organizationId\": \"ea\",
            \"isGlobal\": true,
            \"isGroup\": true,
            \"mappings\": [],
            \"notes\": \"sint\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-mappings/batch"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "companyId": "pariatur",
            "organizationId": "ea",
            "isGlobal": true,
            "isGroup": true,
            "mappings": [],
            "notes": "sint"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/pay-code-mappings/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

resources   object[]  optional  
whiteListedPayCodeIds   object  optional  
companyId   string  optional  

This field is required when resources.*.organizationId is not present. Example: pariatur

organizationId   string  optional  

This field is required when resources.*.companyId is not present. Example: ea

isGlobal   boolean   

Example: true

isGroup   boolean   

Example: true

mappings   object   
notes   string  optional  

Example: sint

Fetch a Pay code mapping by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/pay-code-mappings/autem?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-code-mappings/autem"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCodeMapping [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/pay-code-mappings/{payCodeMappingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeMappingId   string   

Example: autem

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Batch update Pay code mappings

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/pay-code-mappings/batch?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"isGlobal\": false,
            \"isGroup\": false,
            \"notes\": \"et\",
            \"status\": \"active\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-mappings/batch"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "isGlobal": false,
            "isGroup": false,
            "notes": "et",
            "status": "active"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/pay-code-mappings/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

resources   object[]  optional  
whiteListedPayCodeIds   object  optional  
companyId   string  optional  
organizationId   string  optional  
isGlobal   boolean  optional  

Example: false

isGroup   boolean  optional  

Example: false

mappings   object  optional  
notes   string  optional  

Example: et

status   string  optional  

Example: active

Must be one of:
  • active
  • inactive

Update a Pay code mapping by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/pay-code-mappings/culpa?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isGlobal\": false,
    \"isGroup\": false,
    \"notes\": \"laboriosam\",
    \"status\": \"inactive\"
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-mappings/culpa"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isGlobal": false,
    "isGroup": false,
    "notes": "laboriosam",
    "status": "inactive"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCodeMapping [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/pay-code-mappings/{payCodeMappingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeMappingId   string   

Example: culpa

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

whiteListedPayCodeIds   object  optional  
companyId   string  optional  
organizationId   string  optional  
isGlobal   boolean  optional  

Example: false

isGroup   boolean  optional  

Example: false

mappings   string[]  optional  
payCodeId   string   

Example: dolorum

companyPayCodeId   string   

Example: molestias

notes   string  optional  

Example: qui

notes   string  optional  

Example: laboriosam

status   string  optional  

Example: inactive

Must be one of:
  • active
  • inactive

Batch delete Pay code mappings by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/pay-code-mappings/batch?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"voluptatem\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-mappings/batch"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "voluptatem"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/pay-code-mappings/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

resources   string[]  optional  

Delete a Pay code mapping by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/pay-code-mappings/rerum?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-code-mappings/rerum"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCodeMapping [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/pay-code-mappings/{payCodeMappingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeMappingId   string   

Example: rerum

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Fetch a list of Pay code mappings with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/pay-code-mappings?page=1&pageSize=15&withSoftDeletes=1&include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-code-mappings"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/pay-code-mappings

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-code-mappings/search?page=1&pageSize=15&withSoftDeletes=1&include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"companyId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"isGlobal\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"isGroup\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"status\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"whiteListedPayCodeIds\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-mappings/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "companyId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "isGlobal",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "isGroup",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "status",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "whiteListedPayCodeIds",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Company

Create a new Company

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/companies?include=companies%2CfieldMaps%2CcompanyIntegration" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "http://localhost/api/v1/companies"
);

const params = {
    "include": "companies,fieldMaps,companyIntegration",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/companies

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies,fieldMaps,companyIntegration

Body Parameters

fields   string  optional  
companyId   string  optional  
importedAt   string  optional  
parentCompanyId   string  optional  
organizationId   string  optional  

Batch create new Companies

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/companies/batch?include=companies%2CfieldMaps%2CcompanyIntegration" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "http://localhost/api/v1/companies/batch"
);

const params = {
    "include": "companies,fieldMaps,companyIntegration",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/companies/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies,fieldMaps,companyIntegration

Body Parameters

resources   object[]  optional  
fields   string  optional  
companyId   string  optional  
importedAt   string  optional  
parentCompanyId   string  optional  
organizationId   string  optional  

Fetch a Company by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/companies/harum?include=companies%2CfieldMaps%2CcompanyIntegration" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/companies/harum"
);

const params = {
    "include": "companies,fieldMaps,companyIntegration",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "Company [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/companies/{companyId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: harum

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies,fieldMaps,companyIntegration

Batch update Companies

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/companies/batch?include=companies%2CfieldMaps%2CcompanyIntegration" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "http://localhost/api/v1/companies/batch"
);

const params = {
    "include": "companies,fieldMaps,companyIntegration",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Request      

PATCH api/v1/companies/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies,fieldMaps,companyIntegration

Body Parameters

resources   object[]  optional  
fields   string  optional  
companyId   string  optional  
importedAt   string  optional  
parentCompanyId   string  optional  
organizationId   string  optional  

Update a Company by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/companies/praesentium?include=companies%2CfieldMaps%2CcompanyIntegration" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "http://localhost/api/v1/companies/praesentium"
);

const params = {
    "include": "companies,fieldMaps,companyIntegration",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "Company [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/companies/{companyId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: praesentium

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies,fieldMaps,companyIntegration

Body Parameters

fields   string  optional  
companyId   string  optional  
importedAt   string  optional  
parentCompanyId   string  optional  
organizationId   string  optional  

Batch delete Companies by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/companies/batch?include=companies%2CfieldMaps%2CcompanyIntegration" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"accusamus\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/companies/batch"
);

const params = {
    "include": "companies,fieldMaps,companyIntegration",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "accusamus"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/companies/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies,fieldMaps,companyIntegration

Body Parameters

resources   string[]  optional  

Delete a Company by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/companies/eligendi?include=companies%2CfieldMaps%2CcompanyIntegration" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/companies/eligendi"
);

const params = {
    "include": "companies,fieldMaps,companyIntegration",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "Company [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/companies/{companyId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: eligendi

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies,fieldMaps,companyIntegration

Fetch a list of Companies with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/companies?page=1&pageSize=15&withSoftDeletes=1&include=companies%2CfieldMaps%2CcompanyIntegration" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/companies"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "companies,fieldMaps,companyIntegration",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/companies

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: companies,fieldMaps,companyIntegration

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/companies/search?page=1&pageSize=15&withSoftDeletes=1&include=companies%2CfieldMaps%2CcompanyIntegration" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"companyId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"companyName\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"organisationNumber\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"externalId\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"companyId\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"companyName\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"organisationNumber\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/companies/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "companies,fieldMaps,companyIntegration",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "companyId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "companyName",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "organisationNumber",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "externalId",
            "direction": "asc"
        },
        {
            "field": "companyId",
            "direction": "asc"
        },
        {
            "field": "companyName",
            "direction": "asc"
        },
        {
            "field": "organisationNumber",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Company integrations mapping

Create a new Company integrations mapping

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company-integrations-mappings?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"externalIntegrationId\": \"qui\",
    \"companyId\": \"nesciunt\",
    \"notes\": \"molestiae\",
    \"status\": \"inactive\"
}"

const url = new URL(
    "http://localhost/api/v1/company-integrations-mappings"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "externalIntegrationId": "qui",
    "companyId": "nesciunt",
    "notes": "molestiae",
    "status": "inactive"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/company-integrations-mappings

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

externalIntegrationId   string   

Example: qui

companyId   string   

Example: nesciunt

notes   string   

Example: molestiae

status   string   

Example: inactive

Must be one of:
  • active
  • inactive

Batch create new Company integrations mappings

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company-integrations-mappings/batch?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"externalIntegrationId\": \"exercitationem\",
            \"companyId\": \"quo\",
            \"notes\": \"magnam\",
            \"status\": \"active\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-integrations-mappings/batch"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "externalIntegrationId": "exercitationem",
            "companyId": "quo",
            "notes": "magnam",
            "status": "active"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/company-integrations-mappings/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

resources   object[]  optional  
externalIntegrationId   string   

Example: exercitationem

companyId   string   

Example: quo

notes   string   

Example: magnam

status   string   

Example: active

Must be one of:
  • active
  • inactive

Fetch a Company integrations mapping by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/company-integrations-mappings/voluptates?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/company-integrations-mappings/voluptates"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/company-integrations-mappings/{companyIntegrationsMappingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyIntegrationsMappingId   string   

Example: voluptates

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Batch update Company integrations mappings

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/company-integrations-mappings/batch?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"notes\": \"placeat\",
            \"status\": \"inactive\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-integrations-mappings/batch"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "notes": "placeat",
            "status": "inactive"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/company-integrations-mappings/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

resources   object[]  optional  
externalIntegrationId   string  optional  
companyId   string  optional  
notes   string  optional  

Example: placeat

status   string  optional  

Example: inactive

Must be one of:
  • active
  • inactive

Update a Company integrations mapping by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/company-integrations-mappings/rerum?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"notes\": \"vitae\",
    \"status\": \"inactive\"
}"

const url = new URL(
    "http://localhost/api/v1/company-integrations-mappings/rerum"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "notes": "vitae",
    "status": "inactive"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/company-integrations-mappings/{companyIntegrationsMappingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyIntegrationsMappingId   string   

Example: rerum

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

externalIntegrationId   string  optional  
companyId   string  optional  
notes   string  optional  

Example: vitae

status   string  optional  

Example: inactive

Must be one of:
  • active
  • inactive

Batch delete Company integrations mappings by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/company-integrations-mappings/batch?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"et\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-integrations-mappings/batch"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "et"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/company-integrations-mappings/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

resources   string[]  optional  

Delete a Company integrations mapping by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/company-integrations-mappings/totam?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/company-integrations-mappings/totam"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Request      

DELETE api/v1/company-integrations-mappings/{companyIntegrationsMappingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyIntegrationsMappingId   string   

Example: totam

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Fetch a list of Company integrations mappings with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/company-integrations-mappings?page=1&pageSize=15&withSoftDeletes=1&include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/company-integrations-mappings"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/company-integrations-mappings

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company-integrations-mappings/search?page=1&pageSize=15&withSoftDeletes=1&include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-integrations-mappings/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Company settings

Create a new Company settings

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company-settings?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"defaultLocale\": \"es_PE\",
    \"defaultProfile\": \"tempora\",
    \"activeProfile\": \"voluptatem\",
    \"companyId\": \"molestiae\",
    \"organizationId\": \"non\",
    \"organisationNumber\": \"nisi\"
}"

const url = new URL(
    "http://localhost/api/v1/company-settings"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "defaultLocale": "es_PE",
    "defaultProfile": "tempora",
    "activeProfile": "voluptatem",
    "companyId": "molestiae",
    "organizationId": "non",
    "organisationNumber": "nisi"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/company-settings

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

defaultLocale   string  optional  

Example: es_PE

defaultProfile   string  optional  

Example: tempora

activeProfile   string  optional  

Example: voluptatem

companyId   string  optional  

This field is required when organizationId is not present. Example: molestiae

organizationId   string  optional  

This field is required when companyId is not present. Example: non

organisationNumber   string  optional  

Example: nisi

Batch create new Company settings

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company-settings/batch?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"defaultLocale\": \"dz_BT\",
            \"defaultProfile\": \"maiores\",
            \"activeProfile\": \"officia\",
            \"companyId\": \"numquam\",
            \"organizationId\": \"ipsum\",
            \"organisationNumber\": \"modi\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-settings/batch"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "defaultLocale": "dz_BT",
            "defaultProfile": "maiores",
            "activeProfile": "officia",
            "companyId": "numquam",
            "organizationId": "ipsum",
            "organisationNumber": "modi"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/company-settings/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

resources   object[]  optional  
defaultLocale   string  optional  

Example: dz_BT

defaultProfile   string  optional  

Example: maiores

activeProfile   string  optional  

Example: officia

companyId   string  optional  

This field is required when resources.*.organizationId is not present. Example: numquam

organizationId   string  optional  

This field is required when resources.*.companyId is not present. Example: ipsum

organisationNumber   string  optional  

Example: modi

Fetch a Company settings by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/company-settings/illo?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/company-settings/illo"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "CompanySettings [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/company-settings/{companySettingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companySettingId   string   

Example: illo

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Batch update Company settings

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/company-settings/batch?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"defaultLocale\": \"uk_UA\",
            \"defaultProfile\": \"aliquid\",
            \"activeProfile\": \"qui\",
            \"organisationNumber\": \"et\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-settings/batch"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "defaultLocale": "uk_UA",
            "defaultProfile": "aliquid",
            "activeProfile": "qui",
            "organisationNumber": "et"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/company-settings/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

resources   object[]  optional  
defaultLocale   string  optional  

Example: uk_UA

defaultProfile   string  optional  

Example: aliquid

activeProfile   string  optional  

Example: qui

companyId   string  optional  
organizationId   string  optional  
organisationNumber   string  optional  

Example: et

Update a Company settings by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/company-settings/eius?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"defaultLocale\": \"to_TO\",
    \"defaultProfile\": \"quae\",
    \"activeProfile\": \"et\",
    \"organisationNumber\": \"sit\"
}"

const url = new URL(
    "http://localhost/api/v1/company-settings/eius"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "defaultLocale": "to_TO",
    "defaultProfile": "quae",
    "activeProfile": "et",
    "organisationNumber": "sit"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "CompanySettings [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/company-settings/{companySettingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companySettingId   string   

Example: eius

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

defaultLocale   string  optional  

Example: to_TO

defaultProfile   string  optional  

Example: quae

activeProfile   string  optional  

Example: et

companyId   string  optional  
organizationId   string  optional  
organisationNumber   string  optional  

Example: sit

Batch delete Company settings by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/company-settings/batch?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"dignissimos\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-settings/batch"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "dignissimos"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/company-settings/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

resources   string[]  optional  

Delete a Company settings by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/company-settings/recusandae?include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"companyId\": \"deserunt\"
}"

const url = new URL(
    "http://localhost/api/v1/company-settings/recusandae"
);

const params = {
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "companyId": "deserunt"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "CompanySettings [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/company-settings/{companySettingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companySettingId   string   

Example: recusandae

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

Body Parameters

companyId   string   

Example: deserunt

Fetch a list of Company settings with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/company-settings?page=1&pageSize=15&withSoftDeletes=1&include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/company-settings"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/company-settings

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company-settings/search?page=1&pageSize=15&withSoftDeletes=1&include=company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"companyId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"organisationId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company-settings/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "company",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "companyId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "organisationId",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Pay code group

Create a new Pay code group

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-code-groups?include=payCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"payCodeGroupNumber\": 172568.8,
    \"payCodeVariableIds\": [
        \"quo\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-groups"
);

const params = {
    "include": "payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "payCodeGroupNumber": 172568.8,
    "payCodeVariableIds": [
        "quo"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/pay-code-groups

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeVariables,payCodeVariables.variableType

Body Parameters

translations   object  optional  

The data must be a valid translation object.

payCodeGroupNumber   number   

Example: 172568.8

payCodeGroupId   string  optional  
payCodeVariableIds   string[]   

Batch create new Pay code groups

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-code-groups/batch?include=payCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"payCodeGroupNumber\": 1886.1,
            \"payCodeVariableIds\": []
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-groups/batch"
);

const params = {
    "include": "payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "payCodeGroupNumber": 1886.1,
            "payCodeVariableIds": []
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/pay-code-groups/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeVariables,payCodeVariables.variableType

Body Parameters

resources   object[]  optional  
translations   object  optional  

The data must be a valid translation object.

payCodeGroupNumber   number   

Example: 1886.1

payCodeGroupId   string  optional  
payCodeVariableIds   object   

Fetch a Pay code group by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/pay-code-groups/doloribus?include=payCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-code-groups/doloribus"
);

const params = {
    "include": "payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCodeGroup [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/pay-code-groups/{payCodeGroupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeGroupId   string   

Example: doloribus

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeVariables,payCodeVariables.variableType

Batch update Pay code groups

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/pay-code-groups/batch?include=payCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"payCodeGroupNumber\": 1820
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-groups/batch"
);

const params = {
    "include": "payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "payCodeGroupNumber": 1820
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/pay-code-groups/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeVariables,payCodeVariables.variableType

Body Parameters

resources   object[]  optional  
translations   object  optional  

The data must be a valid translation object.

payCodeGroupNumber   number  optional  

Example: 1820

payCodeGroupId   string  optional  
payCodeVariableIds   object  optional  

Update a Pay code group by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/pay-code-groups/veniam?include=payCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"payCodeGroupNumber\": 650692960.91821,
    \"payCodeVariableIds\": [
        \"quia\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-groups/veniam"
);

const params = {
    "include": "payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "payCodeGroupNumber": 650692960.91821,
    "payCodeVariableIds": [
        "quia"
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCodeGroup [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/pay-code-groups/{payCodeGroupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeGroupId   string   

Example: veniam

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeVariables,payCodeVariables.variableType

Body Parameters

translations   object  optional  

The data must be a valid translation object.

payCodeGroupNumber   number  optional  

Example: 650692960.91821

payCodeGroupId   string  optional  
payCodeVariableIds   string[]  optional  

Batch delete Pay code groups by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/pay-code-groups/batch?include=payCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"recusandae\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-groups/batch"
);

const params = {
    "include": "payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "recusandae"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/pay-code-groups/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeVariables,payCodeVariables.variableType

Body Parameters

resources   string[]  optional  

Delete a Pay code group by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/pay-code-groups/autem?include=payCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-code-groups/autem"
);

const params = {
    "include": "payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCodeGroup [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/pay-code-groups/{payCodeGroupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeGroupId   string   

Example: autem

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeVariables,payCodeVariables.variableType

Fetch a list of Pay code groups with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/pay-code-groups?page=1&pageSize=15&withSoftDeletes=1&include=payCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-code-groups"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/pay-code-groups

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeVariables,payCodeVariables.variableType

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-code-groups/search?page=1&pageSize=15&withSoftDeletes=1&include=payCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"payCodeGroupNumber\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"payCodeVariableIds\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-groups/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "payCodeGroupNumber",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "payCodeVariableIds",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

External integration

Create a new External integration

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/external-integrations?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"integrationName\": \"nemo\",
    \"description\": \"Molestiae illum officia rerum cumque iusto voluptatum enim voluptatem.\",
    \"status\": \"inactive\",
    \"integrationTypeId\": \"et\"
}"

const url = new URL(
    "http://localhost/api/v1/external-integrations"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "integrationName": "nemo",
    "description": "Molestiae illum officia rerum cumque iusto voluptatum enim voluptatem.",
    "status": "inactive",
    "integrationTypeId": "et"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/external-integrations

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

integrationName   string   

Example: nemo

description   string   

Example: Molestiae illum officia rerum cumque iusto voluptatum enim voluptatem.

status   string   

Example: inactive

Must be one of:
  • active
  • inactive
integrationTypeId   string   

Example: et

Batch create new External integrations

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/external-integrations/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"integrationName\": \"culpa\",
            \"description\": \"Laudantium veritatis incidunt ex deserunt facilis.\",
            \"status\": \"inactive\",
            \"integrationTypeId\": \"in\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/external-integrations/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "integrationName": "culpa",
            "description": "Laudantium veritatis incidunt ex deserunt facilis.",
            "status": "inactive",
            "integrationTypeId": "in"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/external-integrations/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
integrationName   string   

Example: culpa

description   string   

Example: Laudantium veritatis incidunt ex deserunt facilis.

status   string   

Example: inactive

Must be one of:
  • active
  • inactive
integrationTypeId   string   

Example: in

Fetch a External integration by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/external-integrations/corrupti?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/external-integrations/corrupti"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "ExternalIntegration [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/external-integrations/{externalIntegrationId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

externalIntegrationId   string   

Example: corrupti

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Batch update External integrations

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/external-integrations/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"description\": \"Deleniti et voluptas voluptatem voluptatem.\",
            \"status\": \"inactive\",
            \"integrationTypeId\": \"pariatur\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/external-integrations/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "description": "Deleniti et voluptas voluptatem voluptatem.",
            "status": "inactive",
            "integrationTypeId": "pariatur"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/external-integrations/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
integrationName   string  optional  
description   string  optional  

Example: Deleniti et voluptas voluptatem voluptatem.

status   string  optional  

Example: inactive

Must be one of:
  • active
  • inactive
integrationTypeId   string  optional  

Example: pariatur

Update a External integration by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/external-integrations/cum?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"description\": \"Nisi sed natus nulla dolores veritatis.\",
    \"status\": \"inactive\",
    \"integrationTypeId\": \"suscipit\"
}"

const url = new URL(
    "http://localhost/api/v1/external-integrations/cum"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "description": "Nisi sed natus nulla dolores veritatis.",
    "status": "inactive",
    "integrationTypeId": "suscipit"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "ExternalIntegration [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/external-integrations/{externalIntegrationId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

externalIntegrationId   string   

Example: cum

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

integrationName   string  optional  
description   string  optional  

Example: Nisi sed natus nulla dolores veritatis.

status   string  optional  

Example: inactive

Must be one of:
  • active
  • inactive
integrationTypeId   string  optional  

Example: suscipit

Batch delete External integrations by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/external-integrations/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"iste\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/external-integrations/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "iste"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/external-integrations/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   string[]  optional  

Delete a External integration by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/external-integrations/ad?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/external-integrations/ad"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "ExternalIntegration [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/external-integrations/{externalIntegrationId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

externalIntegrationId   string   

Example: ad

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Fetch a list of External integrations with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/external-integrations?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/external-integrations"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/external-integrations

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/external-integrations/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"integrationName\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"description\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"status\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/external-integrations/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "integrationName",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "description",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "status",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Pay code

Create a new Pay code

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-codes?include=payCodeGroup%2CpayCodeType%2CpayCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"companyId\": \"adipisci\",
    \"integrationId\": \"molestiae\",
    \"organizationId\": \"autem\",
    \"payCodeNumber\": 163,
    \"payCodeGroupId\": \"est\",
    \"payCodeTypeId\": \"porro\",
    \"payCodeVariableIds\": [
        \"enim\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-codes"
);

const params = {
    "include": "payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "companyId": "adipisci",
    "integrationId": "molestiae",
    "organizationId": "autem",
    "payCodeNumber": 163,
    "payCodeGroupId": "est",
    "payCodeTypeId": "porro",
    "payCodeVariableIds": [
        "enim"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/pay-codes

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType

Body Parameters

companyId   string  optional  

Example: adipisci

integrationId   string  optional  

Example: molestiae

organizationId   string  optional  

Example: autem

translations   object  optional  

The data must be a valid translation object.

payCodeNumber   number   

Example: 163

payCodeId   string  optional  
payCodeGroupId   string   

Example: est

payCodeTypeId   string   

Example: porro

payCodeVariableIds   string[]   

Batch create new Pay codes

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-codes/batch?include=payCodeGroup%2CpayCodeType%2CpayCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"companyId\": \"dicta\",
            \"integrationId\": \"quod\",
            \"organizationId\": \"qui\",
            \"payCodeNumber\": 52173309.2462472,
            \"payCodeGroupId\": \"aut\",
            \"payCodeTypeId\": \"beatae\",
            \"payCodeVariableIds\": []
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-codes/batch"
);

const params = {
    "include": "payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "companyId": "dicta",
            "integrationId": "quod",
            "organizationId": "qui",
            "payCodeNumber": 52173309.2462472,
            "payCodeGroupId": "aut",
            "payCodeTypeId": "beatae",
            "payCodeVariableIds": []
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/pay-codes/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType

Body Parameters

resources   object[]  optional  
companyId   string  optional  

Example: dicta

integrationId   string  optional  

Example: quod

organizationId   string  optional  

Example: qui

translations   object  optional  

The data must be a valid translation object.

payCodeNumber   number   

Example: 52173309.246247

payCodeId   string  optional  
payCodeGroupId   string   

Example: aut

payCodeTypeId   string   

Example: beatae

payCodeVariableIds   object   

Fetch a Pay code by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/pay-codes/iure?include=payCodeGroup%2CpayCodeType%2CpayCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-codes/iure"
);

const params = {
    "include": "payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCode [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/pay-codes/{payCodeId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeId   string   

Example: iure

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType

Batch update Pay codes

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/pay-codes/batch?include=payCodeGroup%2CpayCodeType%2CpayCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"payCodeNumber\": 351.1508298,
            \"payCodeGroupId\": \"voluptas\",
            \"payCodeTypeId\": \"ullam\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-codes/batch"
);

const params = {
    "include": "payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "payCodeNumber": 351.1508298,
            "payCodeGroupId": "voluptas",
            "payCodeTypeId": "ullam"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/pay-codes/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType

Body Parameters

resources   object[]  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

payCodeNumber   number  optional  

Example: 351.1508298

payCodeId   string  optional  
payCodeGroupId   string  optional  

Example: voluptas

payCodeTypeId   string  optional  

Example: ullam

payCodeVariableIds   object  optional  

Update a Pay code by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/pay-codes/eligendi?include=payCodeGroup%2CpayCodeType%2CpayCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"payCodeNumber\": 1526.6751,
    \"payCodeGroupId\": \"repellendus\",
    \"payCodeTypeId\": \"est\",
    \"payCodeVariableIds\": [
        \"numquam\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-codes/eligendi"
);

const params = {
    "include": "payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "payCodeNumber": 1526.6751,
    "payCodeGroupId": "repellendus",
    "payCodeTypeId": "est",
    "payCodeVariableIds": [
        "numquam"
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCode [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/pay-codes/{payCodeId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeId   string   

Example: eligendi

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType

Body Parameters

companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

payCodeNumber   number  optional  

Example: 1526.6751

payCodeId   string  optional  
payCodeGroupId   string  optional  

Example: repellendus

payCodeTypeId   string  optional  

Example: est

payCodeVariableIds   string[]  optional  

Batch delete Pay codes by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/pay-codes/batch?include=payCodeGroup%2CpayCodeType%2CpayCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"dolorum\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-codes/batch"
);

const params = {
    "include": "payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "dolorum"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/pay-codes/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType

Body Parameters

resources   string[]  optional  

Delete a Pay code by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/pay-codes/omnis?include=payCodeGroup%2CpayCodeType%2CpayCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-codes/omnis"
);

const params = {
    "include": "payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PayCode [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/pay-codes/{payCodeId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

payCodeId   string   

Example: omnis

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType

Fetch a list of Pay codes with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/pay-codes?page=1&pageSize=15&withSoftDeletes=1&include=payCodeGroup%2CpayCodeType%2CpayCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/pay-codes"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/pay-codes

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-codes/search?page=1&pageSize=15&withSoftDeletes=1&include=payCodeGroup%2CpayCodeType%2CpayCodeVariables%2CpayCodeVariables.variableType" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"organizationId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"integrationId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"companyId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"payCodeNumber\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"payCodeGroupId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"payCodeTypeId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"payCodeVariableIds\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"payCodeNumber\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/pay-codes/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "payCodeGroup,payCodeType,payCodeVariables,payCodeVariables.variableType",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "organizationId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "integrationId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "companyId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "payCodeNumber",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "payCodeGroupId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "payCodeTypeId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "payCodeVariableIds",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "payCodeNumber",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Personal card profile

Create a new Personal card profile

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personal-card-profiles?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"omnis\",
    \"tabs\": [
        {
            \"order\": 654283.881,
            \"personalCardProfileTabId\": \"at\",
            \"grids\": [
                {
                    \"order\": 1,
                    \"personalCardProfileTabGridId\": \"aut\",
                    \"fieldGroupId\": \"qui\",
                    \"fields\": [
                        {
                            \"order\": 1791.1527595,
                            \"fieldId\": \"qui\"
                        }
                    ]
                }
            ]
        }
    ],
    \"description\": \"Qui labore fugit eveniet et distinctio.\",
    \"isGlobal\": \"eligendi\",
    \"companyId\": \"deserunt\"
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profiles"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "omnis",
    "tabs": [
        {
            "order": 654283.881,
            "personalCardProfileTabId": "at",
            "grids": [
                {
                    "order": 1,
                    "personalCardProfileTabGridId": "aut",
                    "fieldGroupId": "qui",
                    "fields": [
                        {
                            "order": 1791.1527595,
                            "fieldId": "qui"
                        }
                    ]
                }
            ]
        }
    ],
    "description": "Qui labore fugit eveniet et distinctio.",
    "isGlobal": "eligendi",
    "companyId": "deserunt"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/personal-card-profiles

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

name   string   

Example: omnis

tabs   object[]   
order   number   

Example: 654283.881

personalCardProfileTabId   string   

Example: at

grids   object[]   
order   number   

Example: 1

personalCardProfileTabGridId   string   

Example: aut

fieldGroupId   string  optional  

This field is required when tabs..grids..fields is not present. Example: qui

fields   object[]   
order   number   

Example: 1791.1527595

fieldId   string   

Example: qui

translations   object  optional  

The data must be a valid translation object.

description   string   

Example: Qui labore fugit eveniet et distinctio.

isGlobal   string   

Example: eligendi

companyId   string  optional  

Example: deserunt

Batch create new Personal card profiles

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personal-card-profiles/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"name\": \"harum\",
            \"description\": \"Voluptatem nam et dolores.\",
            \"isGlobal\": \"iste\",
            \"companyId\": \"voluptatem\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profiles/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "name": "harum",
            "description": "Voluptatem nam et dolores.",
            "isGlobal": "iste",
            "companyId": "voluptatem"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/personal-card-profiles/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
name   string   

Example: harum

tabs   object  optional  
translations   object  optional  

The data must be a valid translation object.

description   string   

Example: Voluptatem nam et dolores.

isGlobal   string   

Example: iste

companyId   string  optional  

Example: voluptatem

Fetch a Personal card profile by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/personal-card-profiles/quibusdam?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isGlobal\": \"a\"
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profiles/quibusdam"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isGlobal": "a"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PersonalCardProfile [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/personal-card-profiles/{personalCardProfileId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personalCardProfileId   string   

Example: quibusdam

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

isGlobal   string   

Example: a

Batch update Personal card profiles

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/personal-card-profiles/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"debitis\",
    \"description\": \"Sunt qui itaque voluptates necessitatibus.\",
    \"tabs\": [
        {
            \"order\": 4489190.5,
            \"personalCardProfileTabId\": \"ullam\",
            \"grids\": [
                {
                    \"order\": 120.5959,
                    \"personalCardProfileTabGridId\": \"occaecati\",
                    \"fieldGroupId\": \"et\",
                    \"fields\": [
                        {
                            \"order\": 5.7453899,
                            \"fieldId\": \"est\"
                        }
                    ]
                }
            ]
        }
    ],
    \"isGlobal\": \"nisi\",
    \"companyId\": \"enim\"
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profiles/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "debitis",
    "description": "Sunt qui itaque voluptates necessitatibus.",
    "tabs": [
        {
            "order": 4489190.5,
            "personalCardProfileTabId": "ullam",
            "grids": [
                {
                    "order": 120.5959,
                    "personalCardProfileTabGridId": "occaecati",
                    "fieldGroupId": "et",
                    "fields": [
                        {
                            "order": 5.7453899,
                            "fieldId": "est"
                        }
                    ]
                }
            ]
        }
    ],
    "isGlobal": "nisi",
    "companyId": "enim"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/personal-card-profiles/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

name   string  optional  

Example: debitis

translations   object  optional  

The data must be a valid translation object.

description   string  optional  

Example: Sunt qui itaque voluptates necessitatibus.

tabs   object[]   
order   number   

Example: 4489190.5

personalCardProfileTabId   string   

Example: ullam

grids   object[]   
order   number   

Example: 120.5959

personalCardProfileTabGridId   string   

Example: occaecati

fieldGroupId   string  optional  

Example: et

fields   object[]  optional  
order   number   

Example: 5.7453899

fieldId   string   

Example: est

isGlobal   string   

Example: nisi

companyId   string  optional  

Example: enim

Update a Personal card profile by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/personal-card-profiles/dolor?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"aliquam\",
    \"description\": \"Corporis et consequuntur excepturi voluptate.\",
    \"tabs\": [
        {
            \"order\": 463006583.02,
            \"personalCardProfileTabId\": \"suscipit\",
            \"grids\": [
                {
                    \"order\": 40.8,
                    \"personalCardProfileTabGridId\": \"quo\",
                    \"fieldGroupId\": \"nesciunt\",
                    \"fields\": [
                        {
                            \"order\": 53.52108,
                            \"fieldId\": \"excepturi\"
                        }
                    ]
                }
            ]
        }
    ],
    \"isGlobal\": \"fuga\",
    \"companyId\": \"expedita\"
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profiles/dolor"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "aliquam",
    "description": "Corporis et consequuntur excepturi voluptate.",
    "tabs": [
        {
            "order": 463006583.02,
            "personalCardProfileTabId": "suscipit",
            "grids": [
                {
                    "order": 40.8,
                    "personalCardProfileTabGridId": "quo",
                    "fieldGroupId": "nesciunt",
                    "fields": [
                        {
                            "order": 53.52108,
                            "fieldId": "excepturi"
                        }
                    ]
                }
            ]
        }
    ],
    "isGlobal": "fuga",
    "companyId": "expedita"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PersonalCardProfile [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/personal-card-profiles/{personalCardProfileId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personalCardProfileId   string   

Example: dolor

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

name   string  optional  

Example: aliquam

translations   object  optional  

The data must be a valid translation object.

description   string  optional  

Example: Corporis et consequuntur excepturi voluptate.

tabs   object[]   
order   number   

Example: 463006583.02

personalCardProfileTabId   string   

Example: suscipit

grids   object[]   
order   number   

Example: 40.8

personalCardProfileTabGridId   string   

Example: quo

fieldGroupId   string  optional  

Example: nesciunt

fields   object[]  optional  
order   number   

Example: 53.52108

fieldId   string   

Example: excepturi

isGlobal   string   

Example: fuga

companyId   string  optional  

Example: expedita

Batch delete Personal card profiles by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/personal-card-profiles/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isGlobal\": \"voluptas\"
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profiles/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isGlobal": "voluptas"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/personal-card-profiles/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

isGlobal   string   

Example: voluptas

Delete a Personal card profile by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/personal-card-profiles/nemo?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isGlobal\": \"dolor\"
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profiles/nemo"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isGlobal": "dolor"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PersonalCardProfile [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/personal-card-profiles/{personalCardProfileId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personalCardProfileId   string   

Example: nemo

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

isGlobal   string   

Example: dolor

Fetch a list of Personal card profiles with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/personal-card-profiles?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isGlobal\": \"debitis\"
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profiles"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isGlobal": "debitis"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/personal-card-profiles

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

isGlobal   string   

Example: debitis

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personal-card-profiles/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"companyId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"isGlobal\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"name\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"description\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profiles/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "companyId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "isGlobal",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "name",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "description",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Personal card profile tab grid

Create a new Personal card profile tab grid

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personal-card-profile-tab-grids?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"tabId\": \"esse\",
    \"isGlobal\": false,
    \"description\": \"In qui totam sequi aliquam non.\",
    \"fieldGroupId\": \"velit\",
    \"fields\": [
        {
            \"globalFieldId\": \"sunt\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tab-grids"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "tabId": "esse",
    "isGlobal": false,
    "description": "In qui totam sequi aliquam non.",
    "fieldGroupId": "velit",
    "fields": [
        {
            "globalFieldId": "sunt"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/personal-card-profile-tab-grids

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

tabId   string  optional  

Example: esse

isGlobal   boolean  optional  

Example: false

description   string   

Example: In qui totam sequi aliquam non.

translations   string  optional  
fieldGroupId   string  optional  

Example: velit

fields   object[]  optional  
globalFieldId   string   

Example: sunt

Batch create new Personal card profile tab grids

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personal-card-profile-tab-grids/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"tabId\": \"dolores\",
            \"isGlobal\": false,
            \"description\": \"Molestias repellat rerum porro debitis accusantium et culpa.\",
            \"fieldGroupId\": \"aut\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tab-grids/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "tabId": "dolores",
            "isGlobal": false,
            "description": "Molestias repellat rerum porro debitis accusantium et culpa.",
            "fieldGroupId": "aut"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/personal-card-profile-tab-grids/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
tabId   string  optional  

Example: dolores

isGlobal   boolean  optional  

Example: false

description   string   

Example: Molestias repellat rerum porro debitis accusantium et culpa.

translations   string  optional  
fieldGroupId   string  optional  

Example: aut

fields   object  optional  

Fetch a Personal card profile tab grid by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/personal-card-profile-tab-grids/id?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tab-grids/id"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PersonalCardProfileTabGrid [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/personal-card-profile-tab-grids/{personalCardProfileTabGridId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personalCardProfileTabGridId   string   

Example: id

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Batch update Personal card profile tab grids

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/personal-card-profile-tab-grids/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"isGlobal\": true,
            \"description\": \"Quaerat illo sunt dolor impedit.\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tab-grids/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "isGlobal": true,
            "description": "Quaerat illo sunt dolor impedit."
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/personal-card-profile-tab-grids/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
tabId   string  optional  
isGlobal   boolean  optional  

Example: true

description   string  optional  

Example: Quaerat illo sunt dolor impedit.

translations   string  optional  
fields   string  optional  

Update a Personal card profile tab grid by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/personal-card-profile-tab-grids/reprehenderit?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isGlobal\": false,
    \"description\": \"Sapiente earum et qui eligendi.\"
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tab-grids/reprehenderit"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isGlobal": false,
    "description": "Sapiente earum et qui eligendi."
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PersonalCardProfileTabGrid [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/personal-card-profile-tab-grids/{personalCardProfileTabGridId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personalCardProfileTabGridId   string   

Example: reprehenderit

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

tabId   string  optional  
isGlobal   boolean  optional  

Example: false

description   string  optional  

Example: Sapiente earum et qui eligendi.

translations   string  optional  
fields   string  optional  

Batch delete Personal card profile tab grids by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/personal-card-profile-tab-grids/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"voluptas\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tab-grids/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "voluptas"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/personal-card-profile-tab-grids/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   string[]  optional  

Delete a Personal card profile tab grid by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/personal-card-profile-tab-grids/est?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tab-grids/est"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PersonalCardProfileTabGrid [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/personal-card-profile-tab-grids/{personalCardProfileTabGridId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personalCardProfileTabGridId   string   

Example: est

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Fetch a list of Personal card profile tab grids with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/personal-card-profile-tab-grids?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tab-grids"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/personal-card-profile-tab-grids

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personal-card-profile-tab-grids/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"isGlobal\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"description\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tab-grids/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "isGlobal",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "description",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Personal card profile tab

Create a new Personal card profile tab

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personal-card-profile-tabs?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isGlobal\": false,
    \"description\": \"Impedit alias debitis voluptatum quibusdam est.\"
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tabs"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isGlobal": false,
    "description": "Impedit alias debitis voluptatum quibusdam est."
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/personal-card-profile-tabs

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

isGlobal   boolean  optional  

Example: false

description   string   

Example: Impedit alias debitis voluptatum quibusdam est.

translations   string  optional  

Batch create new Personal card profile tabs

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personal-card-profile-tabs/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"isGlobal\": true,
            \"description\": \"Tempora quae saepe sit rerum.\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tabs/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "isGlobal": true,
            "description": "Tempora quae saepe sit rerum."
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/personal-card-profile-tabs/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
isGlobal   boolean  optional  

Example: true

description   string   

Example: Tempora quae saepe sit rerum.

translations   string  optional  

Fetch a Personal card profile tab by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/personal-card-profile-tabs/ut?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tabs/ut"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PersonalCardProfileTab [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/personal-card-profile-tabs/{personalCardProfileTabId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personalCardProfileTabId   string   

Example: ut

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Batch update Personal card profile tabs

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/personal-card-profile-tabs/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"isGlobal\": true,
            \"description\": \"Exercitationem quisquam iste deserunt dolorem modi eaque quo.\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tabs/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "isGlobal": true,
            "description": "Exercitationem quisquam iste deserunt dolorem modi eaque quo."
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/personal-card-profile-tabs/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
isGlobal   boolean  optional  

Example: true

description   string  optional  

Example: Exercitationem quisquam iste deserunt dolorem modi eaque quo.

translations   string  optional  

Update a Personal card profile tab by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/personal-card-profile-tabs/et?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isGlobal\": false,
    \"description\": \"Cum ea minima aut praesentium a.\"
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tabs/et"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isGlobal": false,
    "description": "Cum ea minima aut praesentium a."
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PersonalCardProfileTab [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/personal-card-profile-tabs/{personalCardProfileTabId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personalCardProfileTabId   string   

Example: et

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

isGlobal   boolean  optional  

Example: false

description   string  optional  

Example: Cum ea minima aut praesentium a.

translations   string  optional  

Batch delete Personal card profile tabs by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/personal-card-profile-tabs/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"error\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tabs/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "error"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/personal-card-profile-tabs/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   string[]  optional  

Delete a Personal card profile tab by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/personal-card-profile-tabs/beatae?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tabs/beatae"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "PersonalCardProfileTab [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/personal-card-profile-tabs/{personalCardProfileTabId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personalCardProfileTabId   string   

Example: beatae

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Fetch a list of Personal card profile tabs with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/personal-card-profile-tabs?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tabs"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/personal-card-profile-tabs

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personal-card-profile-tabs/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"isGlobal\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"description\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profile-tabs/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "isGlobal",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "description",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Locale

Create a new Locale

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/locales?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"dignissimos\",
    \"code\": \"pariatur\",
    \"enabled\": true
}"

const url = new URL(
    "http://localhost/api/v1/locales"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "dignissimos",
    "code": "pariatur",
    "enabled": true
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/locales

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

title   string   

Example: dignissimos

code   string   

Example: pariatur

enabled   boolean   

Example: true

Batch create new Locales

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/locales/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"title\": \"minus\",
            \"code\": \"sit\",
            \"enabled\": false
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/locales/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "title": "minus",
            "code": "sit",
            "enabled": false
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/locales/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
title   string   

Example: minus

code   string   

Example: sit

enabled   boolean   

Example: false

Fetch a Locale by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/locales/voluptatem?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/locales/voluptatem"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "Locale [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/locales/{localeId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

localeId   string   

Example: voluptatem

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Batch update Locales

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/locales/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"title\": \"laboriosam\",
            \"code\": \"ut\",
            \"enabled\": true
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/locales/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "title": "laboriosam",
            "code": "ut",
            "enabled": true
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/locales/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
title   string  optional  

Example: laboriosam

code   string  optional  

Example: ut

enabled   boolean  optional  

Example: true

Update a Locale by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/locales/non?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"dolores\",
    \"code\": \"error\",
    \"enabled\": false
}"

const url = new URL(
    "http://localhost/api/v1/locales/non"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "dolores",
    "code": "error",
    "enabled": false
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "Locale [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/locales/{localeId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

localeId   string   

Example: non

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

title   string  optional  

Example: dolores

code   string  optional  

Example: error

enabled   boolean  optional  

Example: false

Batch delete Locales by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/locales/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"pariatur\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/locales/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "pariatur"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/locales/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   string[]  optional  

Delete a Locale by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/locales/doloremque?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/locales/doloremque"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "Locale [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/locales/{localeId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

localeId   string   

Example: doloremque

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Fetch a list of Locales with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/locales?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/locales"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/locales

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/locales/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"code\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"title\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"enabled\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/locales/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "code",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "title",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "enabled",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

External salary type

Fetch a External salary type by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/external-salary-types/sit?include=company%2CexternalIntegration" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/external-salary-types/sit"
);

const params = {
    "include": "company,externalIntegration",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "ExternalSalaryType [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/external-salary-types/{externalSalaryTypeId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

externalSalaryTypeId   string   

Example: sit

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company,externalIntegration

Fetch a list of External salary types with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/external-salary-types?page=1&pageSize=15&withSoftDeletes=1&include=company%2CexternalIntegration" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/external-salary-types"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "company,externalIntegration",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/external-salary-types

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company,externalIntegration

Emp permission

Create a new Emp permission

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personnel-permissions?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"glue\": \"AND\",
    \"rules\": [
        \"odio\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personnel-permissions"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "glue": "AND",
    "rules": [
        "odio"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/personnel-permissions

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

glue   string   

Example: AND

Must be one of:
  • AND
  • OR
translations   object  optional  

The data must be a valid translation object.

rules   string[]  optional  

Batch create new Emp permissions

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personnel-permissions/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"glue\": \"AND\",
            \"rules\": []
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personnel-permissions/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "glue": "AND",
            "rules": []
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/personnel-permissions/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
glue   string   

Example: AND

Must be one of:
  • AND
  • OR
translations   object  optional  

The data must be a valid translation object.

rules   object   

Must have at least 1 items.

Fetch a Emp permission by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/personnel-permissions/eveniet?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/personnel-permissions/eveniet"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "EmpPermission [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/personnel-permissions/{personnelPermissionId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personnelPermissionId   string   

Example: eveniet

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Batch update Emp permissions

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/personnel-permissions/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"glue\": \"OR\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personnel-permissions/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "glue": "OR"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/personnel-permissions/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
glue   string  optional  

Example: OR

Must be one of:
  • AND
  • OR
translations   object  optional  

The data must be a valid translation object.

rules   object  optional  

Must have at least 1 items.

Update a Emp permission by its ID (Stability Score: 0.1)

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/personnel-permissions/et?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"glue\": \"AND\",
    \"rules\": [
        \"debitis\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personnel-permissions/et"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "glue": "AND",
    "rules": [
        "debitis"
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "EmpPermission [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/personnel-permissions/{personnelPermissionId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personnelPermissionId   string   

Example: et

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

glue   string  optional  

Example: AND

Must be one of:
  • AND
  • OR
translations   object  optional  

The data must be a valid translation object.

rules   string[]  optional  

Batch delete Emp permissions by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/personnel-permissions/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"sit\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personnel-permissions/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "sit"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/personnel-permissions/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   string[]  optional  

Delete a Emp permission by its ID (Stability Score: 0.1)

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/personnel-permissions/iure?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/personnel-permissions/iure"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "EmpPermission [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/personnel-permissions/{personnelPermissionId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personnelPermissionId   string   

Example: iure

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Fetch a list of Emp permissions with pagination (Stability Score: 0.1)

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/personnel-permissions?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/personnel-permissions"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/personnel-permissions

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personnel-permissions/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"empPermissionId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personnel-permissions/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "empPermissionId",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Emp permission rule

Create a new Emp permission rule

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personnel-permission-rules?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"employeeFieldId\": \"veritatis\",
    \"operator\": \"=\",
    \"value\": \"necessitatibus\"
}"

const url = new URL(
    "http://localhost/api/v1/personnel-permission-rules"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "employeeFieldId": "veritatis",
    "operator": "=",
    "value": "necessitatibus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/personnel-permission-rules

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

employeeFieldId   string   

Example: veritatis

translations   object  optional  

The data must be a valid translation object.

operator   string   

Example: =

Must be one of:
  • =
value   string   

Example: necessitatibus

Batch create new Emp permission rules

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personnel-permission-rules/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"employeeFieldId\": \"quae\",
            \"operator\": \"=\",
            \"value\": \"rerum\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personnel-permission-rules/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "employeeFieldId": "quae",
            "operator": "=",
            "value": "rerum"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/personnel-permission-rules/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
employeeFieldId   string   

Example: quae

translations   object  optional  

The data must be a valid translation object.

operator   string   

Example: =

Must be one of:
  • =
value   string   

Example: rerum

Fetch a Emp permission rule by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/personnel-permission-rules/et?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/personnel-permission-rules/et"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "EmpPermissionRule [id] does not exist.",
    "status": 404
}

Request      

GET api/v1/personnel-permission-rules/{personnelPermissionRuleId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personnelPermissionRuleId   string   

Example: et

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Batch update Emp permission rules

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/personnel-permission-rules/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        {
            \"employeeFieldId\": \"in\",
            \"operator\": \"=\",
            \"value\": \"ut\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personnel-permission-rules/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        {
            "employeeFieldId": "in",
            "operator": "=",
            "value": "ut"
        }
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/personnel-permission-rules/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   object[]  optional  
employeeFieldId   string  optional  

Example: in

translations   object  optional  

The data must be a valid translation object.

operator   string  optional  

Example: =

Must be one of:
  • =
value   string  optional  

Example: ut

Update a Emp permission rule by its ID (Stability Score: 0.1)

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/personnel-permission-rules/veniam?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"employeeFieldId\": \"et\",
    \"operator\": \"=\",
    \"value\": \"velit\"
}"

const url = new URL(
    "http://localhost/api/v1/personnel-permission-rules/veniam"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "employeeFieldId": "et",
    "operator": "=",
    "value": "velit"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "EmpPermissionRule [id] does not exist.",
    "status": 404
}

Request      

PATCH api/v1/personnel-permission-rules/{personnelPermissionRuleId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personnelPermissionRuleId   string   

Example: veniam

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

employeeFieldId   string  optional  

Example: et

translations   object  optional  

The data must be a valid translation object.

operator   string  optional  

Example: =

Must be one of:
  • =
value   string  optional  

Example: velit

Batch delete Emp permission rules by their IDs

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/personnel-permission-rules/batch?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": [
        \"dolor\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personnel-permission-rules/batch"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": [
        "dolor"
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/personnel-permission-rules/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

resources   string[]  optional  

Delete a Emp permission rule by its ID (Stability Score: 0.1)

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/personnel-permission-rules/debitis?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/personnel-permission-rules/debitis"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Example response (404):


{
    "data": [],
    "message": "EmpPermissionRule [id] does not exist.",
    "status": 404
}

Request      

DELETE api/v1/personnel-permission-rules/{personnelPermissionRuleId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personnelPermissionRuleId   string   

Example: debitis

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Fetch a list of Emp permission rules with pagination (Stability Score: 0.1)

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/personnel-permission-rules?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/personnel-permission-rules"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/personnel-permission-rules

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personnel-permission-rules/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"empPermissionRuleId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/personnel-permission-rules/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "empPermissionRuleId",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Transaction

Fetch a list of Transactions with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/transactions?page=1&pageSize=15&withSoftDeletes=1&include=company%2Cemployee%2CpayCode" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"companyId\": \"provident\"
}"

const url = new URL(
    "http://localhost/api/v1/transactions"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "company,employee,payCode",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "companyId": "provident"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/transactions

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: company,employee,payCode

Body Parameters

companyId   string   

Example: provident

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/transactions/search?page=1&pageSize=15&withSoftDeletes=1&include=company%2Cemployee%2CpayCode" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"companyId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"employeeId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"payCodeId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"salaryPeriod\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"externalId\",
            \"direction\": \"asc\"
        }
    ],
    \"companyId\": \"fuga\"
}"

const url = new URL(
    "http://localhost/api/v1/transactions/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "company,employee,payCode",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "companyId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "employeeId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "payCodeId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "salaryPeriod",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "externalId",
            "direction": "asc"
        }
    ],
    "companyId": "fuga"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Employee

Fetch a list of Employees with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/companies/illum/employees?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/companies/illum/employees"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

GET api/v1/companies/{companyId}/employees

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: illum

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Create a new Employee

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/companies/excepturi/employees?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/companies/excepturi/employees"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Example response (401):


{
    "message": "Unauthenticated."
}

Request      

POST api/v1/companies/{companyId}/employees

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: excepturi

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

App\ http\ resources\ api\ v1\ employee field change resource

Fetch a list of App\ http\ resources\ api\ v1\ employee field change resources based on the provided filters, scopes, sorting and pagination

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/et/field-changes/search-custom?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"fieldName\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"changeId\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"effectiveDate\",
            \"operator\": \"=\",
            \"value\": \"value\"
        },
        {
            \"field\": \"status\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/employees/et/field-changes/search-custom"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "fieldName",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "changeId",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "effectiveDate",
            "operator": "=",
            "value": "value"
        },
        {
            "field": "status",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/search-custom

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: et

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

filters   array  optional  

Filtering criteria Allowed operators: !=, =, >, <, >=, <=, in, not-in, array-contains, array-contains-any.

sort   array  optional  

Sorting criteria. Default sort is by createdAt.

Employee field change

Fetch a list of Employee field changes based on the provided filters, scopes, sorting and pagination

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/ut/field-changes/search?page=1&pageSize=15&withSoftDeletes=1&include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"filters\": [
        {
            \"field\": \"effectiveDate\",
            \"operator\": \"=\",
            \"value\": \"value\"
        }
    ],
    \"sort\": [
        {
            \"field\": \"createdAt\",
            \"direction\": \"asc\"
        },
        {
            \"field\": \"updatedAt\",
            \"direction\": \"asc\"
        }
    ]
}"

const url = new URL(
    "http://localhost/api/v1/employees/ut/field-changes/search"
);

const params = {
    "page": "1",
    "pageSize": "15",
    "withSoftDeletes": "1",
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "filters": [
        {
            "field": "effectiveDate",
            "operator": "=",
            "value": "value"
        }
    ],
    "sort": [
        {
            "field": "createdAt",
            "direction": "asc"
        },
        {
            "field": "updatedAt",
            "direction": "asc"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/search

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: ut

Query Parameters

page   integer  optional  

Page number for pagination, defaults to 1, minimum 1 Example: 1

pageSize   integer  optional  

Number of items per page, defaults to 15, minimum 1 Example: 15

withSoftDeletes   boolean  optional  

Include soft deleted items in the response Example: true

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

filters   array  optional  

Filtering criteria Allowed operators: !=, =, >, <, >=, <=, in, not-in, array-contains, array-contains-any.

sort   array  optional  

Sorting criteria. Default sort is by createdAt.

Custom Endpoints

All other endpoints

Authentication

Authenticate (Stability Score: 0.1)

This endpoint lets you authenticate.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/authenticate" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"url\": \"http:\\/\\/www.bashirian.com\\/\",
    \"companyId\": \"accusamus\",
    \"roleId\": 5,
    \"access_token\": \"qui\",
    \"sensitive\": true
}"

const url = new URL(
    "http://localhost/api/v1/authenticate"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "url": "http:\/\/www.bashirian.com\/",
    "companyId": "accusamus",
    "roleId": 5,
    "access_token": "qui",
    "sensitive": true
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (422):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Company accusamus does not exist. (and 1 more error)",
    "errors": {
        "companyId": [
            "Company accusamus does not exist."
        ],
        "roleId": [
            "The selected role id is invalid."
        ]
    },
    "status": 422
}

Request      

GET api/v1/authenticate

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

url   string  optional  

Example: http://www.bashirian.com/

companyId   string  optional  

Example: accusamus

roleId   integer  optional  

Example: 5

access_token   string  optional  

Example: qui

sensitive   boolean  optional  

Example: true

Logout

requires authentication

This endpoint lets you logout.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/logout" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/logout"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/logout

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

User

requires authentication

This endpoint lets you get the authenticated user.

Example request:
curl --request GET \
    --get "http://localhost/api/v1/user" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/user"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/user

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

SalaryWarning

Confirm a salary rule warning (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/salary-warnings/quidem/confirm?include=employee%2CsalaryRule" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/salary-warnings/quidem/confirm"
);

const params = {
    "include": "employee,salaryRule",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/salary-warnings/{salaryWarningId}/confirm

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

salaryWarningId   string   

Example: quidem

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: employee,salaryRule

Remove confirmation from a salary rule warning (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/salary-warnings/et/unconfirm?include=employee%2CsalaryRule" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/salary-warnings/et/unconfirm"
);

const params = {
    "include": "employee,salaryRule",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/salary-warnings/{salaryWarningId}/unconfirm

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

salaryWarningId   string   

Example: et

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes. Example: employee,salaryRule

Evaluate salary rules for a given period (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/execute-salary-rules?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/execute-salary-rules"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/execute-salary-rules

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Notification

Mark all notifications as read

requires authentication

This endpoint lets you mark all notifications as read.

Example request:
curl --request POST \
    "http://localhost/api/v1/notifications/read-all?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/notifications/read-all"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/notifications/read-all

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Mark a notification as read by its ID

requires authentication

This endpoint lets you mark a notification as read.

Example request:
curl --request POST \
    "http://localhost/api/v1/notifications/laborum/read?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/notifications/laborum/read"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/notifications/{notificationId}/read

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

notificationId   string   

Example: laborum

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Mark a notification as not read by its ID (Stability Score: 0.1)

requires authentication

This endpoint lets you mark a notification as not read.

Example request:
curl --request POST \
    "http://localhost/api/v1/notifications/pariatur/unread?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/notifications/pariatur/unread"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/notifications/{notificationId}/unread

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

notificationId   string   

Example: pariatur

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

PayCode Mapping

Duplicate a payCode mapping

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/pay-code-mappings/asperiores/duplicate" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"companyId\": \"autem\"
}"

const url = new URL(
    "http://localhost/api/v1/pay-code-mappings/asperiores/duplicate"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "companyId": "autem"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/pay-code-mappings/{mappingId}/duplicate

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

mappingId   string   

Example: asperiores

Body Parameters

companyId   string   

Example: autem

Statistics

Transaction Statistics

requires authentication

This endpoint lets you get transaction statistics.

Example request:
curl --request POST \
    "http://localhost/api/v1/transactions/statistics" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"includeChildren\": false,
    \"organizationId\": \"fugiat\",
    \"companyId\": \"ab\"
}"

const url = new URL(
    "http://localhost/api/v1/transactions/statistics"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "includeChildren": false,
    "organizationId": "fugiat",
    "companyId": "ab"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/transactions/statistics

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

includeChildren   boolean  optional  

Example: false

organizationId   string  optional  

This field is required when companyId is not present. Example: fugiat

companyId   string  optional  

This field is required when organizationId is not present. Example: ab

Personal Card Profile

Duplicate a personal card profile

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/personal-card-profiles/dolorem/duplicate?include=" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"animi\",
    \"description\": \"Ratione rerum ut magni voluptas ipsum.\",
    \"isGlobal\": \"vel\",
    \"companyId\": \"sed\"
}"

const url = new URL(
    "http://localhost/api/v1/personal-card-profiles/dolorem/duplicate"
);

const params = {
    "include": "",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "animi",
    "description": "Ratione rerum ut magni voluptas ipsum.",
    "isGlobal": "vel",
    "companyId": "sed"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/personal-card-profiles/{personalCardProfileId}/duplicate

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

personalCardProfileId   string   

Example: dolorem

Query Parameters

include   string  optional  

Include related resources. Use comma-separated values for multiple includes.

Body Parameters

name   string  optional  

Example: animi

translations   object  optional  

The data must be a valid translation object.

description   string  optional  

Example: Ratione rerum ut magni voluptas ipsum.

isGlobal   string   

Example: vel

companyId   string  optional  

Example: sed

Storage Structure

Create a new storage structure

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/storage-structure" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"directoryName\": \"inventore\",
    \"directoryParentId\": \"porro\"
}"

const url = new URL(
    "http://localhost/api/v1/storage-structure"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "directoryName": "inventore",
    "directoryParentId": "porro"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/storage-structure

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

directoryName   string   

Example: inventore

directoryParentId   string  optional  

Example: porro

Fetch a list of storage structures with pagination

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/storage-structure" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/storage-structure"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/storage-structure

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Fetch a storage structure by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/storage-structure/nihil" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/storage-structure/nihil"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/storage-structure/{storageStructureId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

storageStructureId   string   

Example: nihil

Update a storage structure by its ID

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/storage-structure/ex" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"directoryName\": \"reprehenderit\",
    \"directoryParentId\": \"hic\"
}"

const url = new URL(
    "http://localhost/api/v1/storage-structure/ex"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "directoryName": "reprehenderit",
    "directoryParentId": "hic"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/storage-structure/{storageStructureId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

storageStructureId   string   

Example: ex

Body Parameters

directoryName   string  optional  

This field is required when directoryParentId is not present. Example: reprehenderit

directoryParentId   string  optional  

Example: hic

Delete a storage structure by its ID

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/storage-structure/inventore" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/storage-structure/inventore"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Request      

DELETE api/v1/storage-structure/{storageStructureId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

storageStructureId   string   

Example: inventore

Employee

Transfer Changes

requires authentication

This endpoint lets you transfer changes.

Example request:
curl --request POST \
    "http://localhost/api/v1/change-transfer" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/change-transfer"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/change-transfer

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Relatives

Create a new relative

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/nam/employee-relatives" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"firstName\": \"temporibus\",
    \"lastName\": \"fugiat\",
    \"emailAddress\": \"fanny.jenkins@example.org\",
    \"telephone\": \"-{5,}\",
    \"mobilePhone\": \"+{5,}\",
    \"relationship\": \"fugit\",
    \"comment\": \"sint\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/nam/employee-relatives"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "firstName": "temporibus",
    "lastName": "fugiat",
    "emailAddress": "fanny.jenkins@example.org",
    "telephone": "-{5,}",
    "mobilePhone": "+{5,}",
    "relationship": "fugit",
    "comment": "sint"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/employee-relatives

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: nam

Body Parameters

firstName   string   

Example: temporibus

lastName   string   

Example: fugiat

emailAddress   string  optional  

Must be a valid email address. Example: fanny.jenkins@example.org

telephone   string  optional  

Must match the regex /^[\d\s-+]{5,}$/. Example: -{5,}

mobilePhone   string  optional  

Must match the regex /^[\d\s-+]{5,}$/. Example: +{5,}

relationship   string   

Example: fugit

comment   string  optional  

Example: sint

Relative Changes

Get changes for a particular relative.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/employees/laborum/employee-relatives/esse/field-changes" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/employees/laborum/employee-relatives/esse/field-changes"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/employees/{employeeId}/employee-relatives/{relativeId}/field-changes

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: laborum

relativeId   string   

Example: esse

Employee Relative Field Changes

Approve a field change for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/ut/employee-relatives/repellat/approve-field-change" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"mollitia\",
    \"recordId\": \"voluptatem\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/ut/employee-relatives/repellat/approve-field-change"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "mollitia",
    "recordId": "voluptatem"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/employee-relatives/{relativeId}/approve-field-change

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: ut

relativeId   string   

Example: repellat

Body Parameters

changeId   string   

Example: mollitia

recordId   string   

Example: voluptatem

Approve multiple field changes for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/officia/employee-relatives/ut/approve-field-change/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"velit\",
    \"recordId\": \"quam\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/officia/employee-relatives/ut/approve-field-change/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "velit",
    "recordId": "quam"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/employee-relatives/{relativeId}/approve-field-change/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: officia

relativeId   string   

Example: ut

Body Parameters

changeId   string   

Example: velit

recordId   string   

Example: quam

Deny a field change for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/autem/employee-relatives/nam/deny-field-change" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"esse\",
    \"recordId\": \"voluptatem\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/autem/employee-relatives/nam/deny-field-change"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "esse",
    "recordId": "voluptatem"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/employee-relatives/{relativeId}/deny-field-change

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: autem

relativeId   string   

Example: nam

Body Parameters

changeId   string   

Example: esse

recordId   string   

Example: voluptatem

Deny multiple field changes for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/et/employee-relatives/possimus/deny-field-change/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"deserunt\",
    \"recordId\": \"sit\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/et/employee-relatives/possimus/deny-field-change/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "deserunt",
    "recordId": "sit"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/employee-relatives/{relativeId}/deny-field-change/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: et

relativeId   string   

Example: possimus

Body Parameters

changeId   string   

Example: deserunt

recordId   string   

Example: sit

Employee Future Changes

List all changes for a particular employee.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/employees/nesciunt/future-changes" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/employees/nesciunt/future-changes"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/employees/{employeeId}/future-changes

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: nesciunt

Employees

Get all unique effective dates for an employee.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/employees/et/field-changes/unique-effective-dates" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/employees/et/field-changes/unique-effective-dates"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/employees/{employeeId}/field-changes/unique-effective-dates

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: et

Create a new employee change

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/quia/field-changes" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"effectiveDate\": 0,
    \"changeId\": \"repellendus\",
    \"changeType\": \"delete\",
    \"fieldName\": \"aliquid\",
    \"oldValue\": \"illum\",
    \"comment\": \"veritatis\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/quia/field-changes"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "effectiveDate": 0,
    "changeId": "repellendus",
    "changeType": "delete",
    "fieldName": "aliquid",
    "oldValue": "illum",
    "comment": "veritatis"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: quia

Body Parameters

effectiveDate   number  optional  

This field is required unless changeType is in delete. Must be between 0 and 2147483647. Example: 0

changeId   string  optional  

Example: repellendus

changeType   string  optional  

Example: delete

Must be one of:
  • delete
fieldName   string   

Example: aliquid

newValue   string  optional  

This field is required unless changeType is in delete.

oldValue   string  optional  

Example: illum

comment   string  optional  

Example: veritatis

changedBy   string  optional  
changedDate   string  optional  
approved   string  optional  
employeeId   string  optional  
status   string  optional  

Create multiple employee changes

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/magni/field-changes/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"effectiveDate\": 0,
    \"changeId\": \"quo\",
    \"changeType\": \"delete\",
    \"fieldName\": \"vitae\",
    \"oldValue\": \"impedit\",
    \"comment\": \"tempora\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/magni/field-changes/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "effectiveDate": 0,
    "changeId": "quo",
    "changeType": "delete",
    "fieldName": "vitae",
    "oldValue": "impedit",
    "comment": "tempora"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: magni

Body Parameters

effectiveDate   number  optional  

This field is required unless changeType is in delete. Must be between 0 and 2147483647. Example: 0

changeId   string  optional  

Example: quo

changeType   string  optional  

Example: delete

Must be one of:
  • delete
fieldName   string   

Example: vitae

newValue   string  optional  

This field is required unless changeType is in delete.

oldValue   string  optional  

Example: impedit

comment   string  optional  

Example: tempora

changedBy   string  optional  
changedDate   string  optional  
approved   string  optional  
employeeId   string  optional  
status   string  optional  

Employment Changes

List all changes for a particular employee.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/employees/ipsa/field-changes/employment" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/employees/ipsa/field-changes/employment"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/employees/{employeeId}/field-changes/employment

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: ipsa

Create a new change request for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/minus/field-changes/employment" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"effectiveDate\": 0,
    \"changeId\": \"aliquid\",
    \"changeType\": \"delete\",
    \"fieldName\": \"voluptates\",
    \"oldValue\": \"dolorem\",
    \"comment\": \"officia\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/minus/field-changes/employment"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "effectiveDate": 0,
    "changeId": "aliquid",
    "changeType": "delete",
    "fieldName": "voluptates",
    "oldValue": "dolorem",
    "comment": "officia"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/employment

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: minus

Body Parameters

effectiveDate   number  optional  

This field is required unless changeType is in delete. Must be between 0 and 2147483647. Example: 0

changeId   string  optional  

Example: aliquid

changeType   string  optional  

Example: delete

Must be one of:
  • delete
fieldName   string   

Example: voluptates

newValue   string  optional  

This field is required unless changeType is in delete.

oldValue   string  optional  

Example: dolorem

comment   string  optional  

Example: officia

changedBy   string  optional  
changedDate   string  optional  
approved   string  optional  
employeeId   string  optional  
status   string  optional  

Create multiple change requests for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/quibusdam/field-changes/employment/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"effectiveDate\": 1,
    \"changeId\": \"odio\",
    \"changeType\": \"delete\",
    \"fieldName\": \"reprehenderit\",
    \"oldValue\": \"voluptatum\",
    \"comment\": \"maxime\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/quibusdam/field-changes/employment/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "effectiveDate": 1,
    "changeId": "odio",
    "changeType": "delete",
    "fieldName": "reprehenderit",
    "oldValue": "voluptatum",
    "comment": "maxime"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/employment/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: quibusdam

Body Parameters

effectiveDate   number  optional  

This field is required unless changeType is in delete. Must be between 0 and 2147483647. Example: 1

changeId   string  optional  

Example: odio

changeType   string  optional  

Example: delete

Must be one of:
  • delete
fieldName   string   

Example: reprehenderit

newValue   string  optional  

This field is required unless changeType is in delete.

oldValue   string  optional  

Example: voluptatum

comment   string  optional  

Example: maxime

changedBy   string  optional  
changedDate   string  optional  
approved   string  optional  
employeeId   string  optional  
status   string  optional  

Approve a field change for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/qui/field-changes/employment/approve-field-change" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"quam\",
    \"recordId\": \"corporis\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/qui/field-changes/employment/approve-field-change"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "quam",
    "recordId": "corporis"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/employment/approve-field-change

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: qui

Body Parameters

changeId   string   

Example: quam

recordId   string   

Example: corporis

Approve multiple field changes for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/non/field-changes/employment/approve-field-change/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"qui\",
    \"recordId\": \"odit\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/non/field-changes/employment/approve-field-change/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "qui",
    "recordId": "odit"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/employment/approve-field-change/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: non

Body Parameters

changeId   string   

Example: qui

recordId   string   

Example: odit

Deny a field change for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/praesentium/field-changes/employment/deny-field-change" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"magnam\",
    \"recordId\": \"in\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/praesentium/field-changes/employment/deny-field-change"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "magnam",
    "recordId": "in"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/employment/deny-field-change

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: praesentium

Body Parameters

changeId   string   

Example: magnam

recordId   string   

Example: in

Deny multiple field changes for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/qui/field-changes/employment/deny-field-change/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"quod\",
    \"recordId\": \"repellendus\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/qui/field-changes/employment/deny-field-change/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "quod",
    "recordId": "repellendus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/employment/deny-field-change/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: qui

Body Parameters

changeId   string   

Example: quod

recordId   string   

Example: repellendus

Pay Code Changes

Get all pay code changes.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/employees/ipsam/field-changes/pay-code" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/employees/ipsam/field-changes/pay-code"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/employees/{employeeId}/field-changes/pay-code

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: ipsam

Create a new pay code change.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/perferendis/field-changes/pay-code" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"effectiveDate\": 0,
    \"changeId\": \"expedita\",
    \"changeType\": \"delete\",
    \"fieldName\": \"qui\",
    \"comment\": \"dolorem\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/perferendis/field-changes/pay-code"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "effectiveDate": 0,
    "changeId": "expedita",
    "changeType": "delete",
    "fieldName": "qui",
    "comment": "dolorem"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/pay-code

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: perferendis

Body Parameters

effectiveDate   number  optional  

This field is required unless changeType is in delete. Must be between 0 and 2147483647. Example: 0

changeId   string  optional  

Example: expedita

changeType   string  optional  

Example: delete

Must be one of:
  • delete
fieldName   string   

Example: qui

newValue   object  optional  

This field is required unless changeType is in delete.

oldValue   object  optional  
comment   string  optional  

Example: dolorem

changedBy   string  optional  
changedDate   string  optional  
approved   string  optional  
employeeId   string  optional  
status   string  optional  

Create multiple pay code changes.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/qui/field-changes/pay-code/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"effectiveDate\": 1,
    \"changeId\": \"ullam\",
    \"changeType\": \"delete\",
    \"fieldName\": \"sit\",
    \"comment\": \"nihil\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/qui/field-changes/pay-code/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "effectiveDate": 1,
    "changeId": "ullam",
    "changeType": "delete",
    "fieldName": "sit",
    "comment": "nihil"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/pay-code/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: qui

Body Parameters

effectiveDate   number  optional  

This field is required unless changeType is in delete. Must be between 0 and 2147483647. Example: 1

changeId   string  optional  

Example: ullam

changeType   string  optional  

Example: delete

Must be one of:
  • delete
fieldName   string   

Example: sit

newValue   object  optional  

This field is required unless changeType is in delete.

oldValue   object  optional  
comment   string  optional  

Example: nihil

changedBy   string  optional  
changedDate   string  optional  
approved   string  optional  
employeeId   string  optional  
status   string  optional  

Approve a field change for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/amet/field-changes/pay-code/approve-field-change" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"in\",
    \"recordId\": \"debitis\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/amet/field-changes/pay-code/approve-field-change"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "in",
    "recordId": "debitis"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/pay-code/approve-field-change

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: amet

Body Parameters

changeId   string   

Example: in

recordId   string   

Example: debitis

Approve multiple field changes for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/velit/field-changes/pay-code/approve-field-change/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"ea\",
    \"recordId\": \"at\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/velit/field-changes/pay-code/approve-field-change/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "ea",
    "recordId": "at"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/pay-code/approve-field-change/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: velit

Body Parameters

changeId   string   

Example: ea

recordId   string   

Example: at

Deny a field change for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/ut/field-changes/pay-code/deny-field-change" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"labore\",
    \"recordId\": \"autem\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/ut/field-changes/pay-code/deny-field-change"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "labore",
    "recordId": "autem"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/pay-code/deny-field-change

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: ut

Body Parameters

changeId   string   

Example: labore

recordId   string   

Example: autem

Deny multiple field changes for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/aut/field-changes/pay-code/deny-field-change/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"ut\",
    \"recordId\": \"et\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/aut/field-changes/pay-code/deny-field-change/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "ut",
    "recordId": "et"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/field-changes/pay-code/deny-field-change/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: aut

Body Parameters

changeId   string   

Example: ut

recordId   string   

Example: et

Employee Field Changes

Approve a field change for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/recusandae/approve-field-change" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"alias\",
    \"recordId\": \"vero\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/recusandae/approve-field-change"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "alias",
    "recordId": "vero"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/approve-field-change

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: recusandae

Body Parameters

changeId   string   

Example: alias

recordId   string   

Example: vero

Approve multiple field changes for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/minima/approve-field-change/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"autem\",
    \"recordId\": \"totam\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/minima/approve-field-change/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "autem",
    "recordId": "totam"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/approve-field-change/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: minima

Body Parameters

changeId   string   

Example: autem

recordId   string   

Example: totam

Deny a field change for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/temporibus/deny-field-change" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"harum\",
    \"recordId\": \"officiis\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/temporibus/deny-field-change"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "harum",
    "recordId": "officiis"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/deny-field-change

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: temporibus

Body Parameters

changeId   string   

Example: harum

recordId   string   

Example: officiis

Deny multiple field changes for a particular employee.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/employees/dolorem/deny-field-change/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"changeId\": \"ea\",
    \"recordId\": \"labore\"
}"

const url = new URL(
    "http://localhost/api/v1/employees/dolorem/deny-field-change/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "changeId": "ea",
    "recordId": "labore"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/employees/{employeeId}/deny-field-change/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeId   string   

Example: dolorem

Body Parameters

changeId   string   

Example: ea

recordId   string   

Example: labore

Employee Field Mappings

Create a new employee field mapping.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/field-mappings" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"externalEmployeeFieldId\": \"harum\",
    \"employeeFieldId\": \"qui\",
    \"externalIntegrationId\": \"quam\"
}"

const url = new URL(
    "http://localhost/api/v1/field-mappings"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "externalEmployeeFieldId": "harum",
    "employeeFieldId": "qui",
    "externalIntegrationId": "quam"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/field-mappings

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

externalEmployeeFieldId   string   

Example: harum

employeeFieldId   string   

Example: qui

companyId   string  optional  
externalIntegrationId   string  optional  

Example: quam

organizationId   string  optional  

Create multiple employee field mappings.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/field-mappings/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"externalEmployeeFieldId\": \"id\",
    \"employeeFieldId\": \"voluptates\",
    \"externalIntegrationId\": \"est\"
}"

const url = new URL(
    "http://localhost/api/v1/field-mappings/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "externalEmployeeFieldId": "id",
    "employeeFieldId": "voluptates",
    "externalIntegrationId": "est"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/field-mappings/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

externalEmployeeFieldId   string   

Example: id

employeeFieldId   string   

Example: voluptates

companyId   string  optional  
externalIntegrationId   string  optional  

Example: est

organizationId   string  optional  

Update an employee field mapping.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/field-mappings/impedit" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"externalEmployeeFieldId\": \"harum\",
    \"employeeFieldId\": \"delectus\",
    \"externalIntegrationId\": \"sed\"
}"

const url = new URL(
    "http://localhost/api/v1/field-mappings/impedit"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "externalEmployeeFieldId": "harum",
    "employeeFieldId": "delectus",
    "externalIntegrationId": "sed"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/field-mappings/{mappingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

mappingId   string   

Example: impedit

Body Parameters

externalEmployeeFieldId   string   

Example: harum

employeeFieldId   string   

Example: delectus

companyId   string  optional  
externalIntegrationId   string  optional  

Example: sed

organizationId   string  optional  

Delete an employee field mapping.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/field-mappings/provident" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/field-mappings/provident"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Request      

DELETE api/v1/field-mappings/{mappingId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

mappingId   string   

Example: provident

Employee Fields

Get fields for a particular integration.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/external-integration/animi/employee-fields" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": true,
    \"isMandatory\": true,
    \"salarySensitive\": true,
    \"sensitive\": true,
    \"allowNewValue\": true,
    \"observe\": false,
    \"importExcluded\": false,
    \"manualInput\": false,
    \"fieldType\": \"select\",
    \"dataType\": \"string\",
    \"maxInput\": 9781421.795177348,
    \"minInput\": 39550010.758808
}"

const url = new URL(
    "http://localhost/api/v1/external-integration/animi/employee-fields"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": true,
    "isMandatory": true,
    "salarySensitive": true,
    "sensitive": true,
    "allowNewValue": true,
    "observe": false,
    "importExcluded": false,
    "manualInput": false,
    "fieldType": "select",
    "dataType": "string",
    "maxInput": 9781421.795177348,
    "minInput": 39550010.758808
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/external-integration/{integrationId}/employee-fields

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

integrationId   string   

Example: animi

Body Parameters

companyId   string  optional  
parentId   string  optional  
fieldName   string  optional  
isGlobal   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: true

isMandatory   boolean  optional  

Example: true

salarySensitive   boolean  optional  

Example: true

sensitive   boolean  optional  

Example: true

allowNewValue   boolean  optional  

Example: true

observe   boolean  optional  

Example: false

importExcluded   boolean  optional  

Example: false

manualInput   boolean  optional  

Example: false

fieldType   string  optional  

Example: select

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: string

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 9781421.7951773

minInput   number  optional  

Example: 39550010.758808

Customize an existing global employee field for a particular integration.

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1/external-integration/et/employee-fields/natus" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": true,
    \"isMandatory\": true,
    \"salarySensitive\": false,
    \"sensitive\": false,
    \"allowNewValue\": true,
    \"observe\": false,
    \"importExcluded\": true,
    \"manualInput\": false,
    \"fieldType\": \"number\",
    \"dataType\": \"date\",
    \"maxInput\": 17716.2,
    \"minInput\": 7574.82138
}"

const url = new URL(
    "http://localhost/api/v1/external-integration/et/employee-fields/natus"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": true,
    "isMandatory": true,
    "salarySensitive": false,
    "sensitive": false,
    "allowNewValue": true,
    "observe": false,
    "importExcluded": true,
    "manualInput": false,
    "fieldType": "number",
    "dataType": "date",
    "maxInput": 17716.2,
    "minInput": 7574.82138
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PUT api/v1/external-integration/{integrationId}/employee-fields/{fieldId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

integrationId   string   

Example: et

fieldId   string   

Example: natus

Body Parameters

companyId   string  optional  
parentId   string  optional  
fieldName   string  optional  
isGlobal   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: true

isMandatory   boolean  optional  

Example: true

salarySensitive   boolean  optional  

Example: false

sensitive   boolean  optional  

Example: false

allowNewValue   boolean  optional  

Example: true

observe   boolean  optional  

Example: false

importExcluded   boolean  optional  

Example: true

manualInput   boolean  optional  

Example: false

fieldType   string  optional  

Example: number

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: date

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 17716.2

minInput   number  optional  

Example: 7574.82138

Get an extended employee field for a particular integration.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/external-integration/quas/employee-fields/optio" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": false,
    \"isMandatory\": true,
    \"salarySensitive\": false,
    \"sensitive\": true,
    \"allowNewValue\": false,
    \"observe\": true,
    \"importExcluded\": false,
    \"manualInput\": false,
    \"fieldType\": \"email\",
    \"dataType\": \"date\",
    \"maxInput\": 172.457,
    \"minInput\": 3522263.42255176
}"

const url = new URL(
    "http://localhost/api/v1/external-integration/quas/employee-fields/optio"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": false,
    "isMandatory": true,
    "salarySensitive": false,
    "sensitive": true,
    "allowNewValue": false,
    "observe": true,
    "importExcluded": false,
    "manualInput": false,
    "fieldType": "email",
    "dataType": "date",
    "maxInput": 172.457,
    "minInput": 3522263.42255176
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/external-integration/{integrationId}/employee-fields/{fieldId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

integrationId   string   

Example: quas

fieldId   string   

Example: optio

Body Parameters

companyId   string  optional  
parentId   string  optional  
fieldName   string  optional  
isGlobal   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: false

isMandatory   boolean  optional  

Example: true

salarySensitive   boolean  optional  

Example: false

sensitive   boolean  optional  

Example: true

allowNewValue   boolean  optional  

Example: false

observe   boolean  optional  

Example: true

importExcluded   boolean  optional  

Example: false

manualInput   boolean  optional  

Example: false

fieldType   string  optional  

Example: email

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: date

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 172.457

minInput   number  optional  

Example: 3522263.4225518

Revert an extended employee field for a particular integration.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/external-integration/eos/employee-fields/nisi" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": false,
    \"isMandatory\": true,
    \"salarySensitive\": true,
    \"sensitive\": false,
    \"allowNewValue\": false,
    \"observe\": false,
    \"importExcluded\": false,
    \"manualInput\": true,
    \"fieldType\": \"password\",
    \"dataType\": \"boolean\",
    \"maxInput\": 6.15836529,
    \"minInput\": 1147495.1267429474
}"

const url = new URL(
    "http://localhost/api/v1/external-integration/eos/employee-fields/nisi"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": false,
    "isMandatory": true,
    "salarySensitive": true,
    "sensitive": false,
    "allowNewValue": false,
    "observe": false,
    "importExcluded": false,
    "manualInput": true,
    "fieldType": "password",
    "dataType": "boolean",
    "maxInput": 6.15836529,
    "minInput": 1147495.1267429474
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/external-integration/{integrationId}/employee-fields/{fieldId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

integrationId   string   

Example: eos

fieldId   string   

Example: nisi

Body Parameters

companyId   string  optional  
parentId   string  optional  
fieldName   string  optional  
isGlobal   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: false

isMandatory   boolean  optional  

Example: true

salarySensitive   boolean  optional  

Example: true

sensitive   boolean  optional  

Example: false

allowNewValue   boolean  optional  

Example: false

observe   boolean  optional  

Example: false

importExcluded   boolean  optional  

Example: false

manualInput   boolean  optional  

Example: true

fieldType   string  optional  

Example: password

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: boolean

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 6.15836529

minInput   number  optional  

Example: 1147495.1267429

Get fields for a particular organization.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/organization/in/employee-fields" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": false,
    \"isMandatory\": false,
    \"salarySensitive\": true,
    \"sensitive\": true,
    \"allowNewValue\": false,
    \"observe\": false,
    \"importExcluded\": false,
    \"manualInput\": true,
    \"fieldType\": \"date\",
    \"dataType\": \"string\",
    \"maxInput\": 35.8457,
    \"minInput\": 980.00662708
}"

const url = new URL(
    "http://localhost/api/v1/organization/in/employee-fields"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": false,
    "isMandatory": false,
    "salarySensitive": true,
    "sensitive": true,
    "allowNewValue": false,
    "observe": false,
    "importExcluded": false,
    "manualInput": true,
    "fieldType": "date",
    "dataType": "string",
    "maxInput": 35.8457,
    "minInput": 980.00662708
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/organization/{organizationId}/employee-fields

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: in

Body Parameters

companyId   string  optional  
parentId   string  optional  
fieldName   string  optional  
isGlobal   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: false

isMandatory   boolean  optional  

Example: false

salarySensitive   boolean  optional  

Example: true

sensitive   boolean  optional  

Example: true

allowNewValue   boolean  optional  

Example: false

observe   boolean  optional  

Example: false

importExcluded   boolean  optional  

Example: false

manualInput   boolean  optional  

Example: true

fieldType   string  optional  

Example: date

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: string

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 35.8457

minInput   number  optional  

Example: 980.00662708

Customize an existing global employee field for a particular organization.

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1/organization/rerum/employee-fields/consequatur" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": false,
    \"isMandatory\": false,
    \"salarySensitive\": false,
    \"sensitive\": false,
    \"allowNewValue\": true,
    \"observe\": false,
    \"importExcluded\": true,
    \"manualInput\": false,
    \"fieldType\": \"email\",
    \"dataType\": \"date\",
    \"maxInput\": 14734.955942,
    \"minInput\": 768375.2478
}"

const url = new URL(
    "http://localhost/api/v1/organization/rerum/employee-fields/consequatur"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": false,
    "isMandatory": false,
    "salarySensitive": false,
    "sensitive": false,
    "allowNewValue": true,
    "observe": false,
    "importExcluded": true,
    "manualInput": false,
    "fieldType": "email",
    "dataType": "date",
    "maxInput": 14734.955942,
    "minInput": 768375.2478
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PUT api/v1/organization/{organizationId}/employee-fields/{fieldId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: rerum

fieldId   string   

Example: consequatur

Body Parameters

companyId   string  optional  
parentId   string  optional  
fieldName   string  optional  
isGlobal   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: false

isMandatory   boolean  optional  

Example: false

salarySensitive   boolean  optional  

Example: false

sensitive   boolean  optional  

Example: false

allowNewValue   boolean  optional  

Example: true

observe   boolean  optional  

Example: false

importExcluded   boolean  optional  

Example: true

manualInput   boolean  optional  

Example: false

fieldType   string  optional  

Example: email

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: date

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 14734.955942

minInput   number  optional  

Example: 768375.2478

Show an extended employee field for a particular organization.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/organization/est/employee-fields/quibusdam" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": true,
    \"isMandatory\": true,
    \"salarySensitive\": false,
    \"sensitive\": true,
    \"allowNewValue\": true,
    \"observe\": true,
    \"importExcluded\": true,
    \"manualInput\": true,
    \"fieldType\": \"textarea\",
    \"dataType\": \"date\",
    \"maxInput\": 229939055.15218,
    \"minInput\": 4.9546598
}"

const url = new URL(
    "http://localhost/api/v1/organization/est/employee-fields/quibusdam"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": true,
    "isMandatory": true,
    "salarySensitive": false,
    "sensitive": true,
    "allowNewValue": true,
    "observe": true,
    "importExcluded": true,
    "manualInput": true,
    "fieldType": "textarea",
    "dataType": "date",
    "maxInput": 229939055.15218,
    "minInput": 4.9546598
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/organization/{organizationId}/employee-fields/{fieldId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: est

fieldId   string   

Example: quibusdam

Body Parameters

companyId   string  optional  
parentId   string  optional  
fieldName   string  optional  
isGlobal   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: true

isMandatory   boolean  optional  

Example: true

salarySensitive   boolean  optional  

Example: false

sensitive   boolean  optional  

Example: true

allowNewValue   boolean  optional  

Example: true

observe   boolean  optional  

Example: true

importExcluded   boolean  optional  

Example: true

manualInput   boolean  optional  

Example: true

fieldType   string  optional  

Example: textarea

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: date

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 229939055.15218

minInput   number  optional  

Example: 4.9546598

Revert an extended employee field for a particular organization.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/organization/sed/employee-fields/sed" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": false,
    \"isMandatory\": true,
    \"salarySensitive\": false,
    \"sensitive\": true,
    \"allowNewValue\": true,
    \"observe\": false,
    \"importExcluded\": false,
    \"manualInput\": true,
    \"fieldType\": \"email\",
    \"dataType\": \"number\",
    \"maxInput\": 16822.811836268,
    \"minInput\": 312246.9004489
}"

const url = new URL(
    "http://localhost/api/v1/organization/sed/employee-fields/sed"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": false,
    "isMandatory": true,
    "salarySensitive": false,
    "sensitive": true,
    "allowNewValue": true,
    "observe": false,
    "importExcluded": false,
    "manualInput": true,
    "fieldType": "email",
    "dataType": "number",
    "maxInput": 16822.811836268,
    "minInput": 312246.9004489
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/organization/{organizationId}/employee-fields/{fieldId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: sed

fieldId   string   

Example: sed

Body Parameters

companyId   string  optional  
parentId   string  optional  
fieldName   string  optional  
isGlobal   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: false

isMandatory   boolean  optional  

Example: true

salarySensitive   boolean  optional  

Example: false

sensitive   boolean  optional  

Example: true

allowNewValue   boolean  optional  

Example: true

observe   boolean  optional  

Example: false

importExcluded   boolean  optional  

Example: false

manualInput   boolean  optional  

Example: true

fieldType   string  optional  

Example: email

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: number

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 16822.811836268

minInput   number  optional  

Example: 312246.9004489

Customize an existing global employee field for a particular company.

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1/company/cumque/employee-fields/et" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": false,
    \"isMandatory\": true,
    \"salarySensitive\": false,
    \"sensitive\": false,
    \"allowNewValue\": false,
    \"observe\": true,
    \"importExcluded\": false,
    \"manualInput\": false,
    \"fieldType\": \"textarea\",
    \"dataType\": \"boolean\",
    \"maxInput\": 92184.9766246,
    \"minInput\": 122229087.09757656
}"

const url = new URL(
    "http://localhost/api/v1/company/cumque/employee-fields/et"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": false,
    "isMandatory": true,
    "salarySensitive": false,
    "sensitive": false,
    "allowNewValue": false,
    "observe": true,
    "importExcluded": false,
    "manualInput": false,
    "fieldType": "textarea",
    "dataType": "boolean",
    "maxInput": 92184.9766246,
    "minInput": 122229087.09757656
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PUT api/v1/company/{companyId}/employee-fields/{fieldId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: cumque

fieldId   string   

Example: et

Body Parameters

companyId   string  optional  
parentId   string  optional  
fieldName   string  optional  
isGlobal   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: false

isMandatory   boolean  optional  

Example: true

salarySensitive   boolean  optional  

Example: false

sensitive   boolean  optional  

Example: false

allowNewValue   boolean  optional  

Example: false

observe   boolean  optional  

Example: true

importExcluded   boolean  optional  

Example: false

manualInput   boolean  optional  

Example: false

fieldType   string  optional  

Example: textarea

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: boolean

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 92184.9766246

minInput   number  optional  

Example: 122229087.09758

Revert an extended employee field for a particular company.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company/perspiciatis/employee-fields/quos/revert" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": true,
    \"isMandatory\": false,
    \"salarySensitive\": false,
    \"sensitive\": false,
    \"allowNewValue\": false,
    \"observe\": true,
    \"importExcluded\": true,
    \"manualInput\": true,
    \"fieldType\": \"email\",
    \"dataType\": \"date\",
    \"maxInput\": 6236.8791,
    \"minInput\": 431304.64
}"

const url = new URL(
    "http://localhost/api/v1/company/perspiciatis/employee-fields/quos/revert"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": true,
    "isMandatory": false,
    "salarySensitive": false,
    "sensitive": false,
    "allowNewValue": false,
    "observe": true,
    "importExcluded": true,
    "manualInput": true,
    "fieldType": "email",
    "dataType": "date",
    "maxInput": 6236.8791,
    "minInput": 431304.64
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/company/{companyId}/employee-fields/{fieldId}/revert

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: perspiciatis

fieldId   string   

Example: quos

Body Parameters

companyId   string  optional  
parentId   string  optional  
fieldName   string  optional  
isGlobal   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: true

isMandatory   boolean  optional  

Example: false

salarySensitive   boolean  optional  

Example: false

sensitive   boolean  optional  

Example: false

allowNewValue   boolean  optional  

Example: false

observe   boolean  optional  

Example: true

importExcluded   boolean  optional  

Example: true

manualInput   boolean  optional  

Example: true

fieldType   string  optional  

Example: email

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: date

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 6236.8791

minInput   number  optional  

Example: 431304.64

Revert extended employee fields and custom fields for a particular company.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company/omnis/employee-fields/revert-all" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": true,
    \"isMandatory\": true,
    \"salarySensitive\": false,
    \"sensitive\": true,
    \"allowNewValue\": true,
    \"observe\": false,
    \"importExcluded\": false,
    \"manualInput\": true,
    \"fieldType\": \"password\",
    \"dataType\": \"number\",
    \"maxInput\": 467809963.5234,
    \"minInput\": 27140.42
}"

const url = new URL(
    "http://localhost/api/v1/company/omnis/employee-fields/revert-all"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": true,
    "isMandatory": true,
    "salarySensitive": false,
    "sensitive": true,
    "allowNewValue": true,
    "observe": false,
    "importExcluded": false,
    "manualInput": true,
    "fieldType": "password",
    "dataType": "number",
    "maxInput": 467809963.5234,
    "minInput": 27140.42
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/company/{companyId}/employee-fields/revert-all

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: omnis

Body Parameters

companyId   string  optional  
parentId   string  optional  
fieldName   string  optional  
isGlobal   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: true

isMandatory   boolean  optional  

Example: true

salarySensitive   boolean  optional  

Example: false

sensitive   boolean  optional  

Example: true

allowNewValue   boolean  optional  

Example: true

observe   boolean  optional  

Example: false

importExcluded   boolean  optional  

Example: false

manualInput   boolean  optional  

Example: true

fieldType   string  optional  

Example: password

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: number

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 467809963.5234

minInput   number  optional  

Example: 27140.42

Get an extended employee field for a particular company.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/company/quia/employee-fields/consequuntur" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": false,
    \"isMandatory\": true,
    \"salarySensitive\": false,
    \"sensitive\": true,
    \"allowNewValue\": true,
    \"observe\": false,
    \"importExcluded\": false,
    \"manualInput\": true,
    \"fieldType\": \"date\",
    \"dataType\": \"date\",
    \"maxInput\": 1.662889,
    \"minInput\": 209382.67085644
}"

const url = new URL(
    "http://localhost/api/v1/company/quia/employee-fields/consequuntur"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": false,
    "isMandatory": true,
    "salarySensitive": false,
    "sensitive": true,
    "allowNewValue": true,
    "observe": false,
    "importExcluded": false,
    "manualInput": true,
    "fieldType": "date",
    "dataType": "date",
    "maxInput": 1.662889,
    "minInput": 209382.67085644
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/company/{companyId}/employee-fields/{fieldId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: quia

fieldId   string   

Example: consequuntur

Body Parameters

companyId   string  optional  
parentId   string  optional  
fieldName   string  optional  
isGlobal   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: false

isMandatory   boolean  optional  

Example: true

salarySensitive   boolean  optional  

Example: false

sensitive   boolean  optional  

Example: true

allowNewValue   boolean  optional  

Example: true

observe   boolean  optional  

Example: false

importExcluded   boolean  optional  

Example: false

manualInput   boolean  optional  

Example: true

fieldType   string  optional  

Example: date

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: date

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 1.662889

minInput   number  optional  

Example: 209382.67085644

Get employee fields for a particular company.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/company/autem/employee-fields" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": true,
    \"isMandatory\": true,
    \"salarySensitive\": true,
    \"sensitive\": false,
    \"allowNewValue\": true,
    \"observe\": false,
    \"importExcluded\": false,
    \"manualInput\": false,
    \"fieldType\": \"textarea\",
    \"dataType\": \"number\",
    \"maxInput\": 5035837.37593388,
    \"minInput\": 516398.17847
}"

const url = new URL(
    "http://localhost/api/v1/company/autem/employee-fields"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": true,
    "isMandatory": true,
    "salarySensitive": true,
    "sensitive": false,
    "allowNewValue": true,
    "observe": false,
    "importExcluded": false,
    "manualInput": false,
    "fieldType": "textarea",
    "dataType": "number",
    "maxInput": 5035837.37593388,
    "minInput": 516398.17847
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/company/{companyId}/employee-fields

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: autem

Body Parameters

companyId   string  optional  
parentId   string  optional  
fieldName   string  optional  
isGlobal   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: true

isMandatory   boolean  optional  

Example: true

salarySensitive   boolean  optional  

Example: true

sensitive   boolean  optional  

Example: false

allowNewValue   boolean  optional  

Example: true

observe   boolean  optional  

Example: false

importExcluded   boolean  optional  

Example: false

manualInput   boolean  optional  

Example: false

fieldType   string  optional  

Example: textarea

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: number

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 5035837.3759339

minInput   number  optional  

Example: 516398.17847

Get employee fields for a particular company.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company/eum/employee-fields" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": true,
    \"isMandatory\": false,
    \"salarySensitive\": true,
    \"sensitive\": false,
    \"allowNewValue\": true,
    \"observe\": true,
    \"importExcluded\": true,
    \"manualInput\": true,
    \"fieldType\": \"password\",
    \"dataType\": \"number\",
    \"maxInput\": 6.697714444,
    \"minInput\": 0,
    \"maxLength\": 159.415,
    \"minLength\": 23756247.3,
    \"fieldName\": \"gi\",
    \"combinedFieldIds\": [
        \"excepturi\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company/eum/employee-fields"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": true,
    "isMandatory": false,
    "salarySensitive": true,
    "sensitive": false,
    "allowNewValue": true,
    "observe": true,
    "importExcluded": true,
    "manualInput": true,
    "fieldType": "password",
    "dataType": "number",
    "maxInput": 6.697714444,
    "minInput": 0,
    "maxLength": 159.415,
    "minLength": 23756247.3,
    "fieldName": "gi",
    "combinedFieldIds": [
        "excepturi"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/company/{companyId}/employee-fields

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: eum

Body Parameters

isGlobal   string  optional  
parentId   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean   

Example: true

isMandatory   boolean  optional  

Example: false

salarySensitive   boolean  optional  

Example: true

sensitive   boolean  optional  

Example: false

allowNewValue   boolean  optional  

Example: true

observe   boolean  optional  

Example: true

importExcluded   boolean  optional  

Example: true

manualInput   boolean  optional  

Example: true

fieldType   string  optional  

Example: password

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: number

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

This field is required when dataType is string. Example: 6.697714444

minInput   number  optional  

This field is required when dataType is string. Example: 0

maxLength   number  optional  

Example: 159.415

minLength   number  optional  

Example: 23756247.3

fieldName   string   

Must not be greater than 255 characters. Example: gi

combinedFieldIds   string[]   

Update an employee field for a particular company.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/company/eum/employee-fields/facilis" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isShow\": true,
    \"isMandatory\": false,
    \"salarySensitive\": true,
    \"sensitive\": false,
    \"allowNewValue\": false,
    \"observe\": false,
    \"importExcluded\": true,
    \"manualInput\": true,
    \"fieldType\": \"text\",
    \"dataType\": \"boolean\",
    \"maxInput\": 9480.989652629,
    \"minInput\": 791.6792,
    \"maxLength\": 2.23,
    \"minLength\": 0.1,
    \"combinedFieldIds\": [
        \"magnam\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/company/eum/employee-fields/facilis"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "isShow": true,
    "isMandatory": false,
    "salarySensitive": true,
    "sensitive": false,
    "allowNewValue": false,
    "observe": false,
    "importExcluded": true,
    "manualInput": true,
    "fieldType": "text",
    "dataType": "boolean",
    "maxInput": 9480.989652629,
    "minInput": 791.6792,
    "maxLength": 2.23,
    "minLength": 0.1,
    "combinedFieldIds": [
        "magnam"
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/company/{companyId}/employee-fields/{fieldId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: eum

fieldId   string   

Example: facilis

Body Parameters

isGlobal   string  optional  
parentId   string  optional  
companyId   string  optional  
externalIntegrationId   string  optional  
organizationId   string  optional  
translations   object  optional  

The data must be a valid translation object.

isShow   boolean  optional  

Example: true

isMandatory   boolean  optional  

Example: false

salarySensitive   boolean  optional  

Example: true

sensitive   boolean  optional  

Example: false

allowNewValue   boolean  optional  

Example: false

observe   boolean  optional  

Example: false

importExcluded   boolean  optional  

Example: true

manualInput   boolean  optional  

Example: true

fieldName   string  optional  
fieldType   string  optional  

Example: text

Must be one of:
  • text
  • number
  • password
  • email
  • date
  • checkbox
  • radio
  • select
  • textarea
dataType   string  optional  

Example: boolean

Must be one of:
  • string
  • number
  • date
  • boolean
maxInput   number  optional  

Example: 9480.989652629

minInput   number  optional  

Example: 791.6792

maxLength   number  optional  

Example: 2.23

minLength   number  optional  

Example: 0.1

combinedFieldIds   string[]   

Delete an employee field for a particular company.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/company/optio/employee-fields/quod" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/company/optio/employee-fields/quod"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Request      

DELETE api/v1/company/{companyId}/employee-fields/{fieldId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: optio

fieldId   string   

Example: quod

Field Groups

Create a global field group

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/field-groups" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"quo\"
}"

const url = new URL(
    "http://localhost/api/v1/field-groups"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "quo"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/field-groups

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

groupName   string   

Example: quo

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Fetch all global field groups

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/field-groups" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/field-groups"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/field-groups

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Fetch a global field group by its ID

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/field-groups/consequatur" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/field-groups/consequatur"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/field-groups/{groupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

groupId   string   

Example: consequatur

Update a global field group

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/field-groups/expedita" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"aut\"
}"

const url = new URL(
    "http://localhost/api/v1/field-groups/expedita"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "aut"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/field-groups/{groupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

groupId   string   

Example: expedita

Body Parameters

groupName   string  optional  

Example: aut

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Delete a global field group

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/field-groups/hic" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/field-groups/hic"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Request      

DELETE api/v1/field-groups/{groupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

groupId   string   

Example: hic

Add a field to a global field group

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/field-groups/eaque/add-field" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupId\": \"vel\"
}"

const url = new URL(
    "http://localhost/api/v1/field-groups/eaque/add-field"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupId": "vel"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/field-groups/{employeeFieldId}/add-field

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeFieldId   string   

Example: eaque

Body Parameters

groupId   string   

Example: vel

Move a field from one global field group to another

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/field-groups/veritatis/move-field" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"oldGroupId\": \"autem\",
    \"newGroupId\": \"libero\"
}"

const url = new URL(
    "http://localhost/api/v1/field-groups/veritatis/move-field"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "oldGroupId": "autem",
    "newGroupId": "libero"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/field-groups/{employeeFieldId}/move-field

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeFieldId   string   

Example: veritatis

Body Parameters

oldGroupId   string   

Example: autem

newGroupId   string   

Example: libero

Remove a field from a global field group

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/field-groups/autem/remove-field" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupId\": \"enim\"
}"

const url = new URL(
    "http://localhost/api/v1/field-groups/autem/remove-field"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupId": "enim"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/field-groups/{employeeFieldId}/remove-field

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

employeeFieldId   string   

Example: autem

Body Parameters

groupId   string   

Example: enim

Get fields groups for a particular integration.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/external-integration/temporibus/field-groups" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"et\"
}"

const url = new URL(
    "http://localhost/api/v1/external-integration/temporibus/field-groups"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "et"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/external-integration/{integrationId}/field-groups

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

integrationId   string   

Example: temporibus

Body Parameters

groupName   string  optional  

Example: et

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Customize an existing global field group for a particular integration.

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1/external-integration/repellat/field-groups/quia" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"repellendus\"
}"

const url = new URL(
    "http://localhost/api/v1/external-integration/repellat/field-groups/quia"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "repellendus"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PUT api/v1/external-integration/{integrationId}/field-groups/{groupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

integrationId   string   

Example: repellat

groupId   string   

Example: quia

Body Parameters

groupName   string  optional  

Example: repellendus

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Get a particular field group for a particular integration.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/external-integration/harum/field-groups/inventore" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"qui\"
}"

const url = new URL(
    "http://localhost/api/v1/external-integration/harum/field-groups/inventore"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "qui"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/external-integration/{integrationId}/field-groups/{groupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

integrationId   string   

Example: harum

groupId   string   

Example: inventore

Body Parameters

groupName   string  optional  

Example: qui

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Revert a customized global field group for a particular integration.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/external-integration/tempora/field-groups/sint" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"voluptas\"
}"

const url = new URL(
    "http://localhost/api/v1/external-integration/tempora/field-groups/sint"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "voluptas"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/external-integration/{integrationId}/field-groups/{groupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

integrationId   string   

Example: tempora

groupId   string   

Example: sint

Body Parameters

groupName   string  optional  

Example: voluptas

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Add a field to a particular field group for a particular integration.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/external-integration/quis/field-groups/et/add-field" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupId\": \"est\"
}"

const url = new URL(
    "http://localhost/api/v1/external-integration/quis/field-groups/et/add-field"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupId": "est"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/external-integration/{integrationId}/field-groups/{employeeFieldId}/add-field

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

integrationId   string   

Example: quis

employeeFieldId   string   

Example: et

Body Parameters

groupId   string   

Example: est

Move a field from a field group for a particular integration.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/external-integration/ipsa/field-groups/qui/move-field" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"oldGroupId\": \"similique\",
    \"newGroupId\": \"mollitia\"
}"

const url = new URL(
    "http://localhost/api/v1/external-integration/ipsa/field-groups/qui/move-field"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "oldGroupId": "similique",
    "newGroupId": "mollitia"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/external-integration/{integrationId}/field-groups/{employeeFieldId}/move-field

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

integrationId   string   

Example: ipsa

employeeFieldId   string   

Example: qui

Body Parameters

oldGroupId   string   

Example: similique

newGroupId   string   

Example: mollitia

Remove a field from a field group for a particular integration.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/external-integration/maxime/field-groups/dolore/remove-field" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupId\": \"maxime\"
}"

const url = new URL(
    "http://localhost/api/v1/external-integration/maxime/field-groups/dolore/remove-field"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupId": "maxime"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/external-integration/{integrationId}/field-groups/{employeeFieldId}/remove-field

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

integrationId   string   

Example: maxime

employeeFieldId   string   

Example: dolore

Body Parameters

groupId   string   

Example: maxime

Get fields groups for a particular organization.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/organization/sit/field-groups" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"ipsa\"
}"

const url = new URL(
    "http://localhost/api/v1/organization/sit/field-groups"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "ipsa"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/organization/{organizationId}/field-groups

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: sit

Body Parameters

groupName   string  optional  

Example: ipsa

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Customize an existing global field group for a particular organization.

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1/organization/iusto/field-groups/amet" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"ad\"
}"

const url = new URL(
    "http://localhost/api/v1/organization/iusto/field-groups/amet"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "ad"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PUT api/v1/organization/{organizationId}/field-groups/{groupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: iusto

groupId   string   

Example: amet

Body Parameters

groupName   string  optional  

Example: ad

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Get a particular field group for a particular organization.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/organization/sit/field-groups/non" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"numquam\"
}"

const url = new URL(
    "http://localhost/api/v1/organization/sit/field-groups/non"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "numquam"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/organization/{organizationId}/field-groups/{groupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: sit

groupId   string   

Example: non

Body Parameters

groupName   string  optional  

Example: numquam

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Revert a customized field group for a particular organization.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/organization/sit/field-groups/sunt" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"fugiat\"
}"

const url = new URL(
    "http://localhost/api/v1/organization/sit/field-groups/sunt"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "fugiat"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/organization/{organizationId}/field-groups/{groupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: sit

groupId   string   

Example: sunt

Body Parameters

groupName   string  optional  

Example: fugiat

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Add a field to a particular field group for a particular organization.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/organization/ratione/field-groups/corporis/add-field" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupId\": \"vitae\"
}"

const url = new URL(
    "http://localhost/api/v1/organization/ratione/field-groups/corporis/add-field"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupId": "vitae"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/organization/{organizationId}/field-groups/{employeeFieldId}/add-field

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: ratione

employeeFieldId   string   

Example: corporis

Body Parameters

groupId   string   

Example: vitae

Move a field from one field group to another for a particular organization.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/organization/quis/field-groups/aut/move-field" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"oldGroupId\": \"aspernatur\",
    \"newGroupId\": \"similique\"
}"

const url = new URL(
    "http://localhost/api/v1/organization/quis/field-groups/aut/move-field"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "oldGroupId": "aspernatur",
    "newGroupId": "similique"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/organization/{organizationId}/field-groups/{employeeFieldId}/move-field

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: quis

employeeFieldId   string   

Example: aut

Body Parameters

oldGroupId   string   

Example: aspernatur

newGroupId   string   

Example: similique

Remove a field from a particular field group for a particular organization.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/organization/eius/field-groups/quia/remove-field" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupId\": \"laboriosam\"
}"

const url = new URL(
    "http://localhost/api/v1/organization/eius/field-groups/quia/remove-field"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupId": "laboriosam"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/organization/{organizationId}/field-groups/{employeeFieldId}/remove-field

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

organizationId   string   

Example: eius

employeeFieldId   string   

Example: quia

Body Parameters

groupId   string   

Example: laboriosam

Get fields groups for a particular company.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/company/molestias/field-groups" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"non\"
}"

const url = new URL(
    "http://localhost/api/v1/company/molestias/field-groups"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "non"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/company/{companyId}/field-groups

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: molestias

Body Parameters

groupName   string  optional  

Example: non

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Customize an existing global field group for a particular company.

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1/company/quia/field-groups/aut" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"alias\"
}"

const url = new URL(
    "http://localhost/api/v1/company/quia/field-groups/aut"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "alias"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PUT api/v1/company/{companyId}/field-groups/{groupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: quia

groupId   string   

Example: aut

Body Parameters

groupName   string  optional  

Example: alias

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Show a customized global field group for a particular company.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/company/ipsa/field-groups/quam" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"necessitatibus\"
}"

const url = new URL(
    "http://localhost/api/v1/company/ipsa/field-groups/quam"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "necessitatibus"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/company/{companyId}/field-groups/{groupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: ipsa

groupId   string   

Example: quam

Body Parameters

groupName   string  optional  

Example: necessitatibus

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Revert a customized global field group for a particular company.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/company/dolor/field-groups/nostrum" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupName\": \"et\"
}"

const url = new URL(
    "http://localhost/api/v1/company/dolor/field-groups/nostrum"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupName": "et"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

DELETE api/v1/company/{companyId}/field-groups/{groupId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: dolor

groupId   string   

Example: nostrum

Body Parameters

groupName   string  optional  

Example: et

translations   object  optional  

The data must be a valid translation object.

fields   string  optional  
isGlobal   string  optional  
companyId   string  optional  
integrationId   string  optional  
organizationId   string  optional  

Add a field to a field group for a particular company.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company/corporis/field-groups/rerum/add-field" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupId\": \"dolores\"
}"

const url = new URL(
    "http://localhost/api/v1/company/corporis/field-groups/rerum/add-field"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupId": "dolores"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/company/{companyId}/field-groups/{employeeFieldId}/add-field

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: corporis

employeeFieldId   string   

Example: rerum

Body Parameters

groupId   string   

Example: dolores

Move a field from one field group to another for a particular company.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/company/blanditiis/field-groups/veniam/move-field" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"oldGroupId\": \"cum\",
    \"newGroupId\": \"illo\"
}"

const url = new URL(
    "http://localhost/api/v1/company/blanditiis/field-groups/veniam/move-field"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "oldGroupId": "cum",
    "newGroupId": "illo"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/company/{companyId}/field-groups/{employeeFieldId}/move-field

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: blanditiis

employeeFieldId   string   

Example: veniam

Body Parameters

oldGroupId   string   

Example: cum

newGroupId   string   

Example: illo

Remove a field from a field group for a particular company.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/company/rerum/field-groups/aut/remove-field" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"groupId\": \"eveniet\"
}"

const url = new URL(
    "http://localhost/api/v1/company/rerum/field-groups/aut/remove-field"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "groupId": "eveniet"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/company/{companyId}/field-groups/{employeeFieldId}/remove-field

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

companyId   string   

Example: rerum

employeeFieldId   string   

Example: aut

Body Parameters

groupId   string   

Example: eveniet

Import

Import company details (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/import/company" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"companyId\": \"laboriosam\",
    \"companyIntegrationId\": \"nihil\",
    \"async\": true
}"

const url = new URL(
    "http://localhost/api/v1/import/company"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "companyId": "laboriosam",
    "companyIntegrationId": "nihil",
    "async": true
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/import/company

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

companyId   string   

Example: laboriosam

companyIntegrationId   string   

Example: nihil

async   boolean  optional  

Example: true

Import employees (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/import/employees" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"companyId\": \"aliquid\",
    \"companyIntegrationId\": \"voluptas\",
    \"async\": false
}"

const url = new URL(
    "http://localhost/api/v1/import/employees"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "companyId": "aliquid",
    "companyIntegrationId": "voluptas",
    "async": false
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/import/employees

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

companyId   string   

Example: aliquid

companyIntegrationId   string   

Example: voluptas

async   boolean  optional  

Example: false

Import transactions. (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/import/transactions" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"companyId\": \"iure\",
    \"companyIntegrationId\": \"ipsa\",
    \"period\": \"4957040\"
}"

const url = new URL(
    "http://localhost/api/v1/import/transactions"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "companyId": "iure",
    "companyIntegrationId": "ipsa",
    "period": "4957040"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/import/transactions

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

companyId   string   

Example: iure

companyIntegrationId   string   

Example: ipsa

period   string   

Must match the regex /^[1-9][0-9]{3}(0[1-9]|1[0-2])[0-9]$/. Example: 4957040

Import salary types.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/import/salary-types" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"companyId\": \"temporibus\"
}"

const url = new URL(
    "http://localhost/api/v1/import/salary-types"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "companyId": "temporibus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/import/salary-types

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

companyId   string   

Example: temporibus

Import transactions to the cloud.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/import/cloud/transactions" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/import/cloud/transactions"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/import/cloud/transactions

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Cache

Refresh the cache.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/cache/refresh" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/cache/refresh"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/cache/refresh

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Warm the cache.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/cache/warm" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/cache/warm"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/cache/warm

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Clear the cache.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/cache/clear" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/cache/clear"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/cache/clear

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Real Time

Generate connection token for Centrifugo.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/real-time/connection-token" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/real-time/connection-token"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/real-time/connection-token

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Generate subscription token for Centrifugo.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/real-time/subscription-token" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"channel\": \"reiciendis\"
}"

const url = new URL(
    "http://localhost/api/v1/real-time/subscription-token"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "channel": "reiciendis"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/real-time/subscription-token

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

channel   string   

Example: reiciendis

Abilities

Retrieve specific abilities for a specific role (Stability Score: 0.1)

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/roles/1/specific-abilities" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/roles/1/specific-abilities"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/roles/{role_id}/specific-abilities

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

role_id   integer   

The ID of the role. Example: 1

Attach a specific ability to a role (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/roles/1/specific-abilities/attach" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "http://localhost/api/v1/roles/1/specific-abilities/attach"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/roles/{role_id}/specific-abilities/attach

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

role_id   integer   

The ID of the role. Example: 1

Body Parameters

specific_ability_ids   string[]  optional  

Detach a specific ability to a role (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/roles/1/specific-abilities/detach" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "http://localhost/api/v1/roles/1/specific-abilities/detach"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/roles/{role_id}/specific-abilities/detach

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

role_id   integer   

The ID of the role. Example: 1

Body Parameters

specific_ability_ids   string[]  optional  

Retrieve all specific abilities (Stability Score: 0.1)

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/specific-abilities" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/specific-abilities"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/specific-abilities

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Ability

Allow an ability to a group. (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/abilities/ability-group/officiis/allow" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"ability\": \"update\",
    \"entity\": \"App\\\\DataLayer\\\\Models\\\\PayCodeVariable\",
    \"entityId\": \"corrupti\"
}"

const url = new URL(
    "http://localhost/api/v1/abilities/ability-group/officiis/allow"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "ability": "update",
    "entity": "App\\DataLayer\\Models\\PayCodeVariable",
    "entityId": "corrupti"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/abilities/ability-group/{abilityGroupId}/allow

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

abilityGroupId   string   

Example: officiis

Body Parameters

ability   string   

Example: update

Must be one of:
  • create
  • read
  • update
  • delete
entity   string   

Example: App\DataLayer\Models\PayCodeVariable

Must be one of:
  • App\DataLayer\Models\Change
  • App\DataLayer\Models\ChangeHistory
  • App\DataLayer\Models\Company
  • App\DataLayer\Models\CompanyField
  • App\DataLayer\Models\CompanyFieldMap
  • App\DataLayer\Models\CompanyIntegration
  • App\DataLayer\Models\CompanyIntegrationsMapping
  • App\DataLayer\Models\CompanySettings
  • App\DataLayer\Models\EmpPermission
  • App\DataLayer\Models\EmpPermissionRule
  • App\DataLayer\Models\Employee
  • App\DataLayer\Models\EmployeeField
  • App\DataLayer\Models\EmployeeFieldChange
  • App\DataLayer\Models\EmployeeFieldMap
  • App\DataLayer\Models\EmploymentChange
  • App\DataLayer\Models\EmploymentHistory
  • App\DataLayer\Models\ExternalCompanyField
  • App\DataLayer\Models\ExternalEmployeeField
  • App\DataLayer\Models\ExternalIntegration
  • App\DataLayer\Models\ExternalSalaryType
  • App\DataLayer\Models\FieldGroup
  • App\DataLayer\Models\FieldValueMatrix
  • App\DataLayer\Models\FileUpload
  • App\DataLayer\Models\IntegrationType
  • App\DataLayer\Models\Locale
  • App\DataLayer\Models\Menu
  • App\DataLayer\Models\Notification
  • App\DataLayer\Models\OrgIntegrationsMapping
  • App\DataLayer\Models\Organization
  • App\DataLayer\Models\PayCode
  • App\DataLayer\Models\PayCodeChange
  • App\DataLayer\Models\PayCodeGroup
  • App\DataLayer\Models\PayCodeHistory
  • App\DataLayer\Models\PayCodeMapping
  • App\DataLayer\Models\PayCodeType
  • App\DataLayer\Models\PayCodeVariable
  • App\DataLayer\Models\PersonalCardProfile
  • App\DataLayer\Models\PersonalCardProfileTab
  • App\DataLayer\Models\PersonalCardProfileTabGrid
  • App\DataLayer\Models\Relative
  • App\DataLayer\Models\RelativeChange
  • App\DataLayer\Models\RelativeChangeHistory
  • App\DataLayer\Models\RoleEmpPermission
  • App\DataLayer\Models\SalaryRule
  • App\DataLayer\Models\SalaryTypeMap
  • App\DataLayer\Models\SalaryWarning
  • App\DataLayer\Models\StorageStructure
  • App\DataLayer\Models\Transaction
  • App\DataLayer\Models\User
  • App\DataLayer\Models\VariableType
entityId   string  optional  

Example: corrupti

Forbid an ability to a group. (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/abilities/ability-group/in/forbid" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"ability\": \"update\",
    \"entity\": \"App\\\\DataLayer\\\\Models\\\\RoleEmpPermission\",
    \"entityId\": \"omnis\"
}"

const url = new URL(
    "http://localhost/api/v1/abilities/ability-group/in/forbid"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "ability": "update",
    "entity": "App\\DataLayer\\Models\\RoleEmpPermission",
    "entityId": "omnis"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/abilities/ability-group/{abilityGroupId}/forbid

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

abilityGroupId   string   

Example: in

Body Parameters

ability   string   

Example: update

Must be one of:
  • create
  • read
  • update
  • delete
entity   string   

Example: App\DataLayer\Models\RoleEmpPermission

Must be one of:
  • App\DataLayer\Models\Change
  • App\DataLayer\Models\ChangeHistory
  • App\DataLayer\Models\Company
  • App\DataLayer\Models\CompanyField
  • App\DataLayer\Models\CompanyFieldMap
  • App\DataLayer\Models\CompanyIntegration
  • App\DataLayer\Models\CompanyIntegrationsMapping
  • App\DataLayer\Models\CompanySettings
  • App\DataLayer\Models\EmpPermission
  • App\DataLayer\Models\EmpPermissionRule
  • App\DataLayer\Models\Employee
  • App\DataLayer\Models\EmployeeField
  • App\DataLayer\Models\EmployeeFieldChange
  • App\DataLayer\Models\EmployeeFieldMap
  • App\DataLayer\Models\EmploymentChange
  • App\DataLayer\Models\EmploymentHistory
  • App\DataLayer\Models\ExternalCompanyField
  • App\DataLayer\Models\ExternalEmployeeField
  • App\DataLayer\Models\ExternalIntegration
  • App\DataLayer\Models\ExternalSalaryType
  • App\DataLayer\Models\FieldGroup
  • App\DataLayer\Models\FieldValueMatrix
  • App\DataLayer\Models\FileUpload
  • App\DataLayer\Models\IntegrationType
  • App\DataLayer\Models\Locale
  • App\DataLayer\Models\Menu
  • App\DataLayer\Models\Notification
  • App\DataLayer\Models\OrgIntegrationsMapping
  • App\DataLayer\Models\Organization
  • App\DataLayer\Models\PayCode
  • App\DataLayer\Models\PayCodeChange
  • App\DataLayer\Models\PayCodeGroup
  • App\DataLayer\Models\PayCodeHistory
  • App\DataLayer\Models\PayCodeMapping
  • App\DataLayer\Models\PayCodeType
  • App\DataLayer\Models\PayCodeVariable
  • App\DataLayer\Models\PersonalCardProfile
  • App\DataLayer\Models\PersonalCardProfileTab
  • App\DataLayer\Models\PersonalCardProfileTabGrid
  • App\DataLayer\Models\Relative
  • App\DataLayer\Models\RelativeChange
  • App\DataLayer\Models\RelativeChangeHistory
  • App\DataLayer\Models\RoleEmpPermission
  • App\DataLayer\Models\SalaryRule
  • App\DataLayer\Models\SalaryTypeMap
  • App\DataLayer\Models\SalaryWarning
  • App\DataLayer\Models\StorageStructure
  • App\DataLayer\Models\Transaction
  • App\DataLayer\Models\User
  • App\DataLayer\Models\VariableType
entityId   string  optional  

Example: omnis

Assign a role to a user. (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/abilities/roles/1/assign" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"nihil\",
    \"title\": \"est\"
}"

const url = new URL(
    "http://localhost/api/v1/abilities/roles/1/assign"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "nihil",
    "title": "est"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/abilities/roles/{roleId}/assign

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

roleId   integer   

Example: 1

Body Parameters

name   string  optional  

Example: nihil

title   string  optional  

Example: est

Retract a role from a user. (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/abilities/roles/1/retract" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"dolores\",
    \"title\": \"animi\"
}"

const url = new URL(
    "http://localhost/api/v1/abilities/roles/1/retract"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "dolores",
    "title": "animi"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/abilities/roles/{roleId}/retract

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

roleId   integer   

Example: 1

Body Parameters

name   string  optional  

Example: dolores

title   string  optional  

Example: animi

Assign a group to a role. (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/abilities/roles/1/assign-group" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"abilityGroupId\": 7
}"

const url = new URL(
    "http://localhost/api/v1/abilities/roles/1/assign-group"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "abilityGroupId": 7
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/abilities/roles/{roleId}/assign-group

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

roleId   integer   

Example: 1

Body Parameters

abilityGroupId   integer   

Example: 7

Retract a group from a role. (Stability Score: 0.1)

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/abilities/roles/1/retract-group" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"abilityGroupId\": 15
}"

const url = new URL(
    "http://localhost/api/v1/abilities/roles/1/retract-group"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "abilityGroupId": 15
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/abilities/roles/{roleId}/retract-group

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

roleId   integer   

Example: 1

Body Parameters

abilityGroupId   integer   

Example: 15

Get all types of entities (Stability Score: 0.1)

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/abilities/entity-types" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/entity-types"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/abilities/entity-types

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Endpoints

All other endpoints

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/abilities/ability-group/search" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/ability-group/search"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Creates a batch of new resources in a transaction-safe way.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/abilities/ability-group/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": []
}"

const url = new URL(
    "http://localhost/api/v1/abilities/ability-group/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/abilities/ability-group/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

resources   object   

Update a batch of resources in a transaction-safe way.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/abilities/ability-group/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": []
}"

const url = new URL(
    "http://localhost/api/v1/abilities/ability-group/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": []
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/abilities/ability-group/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

resources   object   

Deletes a batch of resources in a transaction-safe way.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/abilities/ability-group/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/ability-group/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Request      

DELETE api/v1/abilities/ability-group/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Fetches the list of resources.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/abilities/ability-group" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/ability-group"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/abilities/ability-group

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Creates new resource in a transaction-safe way.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/abilities/ability-group" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/ability-group"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/abilities/ability-group

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Fetches resource.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/abilities/ability-group/nesciunt" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/ability-group/nesciunt"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/abilities/ability-group/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the ability group. Example: nesciunt

Update a resource in a transaction-safe way.

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1/abilities/ability-group/eos" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/ability-group/eos"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Request      

PUT api/v1/abilities/ability-group/{id}

PATCH api/v1/abilities/ability-group/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the ability group. Example: eos

Deletes a resource.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/abilities/ability-group/autem" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/ability-group/autem"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Request      

DELETE api/v1/abilities/ability-group/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the ability group. Example: autem

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/abilities/roles/search" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/roles/search"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Creates a batch of new resources in a transaction-safe way.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/abilities/roles/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": []
}"

const url = new URL(
    "http://localhost/api/v1/abilities/roles/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/abilities/roles/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

resources   object   

Update a batch of resources in a transaction-safe way.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/abilities/roles/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": []
}"

const url = new URL(
    "http://localhost/api/v1/abilities/roles/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": []
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/abilities/roles/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

resources   object   

Deletes a batch of resources in a transaction-safe way.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/abilities/roles/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/roles/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Request      

DELETE api/v1/abilities/roles/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Fetches the list of resources.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/abilities/roles" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/roles"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/abilities/roles

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Creates new resource in a transaction-safe way.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/abilities/roles" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/roles"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/abilities/roles

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Fetches resource.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/abilities/roles/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/roles/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/abilities/roles/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the role. Example: 1

Update a resource in a transaction-safe way.

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1/abilities/roles/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/roles/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Request      

PUT api/v1/abilities/roles/{id}

PATCH api/v1/abilities/roles/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the role. Example: 1

Deletes a resource.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/abilities/roles/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/abilities/roles/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Request      

DELETE api/v1/abilities/roles/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the role. Example: 1

Orion Endpoints

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/orion/transactions/search" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/orion/transactions/search"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Creates a batch of new resources in a transaction-safe way.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/orion/transactions/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": []
}"

const url = new URL(
    "http://localhost/api/v1/orion/transactions/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/orion/transactions/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

resources   object   

Update a batch of resources in a transaction-safe way.

requires authentication

Example request:
curl --request PATCH \
    "http://localhost/api/v1/orion/transactions/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"resources\": []
}"

const url = new URL(
    "http://localhost/api/v1/orion/transactions/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resources": []
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

PATCH api/v1/orion/transactions/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

resources   object   

Deletes a batch of resources in a transaction-safe way.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/orion/transactions/batch" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/orion/transactions/batch"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Request      

DELETE api/v1/orion/transactions/batch

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Fetches the list of resources.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/orion/transactions" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/orion/transactions"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/orion/transactions

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Creates new resource in a transaction-safe way.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/orion/transactions" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/orion/transactions"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Request      

POST api/v1/orion/transactions

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Fetches resource.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/orion/transactions/amet" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/orion/transactions/amet"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/orion/transactions/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the transaction. Example: amet

Update a resource in a transaction-safe way.

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1/orion/transactions/repellat" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/orion/transactions/repellat"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Request      

PUT api/v1/orion/transactions/{id}

PATCH api/v1/orion/transactions/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the transaction. Example: repellat

Deletes a resource.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1/orion/transactions/et" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/orion/transactions/et"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Request      

DELETE api/v1/orion/transactions/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the transaction. Example: et

Uncategorized Endpoints

All other endpoints

GET api/octane-firebase-concurrently

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/octane-firebase-concurrently" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/octane-firebase-concurrently"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/octane-firebase-concurrently

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

GET api/v1/user/roles

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1/user/roles" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1/user/roles"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/user/roles

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

POST api/v1/users

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1/users" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"ut\",
    \"email\": \"bschaefer@example.net\"
}"

const url = new URL(
    "http://localhost/api/v1/users"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "ut",
    "email": "bschaefer@example.net"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Request      

POST api/v1/users

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

name   string   

Example: ut

email   string   

Must be a valid email address. Example: bschaefer@example.net