User Management API

curl -X GET 'https://pilot-root.1kosmos.net/users-mgmt/healthz' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

curl -X GET 'https://pilot-root.1kosmos.net/users-mgmt/healthz' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/healthz", {
  method: "GET",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/users-mgmt/healthz",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

{
  "statusCode": 400,
  "error": "Bad Request",
  "message": "Validation error"
}

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/admin/changepassword' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/admin/changepassword", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/admin/changepassword",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/authenticate' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": {"authModule": "string", "authModules": ["string"], "username": "string", "password": "string", "ktoken": "string", "otp": "string", "pin": "string", "referrerPublicKey": "string", "scep": true, "serviceName": "string"}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/authenticate", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": {
      "authModule": "string",
      "authModules": [
        "string"
      ],
      "username": "string",
      "password": "string",
      "ktoken": "string",
      "otp": "string",
      "pin": "string",
      "referrerPublicKey": "string",
      "scep": true,
      "serviceName": "string"
    }
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/authenticate",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": {
        "authModule": "string",
        "authModules": [
          "string"
        ],
        "username": "string",
        "password": "string",
        "ktoken": "string",
        "otp": "string",
        "pin": "string",
        "referrerPublicKey": "string",
        "scep": true,
        "serviceName": "string"
      }
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/changepassword' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/changepassword", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/changepassword",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/fetch_single_user_by_username' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"authModule": "xxxxxxxxxxxxxxxxxxxxxxxx", "username": "", "attributes": [], "checkAliases": false, "do_transformation": true, "check_locks": true, "load_props": true, "includeProperties": false}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/fetch_single_user_by_username", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "authModule": "xxxxxxxxxxxxxxxxxxxxxxxx",
    "username": "",
    "attributes": [],
    "checkAliases": false,
    "do_transformation": true,
    "check_locks": true,
    "load_props": true,
    "includeProperties": false
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/fetch_single_user_by_username",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "authModule": "xxxxxxxxxxxxxxxxxxxxxxxx",
      "username": "",
      "attributes": [],
      "checkAliases": false,
      "do_transformation": true,
      "check_locks": true,
      "load_props": true,
      "includeProperties": false
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/scepcredentials' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"authModule": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "username": "xxxxxxxxxx"}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/scepcredentials", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "authModule": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "username": "xxxxxxxxxx"
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/scepcredentials",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "authModule": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
      "username": "xxxxxxxxxx"
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/validate_user_password' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/validate_user_password", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/validate_user_password",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/verify_user_ktoken' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/verify_user_ktoken", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/verify_user_ktoken",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/users/count' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"authModule": "xxxxxxxxxxxxxxxxxxxxxxxx", "query": {}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/users/count", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "authModule": "xxxxxxxxxxxxxxxxxxxxxxxx",
    "query": {}
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/users/count",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "authModule": "xxxxxxxxxxxxxxxxxxxxxxxx",
      "query": {}
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/users/fetch' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"authModule": "xxxxxxxxxxxxxxxxxxxxxxxx", "pIndex": 0, "pSize": 25, "query": {}, "attributes": [], "includeBrokerConnectionId": [], "excludeBrokerConnectionId": [], "checkAliases": false, "includeProperties": false}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/users/fetch", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "authModule": "xxxxxxxxxxxxxxxxxxxxxxxx",
    "pIndex": 0,
    "pSize": 25,
    "query": {},
    "attributes": [],
    "includeBrokerConnectionId": [],
    "excludeBrokerConnectionId": [],
    "checkAliases": false,
    "includeProperties": false
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/users/fetch",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "authModule": "xxxxxxxxxxxxxxxxxxxxxxxx",
      "pIndex": 0,
      "pSize": 25,
      "query": {},
      "attributes": [],
      "includeBrokerConnectionId": [],
      "excludeBrokerConnectionId": [],
      "checkAliases": false,
      "includeProperties": false
    },
)
print(res.json())

