data: {
    password: {
        description: "Refers to the password to be validated.",
        type: String,
        methods: [ Params ],
        nested: [ ]
    },
    email: {
        description: "Refers to the email address linked to the password to be validated.",
        type: String,
        default: undefined,
        methods: [ Params ],
        nested: [ password ]
    },
    bannedWords: {
        description: "Refers to the forbidden words in the password.",
        // String Arrays are accepted.
        type: Array,
            items: String,
        default: [ ],
        requirements: {
            minimum: 0,
            maximum: 10
        },
        methods: [ Params ],
        nested: [ password ]
    },
    min: {
        description: "Refers to the minimum length of the password.",
        type: Integer,
        default: 8,
        requirements: {
            minimum: 8,
            maximum: 32
        },
        methods: [ Params ],
        nested: [ password ]
    },
    max: {
        description: "Refers to the maximum length of the password.",
        type: Integer,
        default: 100,
        requirements: {
            minimum: 32,
            maximum: 100
        },
        methods: [ Params ],
        nested: [ password ]
    }
}
                                                

set password=PASSWORD_REQ
set [email protected]
set bannedWords=[appName, test, companyName]
set min=16
set max=52


curl -X GET "https://api.tpeoficial.com/v1/public/validPwd?password=%password%&email=%email%&min=%min%&max=%max%"
                                                

require 'net/http'
require 'uri'
require 'json'

password = URI.encode_www_form_component('PASSWORD_REQ')
banned_words = ['appName', 'test', 'companyName']
banned_words_encoded = URI.encode_www_form_component(JSON.generate(banned_words))

uri = URI.parse("https://api.tpeoficial.com/v1/public/validPwd?password=#{password}[email protected]&bannedWords=#{banned_words_encoded}&min=16&max=52")

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true if uri.scheme == 'https'

request = Net::HTTP::Get.new(uri.request_uri)

response = http.request(request)

puts "Response Code: #{response.code}"
puts "Response Body: #{response.body}"
                                                

import requests
import urllib.parse
import json

password = urllib.parse.quote("PASSWORD_REQ")
banned_words = ["appName", "test", "companyName"]
banned_words_encoded = urllib.parse.quote(json.dumps(banned_words))

url = f"https://api.tpeoficial.com/v1/public/validPwd?password={password}[email protected]&bannedWords={banned_words_encoded}&min=16&max=52"

response = requests.get(url)

print("Response Code:", response.status_code)
print("Response Body:", response.text)
                                                

<?php

$url = 'https://api.tpeoficial.com/v1/public/validPwd';
$password = 'PASSWORD_REQ';
$email = '[email protected]';
$bannedWords = ['appName', 'test', 'companyName'];
$bannedWordsEncoded = urlencode(json_encode($bannedWords));
$min = '16';
$max = '52';

$params = [
    'password' => urlencode($password),
    'email' => $email,
    'bannedWords' => $bannedWordsEncoded,
    'min' => $min,
    'max' => $max,
];

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url . '?' . http_build_query($params));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

curl_close($ch);

echo "Response Code: $httpCode\n";
echo "Response Body: $response\n";

?>
                                                

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class CurlToJava {

    public static void main(String[] args) {
        try {
            String url = "https://api.tpeoficial.com/v1/public/validPwd";
            String password = "PASSWORD_REQ";
            String email = "[email protected]";
            String[] bannedWordsArray = {"appName", "test", "companyName"};
            String bannedWords = Arrays.stream(bannedWordsArray)
                                       .map(URLEncoder::encode)
                                       .collect(Collectors.joining(","));
            String min = "16";
            String max = "52";

            String fullUrl = url + "?password=" + password + "&email=" + email + "&bannedWords=" + bannedWords + "&min=" + min + "&max=" + max;

            URL obj = new URL(fullUrl);
            HttpURLConnection con = (HttpURLConnection) obj.openConnection();

            con.setRequestMethod("GET");

            int responseCode = con.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
            String inputLine;
            StringBuilder response = new StringBuilder();

            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();

            System.out.println("Response Body: " + response.toString());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
                                                

const axios = require('axios');

axios.get('https://api.tpeoficial.com/v1/public/validPwd', {
  params: {
    password: encodeURIComponent('PASSWORD_REQ'),
    email: '[email protected]',
    bannedWords: ["appName", "test", "companyName"],
    min: 16,
    max: 52
  }
})
.then(function (response) {
  console.log('Response Data:', response.data);
})
.catch(function (error) {
  console.error('Error:', error);
});
                                                

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
	"strings"
)

func main() {
	url := "https://api.tpeoficial.com/v1/public/validPwd"
	password := "PASSWORD_REQ"
	email := "[email protected]"
    bannedWords := []string{"appName", "test", "companyName"}
	bannedWordsEncoded := url.QueryEscape(strings.Join(bannedWords, ","))
	min := "16"
	max := "52"

	fullURL := fmt.Sprintf("%s?password=%s&email=%s&min=%s&max=%s",
		url, url.QueryEscape(password), url.QueryEscape(email), bannedWordsEncoded, min, max)

	req, err := http.NewRequest("GET", fullURL, nil)
	if err != nil {
		fmt.Println("Error creating the request:", err)
		return
	}

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error making the request:", err)
		return
	}
	defer resp.Body.Close()

	fmt.Println("Response Code:", resp.Status)

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Error reading the body of the response:", err)
		return
	}

	fmt.Println("Response Body:", string(body))
}
                                                

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web;

class Program
{
    static async Task Main()
    {
        string apiUrl = "https://api.tpeoficial.com/v1/public/validPwd";
        string password = "PASSWORD_REQ";
        string email = "[email protected]";
        string[] bannedWordsArray = { "appName", "test", "companyName" };
        string bannedWords = string.Join(",", bannedWordsArray);
        string min = "16";
        string max = "52";

        string fullUrl = $"{apiUrl}?password={Uri.EscapeDataString(password)}&email={Uri.EscapeDataString(email)}&bannedWords={Uri.EscapeDataString(bannedWords)}&min={min}&max={max}";

        using (HttpClient client = new HttpClient())
        {

            HttpResponseMessage response = await client.GetAsync(fullUrl);

            if (response.IsSuccessStatusCode)
            {
                string responseBody = await response.Content.ReadAsStringAsync();
                Console.WriteLine($"Response Code: {response.StatusCode}");
                Console.WriteLine($"Response Body: {responseBody}");
            }
            else
            {
                Console.WriteLine($"Error: {response.StatusCode}");
            }
        }
    }
}