curl -X PUT 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/users/create' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"authModule": "xxxxxxxxxxxxxxxxxxxxxxxx", "users": [{"username": "string", "password": "string", "status": "string", "firstname": "string", "middlename": "string-optional", "lastname": "string", "email1": "string", "email1_verified": true, "email2": "string-optional", "email2_verified": true, "phone1": "string-only-digits", "phone1_verified": true, "address": {}, "address_verified": true, "disabled": false, "idpId": "string"}]}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/users/create", {
  method: "PUT",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "authModule": "xxxxxxxxxxxxxxxxxxxxxxxx",
    "users": [
      {
        "username": "string",
        "password": "string",
        "status": "string",
        "firstname": "string",
        "middlename": "string-optional",
        "lastname": "string",
        "email1": "string",
        "email1_verified": true,
        "email2": "string-optional",
        "email2_verified": true,
        "phone1": "string-only-digits",
        "phone1_verified": true,
        "address": {},
        "address_verified": true,
        "disabled": false,
        "idpId": "string"
      }
    ]
  })
});
const data = await res.json();

import requests

res = requests.put(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/users/create",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "authModule": "xxxxxxxxxxxxxxxxxxxxxxxx",
      "users": [
        {
          "username": "string",
          "password": "string",
          "status": "string",
          "firstname": "string",
          "middlename": "string-optional",
          "lastname": "string",
          "email1": "string",
          "email1_verified": true,
          "email2": "string-optional",
          "email2_verified": true,
          "phone1": "string-only-digits",
          "phone1_verified": true,
          "address": {},
          "address_verified": true,
          "disabled": false,
          "idpId": "string"
        }
      ]
    },
)
print(res.json())

curl -X PATCH 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/update' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"authModule": "xxxxxxxxxxxxxxxxxxxxxxxx", "username": "xxxxx", "status": "xxxxxx", "firstname": "xxxxxxxx", "middlename": "xxxxxxxx", "lastname": "xxxxxxxx", "email1": "xxxxx@xxxxxxxx.xxx", "email1_verified": true, "email2": "xxxxx@xxxxxxxx.xxx", "email2_verified": true, "phone1": "xxxxxxxxxx", "phone1_verified": true, "address": {}, "address_verified": false, "disabled": false}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/update", {
  method: "PATCH",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "authModule": "xxxxxxxxxxxxxxxxxxxxxxxx",
    "username": "xxxxx",
    "status": "xxxxxx",
    "firstname": "xxxxxxxx",
    "middlename": "xxxxxxxx",
    "lastname": "xxxxxxxx",
    "email1": "xxxxx@xxxxxxxx.xxx",
    "email1_verified": true,
    "email2": "xxxxx@xxxxxxxx.xxx",
    "email2_verified": true,
    "phone1": "xxxxxxxxxx",
    "phone1_verified": true,
    "address": {},
    "address_verified": false,
    "disabled": false
  })
});
const data = await res.json();

import requests

res = requests.patch(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/update",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "authModule": "xxxxxxxxxxxxxxxxxxxxxxxx",
      "username": "xxxxx",
      "status": "xxxxxx",
      "firstname": "xxxxxxxx",
      "middlename": "xxxxxxxx",
      "lastname": "xxxxxxxx",
      "email1": "xxxxx@xxxxxxxx.xxx",
      "email1_verified": true,
      "email2": "xxxxx@xxxxxxxx.xxx",
      "email2_verified": true,
      "phone1": "xxxxxxxxxx",
      "phone1_verified": true,
      "address": {},
      "address_verified": false,
      "disabled": false
    },
)
print(res.json())

curl -X GET 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx", {
  method: "GET",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X GET 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/pwd-policy' \
  -H 'requestid: <ecdsa-requestid>'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/pwd-policy", {
  method: "GET",
  headers: {
    "requestid": "<ecdsa-requestid>"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/pwd-policy",
    headers={
        "requestid": "<ecdsa-requestid>"
    }
)
print(res.json())

curl -X GET 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/test-connection' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/test-connection", {
  method: "GET",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/test-connection",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/update-hosts-status' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": {"hosts": {"attempts": [{"host": {"server": "ldap.example.com", "port": "389"}, "status": "failed", "ts": "2025-12-05T10:30:00Z"}]}, "app_name": "My Application", "app_id": "app-123456"}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/update-hosts-status", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": {
      "hosts": {
        "attempts": [
          {
            "host": {
              "server": "ldap.example.com",
              "port": "389"
            },
            "status": "failed",
            "ts": "2025-12-05T10:30:00Z"
          }
        ]
      },
      "app_name": "My Application",
      "app_id": "app-123456"
    }
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxxxxxxxxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/update-hosts-status",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": {
        "hosts": {
          "attempts": [
            {
              "host": {
                "server": "ldap.example.com",
                "port": "389"
              },
              "status": "failed",
              "ts": "2025-12-05T10:30:00Z"
            }
          ]
        },
        "app_name": "My Application",
        "app_id": "app-123456"
      }
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/modules/fetch' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/modules/fetch", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({})
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/modules/fetch",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={},
)
print(res.json())

curl -X PUT 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/create' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/create", {
  method: "PUT",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
  })
});
const data = await res.json();

import requests

res = requests.put(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/create",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
    },
)
print(res.json())

curl -X PATCH 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx", {
  method: "PATCH",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
  })
});
const data = await res.json();

import requests

res = requests.patch(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
    },
)
print(res.json())

curl -X DELETE 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx", {
  method: "DELETE",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.delete(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X GET 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attribute/xxxxxxxxxxxxxxxxxxxxxxxx/attributes' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attribute/xxxxxxxxxxxxxxxxxxxxxxxx/attributes", {
  method: "GET",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attribute/xxxxxxxxxxxxxxxxxxxxxxxx/attributes",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X GET 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attributes?moduleId=xxxxxxxxxxxxxxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attributes?moduleId=xxxxxxxxxxxxxxxxxxxxxxxx", {
  method: "GET",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attributes?moduleId=xxxxxxxxxxxxxxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/directoryattributes?moduleId=xxxxxxxxxxxxxxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"pIndex": 0, "pSize": 25}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/directoryattributes?moduleId=xxxxxxxxxxxxxxxxxxxxxxxx", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "pIndex": 0,
    "pSize": 25
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/directoryattributes?moduleId=xxxxxxxxxxxxxxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "pIndex": 0,
      "pSize": 25
    },
)
print(res.json())

curl -X PUT 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attributes?moduleId=xxxxxxxxxxxxxxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"attributes": [{"name": "xxxx", "attribute": "xxxx"}]}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attributes?moduleId=xxxxxxxxxxxxxxxxxxxxxxxx", {
  method: "PUT",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "attributes": [
      {
        "name": "xxxx",
        "attribute": "xxxx"
      }
    ]
  })
});
const data = await res.json();

import requests

res = requests.put(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attributes?moduleId=xxxxxxxxxxxxxxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "attributes": [
        {
          "name": "xxxx",
          "attribute": "xxxx"
        }
      ]
    },
)
print(res.json())

curl -X PATCH 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attribute/xxxxxxxxxxxxxxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"name": "xxxx", "attribute": "xxxx"}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attribute/xxxxxxxxxxxxxxxxxxxxxxxx", {
  method: "PATCH",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "name": "xxxx",
    "attribute": "xxxx"
  })
});
const data = await res.json();

import requests

res = requests.patch(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attribute/xxxxxxxxxxxxxxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "name": "xxxx",
      "attribute": "xxxx"
    },
)
print(res.json())

curl -X PATCH 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attributes' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"attributes": [{"id": "xxxx", "name": "xxxx", "attribute": "xxxx"}]}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attributes", {
  method: "PATCH",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "attributes": [
      {
        "id": "xxxx",
        "name": "xxxx",
        "attribute": "xxxx"
      }
    ]
  })
});
const data = await res.json();

import requests

res = requests.patch(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attributes",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "attributes": [
        {
          "id": "xxxx",
          "name": "xxxx",
          "attribute": "xxxx"
        }
      ]
    },
)
print(res.json())

curl -X DELETE 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attribute/xxxxxxxxxxxxxxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attribute/xxxxxxxxxxxxxxxxxxxxxxxx", {
  method: "DELETE",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.delete(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/attribute/xxxxxxxxxxxxxxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/systemuser/authenticate' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/systemuser/authenticate", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/systemuser/authenticate",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/systemuser/changepassword' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/systemuser/changepassword", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/systemuser/changepassword",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/systemusers/fetch' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"pIndex": 0, "pSize": 25, "query": {}, "attributes": [], "authModule": "xxxxxxxxxxx"}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/systemusers/fetch", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "pIndex": 0,
    "pSize": 25,
    "query": {},
    "attributes": [],
    "authModule": "xxxxxxxxxxx"
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/systemusers/fetch",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "pIndex": 0,
      "pSize": 25,
      "query": {},
      "attributes": [],
      "authModule": "xxxxxxxxxxx"
    },
)
print(res.json())

curl -X PUT 'https://pilot-root.1kosmos.net/users-mgmt/systemuser' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/systemuser", {
  method: "PUT",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
  })
});
const data = await res.json();

import requests

res = requests.put(
    "https://pilot-root.1kosmos.net/users-mgmt/systemuser",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
    },
)
print(res.json())

curl -X PATCH 'https://pilot-root.1kosmos.net/users-mgmt/systemuser/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"tenantId": "xxxxxxxxxx", "status": "xxxxxx", "firstname": "xxxxxxxx", "middlename": "xxxxxxxx", "lastname": "xxxxxxxx", "email1": "xxxxx@xxxxxxxx.xxx", "email1_verified": true, "email2": "xxxxx@xxxxxxxx.xxx", "email2_verified": true, "phone1": "xxxxxxxxxx", "phone1_verified": true, "address": {}, "address_verified": false, "disabled": false, "roleValue": "xxxxxx"}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/systemuser/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", {
  method: "PATCH",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "tenantId": "xxxxxxxxxx",
    "status": "xxxxxx",
    "firstname": "xxxxxxxx",
    "middlename": "xxxxxxxx",
    "lastname": "xxxxxxxx",
    "email1": "xxxxx@xxxxxxxx.xxx",
    "email1_verified": true,
    "email2": "xxxxx@xxxxxxxx.xxx",
    "email2_verified": true,
    "phone1": "xxxxxxxxxx",
    "phone1_verified": true,
    "address": {},
    "address_verified": false,
    "disabled": false,
    "roleValue": "xxxxxx"
  })
});
const data = await res.json();

import requests

res = requests.patch(
    "https://pilot-root.1kosmos.net/users-mgmt/systemuser/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "tenantId": "xxxxxxxxxx",
      "status": "xxxxxx",
      "firstname": "xxxxxxxx",
      "middlename": "xxxxxxxx",
      "lastname": "xxxxxxxx",
      "email1": "xxxxx@xxxxxxxx.xxx",
      "email1_verified": true,
      "email2": "xxxxx@xxxxxxxx.xxx",
      "email2_verified": true,
      "phone1": "xxxxxxxxxx",
      "phone1_verified": true,
      "address": {},
      "address_verified": false,
      "disabled": false,
      "roleValue": "xxxxxx"
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/behavior_auth/random_phrase/fetch' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": {"jwt": "string", "language": "en"}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/behavior_auth/random_phrase/fetch", {
  method: "POST",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": {
      "jwt": "string",
      "language": "en"
    }
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/behavior_auth/random_phrase/fetch",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": {
        "jwt": "string",
        "language": "en"
      }
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/behavior_auth/register' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": {"authModule": "string", "username": "string", "phrase": "string", "pattern": "string", "jwt": "string", "user_token": "string", "eventInfo": {"clientIp": "string", "userAgent": "string"}}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/behavior_auth/register", {
  method: "POST",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": {
      "authModule": "string",
      "username": "string",
      "phrase": "string",
      "pattern": "string",
      "jwt": "string",
      "user_token": "string",
      "eventInfo": {
        "clientIp": "string",
        "userAgent": "string"
      }
    }
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/behavior_auth/register",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": {
        "authModule": "string",
        "username": "string",
        "phrase": "string",
        "pattern": "string",
        "jwt": "string",
        "user_token": "string",
        "eventInfo": {
          "clientIp": "string",
          "userAgent": "string"
        }
      }
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/behavior_auth/validate' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": {"authModule": "string", "username": "string", "pattern": "string", "eventInfo": {"clientIp": "string", "userAgent": "string"}}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/behavior_auth/validate", {
  method: "POST",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": {
      "authModule": "string",
      "username": "string",
      "pattern": "string",
      "eventInfo": {
        "clientIp": "string",
        "userAgent": "string"
      }
    }
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/behavior_auth/validate",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": {
        "authModule": "string",
        "username": "string",
        "pattern": "string",
        "eventInfo": {
          "clientIp": "string",
          "userAgent": "string"
        }
      }
    },
)
print(res.json())

curl -X DELETE 'https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/behavior_auth/deregister' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": {"authModule": "string", "username": "string", "jwt": "string", "eventInfo": {"clientIp": "string", "userAgent": "string", "initiatedBy": "string"}}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/behavior_auth/deregister", {
  method: "DELETE",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": {
      "authModule": "string",
      "username": "string",
      "jwt": "string",
      "eventInfo": {
        "clientIp": "string",
        "userAgent": "string",
        "initiatedBy": "string"
      }
    }
  })
});
const data = await res.json();

import requests

res = requests.delete(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/behavior_auth/deregister",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": {
        "authModule": "string",
        "username": "string",
        "jwt": "string",
        "eventInfo": {
          "clientIp": "string",
          "userAgent": "string",
          "initiatedBy": "string"
        }
      }
    },
)
print(res.json())

curl -X GET 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/broker/fetch' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/broker/fetch", {
  method: "GET",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/broker/fetch",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X PATCH 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/broker/changestatus' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"uid": "xxxxxxxxxxxxxxxxxxxxxxxx", "enabled": true}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/broker/changestatus", {
  method: "PATCH",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "uid": "xxxxxxxxxxxxxxxxxxxxxxxx",
    "enabled": true
  })
});
const data = await res.json();

import requests

res = requests.patch(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/broker/changestatus",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "uid": "xxxxxxxxxxxxxxxxxxxxxxxx",
      "enabled": true
    },
)
print(res.json())

curl -X PATCH 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/broker/update' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"uid": "xxxxxxxxxxxxxxxxxxxxxxxx", "name": "xxxxxx"}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/broker/update", {
  method: "PATCH",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "uid": "xxxxxxxxxxxxxxxxxxxxxxxx",
    "name": "xxxxxx"
  })
});
const data = await res.json();

import requests

res = requests.patch(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/broker/update",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "uid": "xxxxxxxxxxxxxxxxxxxxxxxx",
      "name": "xxxxxx"
    },
)
print(res.json())

curl -X DELETE 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/broker/xxxxxxxxxxxxxxxxxxxxxxxx' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/broker/xxxxxxxxxxxxxxxxxxxxxxxx", {
  method: "DELETE",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.delete(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/module/xxxxxxxxxxxxxxxxxxxxxxxx/broker/xxxxxxxxxxxxxxxxxxxxxxxx",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/status' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"username": "xxxxxx"}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/status", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "username": "xxxxxx"
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/status",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "username": "xxxxxx"
    },
)
print(res.json())

curl -X PUT 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/lock' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"username": "xxxxxx", "reason": {"reasonCode": 0, "message": "Admin Action"}, "initiatedby": "xxxxxxxx"}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/lock", {
  method: "PUT",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "username": "xxxxxx",
    "reason": {
      "reasonCode": 0,
      "message": "Admin Action"
    },
    "initiatedby": "xxxxxxxx"
  })
});
const data = await res.json();

import requests

res = requests.put(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/lock",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "username": "xxxxxx",
      "reason": {
        "reasonCode": 0,
        "message": "Admin Action"
      },
      "initiatedby": "xxxxxxxx"
    },
)
print(res.json())

curl -X PUT 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/unlock' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"username": "xxxxxx", "reason": {"reasonCode": 0, "message": "Admin Action"}, "initiatedby": "xxxxxxxx"}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/unlock", {
  method: "PUT",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "username": "xxxxxx",
    "reason": {
      "reasonCode": 0,
      "message": "Admin Action"
    },
    "initiatedby": "xxxxxxxx"
  })
});
const data = await res.json();

import requests

res = requests.put(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/unlock",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "username": "xxxxxx",
      "reason": {
        "reasonCode": 0,
        "message": "Admin Action"
      },
      "initiatedby": "xxxxxxxx"
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/v2/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/lock/status' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"userId": "xxxxxx"}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/v2/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/lock/status", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "userId": "xxxxxx"
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/v2/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/lock/status",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "userId": "xxxxxx"
    },
)
print(res.json())

curl -X PUT 'https://pilot-root.1kosmos.net/users-mgmt/v2/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/lock' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"userId": "xxxxxx", "message": "Admin Action", "initiatedby": "xxxxxxxx", "expiryInMunites": 30}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/v2/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/lock", {
  method: "PUT",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "userId": "xxxxxx",
    "message": "Admin Action",
    "initiatedby": "xxxxxxxx",
    "expiryInMunites": 30
  })
});
const data = await res.json();

import requests

res = requests.put(
    "https://pilot-root.1kosmos.net/users-mgmt/v2/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/lock",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "userId": "xxxxxx",
      "message": "Admin Action",
      "initiatedby": "xxxxxxxx",
      "expiryInMunites": 30
    },
)
print(res.json())

curl -X PUT 'https://pilot-root.1kosmos.net/users-mgmt/v2/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/unlock' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"userId": "xxxxxx", "message": "Admin Action", "initiatedby": "xxxxxxxx"}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/v2/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/unlock", {
  method: "PUT",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "userId": "xxxxxx",
    "message": "Admin Action",
    "initiatedby": "xxxxxxxx"
  })
});
const data = await res.json();

import requests

res = requests.put(
    "https://pilot-root.1kosmos.net/users-mgmt/v2/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user/unlock",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "userId": "xxxxxx",
      "message": "Admin Action",
      "initiatedby": "xxxxxxxx"
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/user_pin/register' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": {"user": {"username": "string", "authModule": "string"}, "pin": "string", "jwt": "string"}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/user_pin/register", {
  method: "POST",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": {
      "user": {
        "username": "string",
        "authModule": "string"
      },
      "pin": "string",
      "jwt": "string"
    }
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/user_pin/register",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": {
        "user": {
          "username": "string",
          "authModule": "string"
        },
        "pin": "string",
        "jwt": "string"
      }
    },
)
print(res.json())

curl -X PATCH 'https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/user_pin/update' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": {"user": {"username": "string", "authModule": "string"}, "currentPin": "string", "newPin": "string", "jwt": "string"}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/user_pin/update", {
  method: "PATCH",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": {
      "user": {
        "username": "string",
        "authModule": "string"
      },
      "currentPin": "string",
      "newPin": "string",
      "jwt": "string"
    }
  })
});
const data = await res.json();

import requests

res = requests.patch(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/user_pin/update",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": {
        "user": {
          "username": "string",
          "authModule": "string"
        },
        "currentPin": "string",
        "newPin": "string",
        "jwt": "string"
      }
    },
)
print(res.json())

curl -X DELETE 'https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/user_pin' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": {"user": {"username": "string", "authModule": "string"}, "currentPin": "string", "jwt": "string", "eventInfo": {"clientIp": "string", "userAgent": "string", "initiatedBy": "string"}}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/user_pin", {
  method: "DELETE",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": {
      "user": {
        "username": "string",
        "authModule": "string"
      },
      "currentPin": "string",
      "jwt": "string",
      "eventInfo": {
        "clientIp": "string",
        "userAgent": "string",
        "initiatedBy": "string"
      }
    }
  })
});
const data = await res.json();

import requests

res = requests.delete(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/user_pin",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": {
        "user": {
          "username": "string",
          "authModule": "string"
        },
        "currentPin": "string",
        "jwt": "string",
        "eventInfo": {
          "clientIp": "string",
          "userAgent": "string",
          "initiatedBy": "string"
        }
      }
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/passkey' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": {"userName": "string"}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/passkey", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": {
      "userName": "string"
    }
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/passkey",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": {
        "userName": "string"
      }
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/passkey/register' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": {"credentialId": "string", "privateKey": {"jwk": {"kty": "string", "crv": "string", "key_ops": ["string"], "ext": true, "d": "string", "x": "string", "y": "string"}, "algorithm": "string", "curve": "string"}, "rpId": "string", "userId": "string", "userName": "string", "userDisplayName": "string", "entraAuthMethodId": "string", "createdAt": "string"}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/passkey/register", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": {
      "credentialId": "string",
      "privateKey": {
        "jwk": {
          "kty": "string",
          "crv": "string",
          "key_ops": [
            "string"
          ],
          "ext": true,
          "d": "string",
          "x": "string",
          "y": "string"
        },
        "algorithm": "string",
        "curve": "string"
      },
      "rpId": "string",
      "userId": "string",
      "userName": "string",
      "userDisplayName": "string",
      "entraAuthMethodId": "string",
      "createdAt": "string"
    }
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/passkey/register",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": {
        "credentialId": "string",
        "privateKey": {
          "jwk": {
            "kty": "string",
            "crv": "string",
            "key_ops": [
              "string"
            ],
            "ext": true,
            "d": "string",
            "x": "string",
            "y": "string"
          },
          "algorithm": "string",
          "curve": "string"
        },
        "rpId": "string",
        "userId": "string",
        "userName": "string",
        "userDisplayName": "string",
        "entraAuthMethodId": "string",
        "createdAt": "string"
      }
    },
)
print(res.json())

curl -X GET 'https://pilot-root.1kosmos.net/users-mgmt/servicekeys' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/servicekeys", {
  method: "GET",
  headers: {
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "licensekey": "YOUR_LICENSE_KEY",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/users-mgmt/servicekeys",
    headers={
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "licensekey": "YOUR_LICENSE_KEY",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X DELETE 'https://pilot-root.1kosmos.net/users-mgmt/servicekey/<keyId>' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/servicekey/<keyId>", {
  method: "DELETE",
  headers: {
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "licensekey": "YOUR_LICENSE_KEY",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.delete(
    "https://pilot-root.1kosmos.net/users-mgmt/servicekey/<keyId>",
    headers={
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "licensekey": "YOUR_LICENSE_KEY",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/fetch_by_oid' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"oid": "string", "tid": "string"}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/fetch_by_oid", {
  method: "POST",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "oid": "string",
    "tid": "string"
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/<tenantId>/community/<communityId>/user/fetch_by_oid",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "oid": "string",
      "tid": "string"
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/ecdsa_helper/<method>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"dataStr": "Hey, This is example data string.", "publicKey": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx=", "privateKey": "xxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/ecdsa_helper/<method>", {
  method: "POST",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "dataStr": "Hey, This is example data string.",
    "publicKey": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx=",
    "privateKey": "xxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/ecdsa_helper/<method>",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "dataStr": "Hey, This is example data string.",
      "publicKey": "xxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx=",
      "privateKey": "xxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxx="
    },
)
print(res.json())

curl -X GET 'https://pilot-root.1kosmos.net/users-mgmt/environment' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/environment", {
  method: "GET",
  headers: {
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/users-mgmt/environment",
    headers={
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X DELETE 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/factor_lock' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"userId": "xxxxxxxxxx", "factor": "xxxxxx", "authModuleId": "xxxxxxx", "eventData": {}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/factor_lock", {
  method: "DELETE",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "userId": "xxxxxxxxxx",
    "factor": "xxxxxx",
    "authModuleId": "xxxxxxx",
    "eventData": {}
  })
});
const data = await res.json();

import requests

res = requests.delete(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/factor_lock",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "userId": "xxxxxxxxxx",
      "factor": "xxxxxx",
      "authModuleId": "xxxxxxx",
      "eventData": {}
    },
)
print(res.json())

curl -X GET 'https://pilot-root.1kosmos.net/users-mgmt/healthz' \
  -H 'synthetic-heartbeat: <value>' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/healthz", {
  method: "GET",
  headers: {
    "synthetic-heartbeat": "<value>",
    "licensekey": "YOUR_LICENSE_KEY",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/users-mgmt/healthz",
    headers={
        "synthetic-heartbeat": "<value>",
        "licensekey": "YOUR_LICENSE_KEY",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/infra/checkBrokerStatusAndSendNotifications' \
  -H 'licensekey: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/infra/checkBrokerStatusAndSendNotifications", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/infra/checkBrokerStatusAndSendNotifications",
    headers={
        "licensekey": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/internal_call/broker_request' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"communityId": "string", "authModule": {}, "dataPayload": {}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/internal_call/broker_request", {
  method: "POST",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "communityId": "string",
    "authModule": {},
    "dataPayload": {}
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/internal_call/broker_request",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "communityId": "string",
      "authModule": {},
      "dataPayload": {}
    },
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/jwt/verifyToken' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"token": "xxxx"}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/jwt/verifyToken", {
  method: "POST",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "token": "xxxx"
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/jwt/verifyToken",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "token": "xxxx"
    },
)
print(res.json())

curl -X GET 'https://pilot-root.1kosmos.net/users-mgmt/publickeys' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/publickeys", {
  method: "GET",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/users-mgmt/publickeys",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X GET 'https://pilot-root.1kosmos.net/users-mgmt/sd' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/sd", {
  method: "GET",
  headers: {
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY"
  }
});
const data = await res.json();

import requests

res = requests.get(
    "https://pilot-root.1kosmos.net/users-mgmt/sd",
    headers={
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    }
)
print(res.json())

curl -X POST 'https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user_properties/update' \
  -H 'licensekey: YOUR_LICENSE_KEY' \
  -H 'requestid: <ecdsa-requestid>' \
  -H 'publickey: <public-key>' \
  -H 'keyId: YOUR_KEY_ID' \
  -H 'keySecret: YOUR_KEY_SECRET' \
  -H 'license: YOUR_LICENSE_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"data": {"user": {"username": "", "uid": "", "authModuleId": ""}, "mobiles": [], "landlines": [], "aliases": {"alias1": "string", "alias2": null, "alias3": "string", "alias4": "string", "alias5": null, "alias6": null, "alias7": null, "alias8": null}}}'

const res = await fetch("https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user_properties/update", {
  method: "POST",
  headers: {
    "licensekey": "YOUR_LICENSE_KEY",
    "requestid": "<ecdsa-requestid>",
    "publickey": "<public-key>",
    "keyId": "YOUR_KEY_ID",
    "keySecret": "YOUR_KEY_SECRET",
    "license": "YOUR_LICENSE_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "data": {
      "user": {
        "username": "",
        "uid": "",
        "authModuleId": ""
      },
      "mobiles": [],
      "landlines": [],
      "aliases": {
        "alias1": "string",
        "alias2": null,
        "alias3": "string",
        "alias4": "string",
        "alias5": null,
        "alias6": null,
        "alias7": null,
        "alias8": null
      }
    }
  })
});
const data = await res.json();

import requests

res = requests.post(
    "https://pilot-root.1kosmos.net/users-mgmt/tenant/xxxxxxxxxx/community/xxxxxxxxxxxxxxxxxxxxxxxx/user_properties/update",
    headers={
        "licensekey": "YOUR_LICENSE_KEY",
        "requestid": "<ecdsa-requestid>",
        "publickey": "<public-key>",
        "keyId": "YOUR_KEY_ID",
        "keySecret": "YOUR_KEY_SECRET",
        "license": "YOUR_LICENSE_KEY"
    },
    json={
      "data": {
        "user": {
          "username": "",
          "uid": "",
          "authModuleId": ""
        },
        "mobiles": [],
        "landlines": [],
        "aliases": {
          "alias1": "string",
          "alias2": null,
          "alias3": "string",
          "alias4": "string",
          "alias5": null,
          "alias6": null,
          "alias7": null,
          "alias8": null
        }
      }
    },
)
print(res.json())