Namespace ajax

<p:remoteCommand name="myCommand" listener="#{myBean.action}" />

This creates a variable window.myCommand that is of this type. On the client-side, you can pass parameters to the remote command via

window.myCommand([ { name: "myParamName", value: 9 } ]);

On the server-side, you can access them as follows:

String myParamValue = FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap().get("myParamName")

To send data back to the client, use

PrimeFaces.current().ajax().addCallbackParam("returnParamName", true);

Finally, to access the returned value on the client, do

try {
  const response = await window.myCommand([ { name: "myParamName", value: 9 } ]);
  // Success, do something with the data
  const value = response.jqXHR.pfArgs.returnParamName;
}
catch (e) {
  // Handle error
  console.error("Could not invoke remote command", e);
}

Please note that you should not use async-await if you need to target old browsers, use then/catch on the returned promise instead. See RemoteCommandParams for more details on how to use this TypeScript type.

<p:remoteCommand name="RemoteCommands.checkMaturity" ... />

Then you can declare (or generate automatically from the bean method!) this remote command in TypeScript like this:

declare const RemoteCommands {
  const checkMaturity: RemoteCommand<
    {name: string, age: number},
    {success: boolean, message: string}
  >;
}

RemoteCommand.checkMaturity( [ { name: "name", value: "John Doe" } ] ) // works
RemoteCommand.checkMaturity( [ { name: "age", value: 12 } ] ) // works

RemoteCommand.checkMaturity( [ { name: "username", value: "John Doe" } ] ) // error
RemoteCommand.checkMaturity( [ { name: "age", value: "12" } ] ) // error

const response = await RemoteCommand.checkMaturity( [ { name: "name", value: "John Doe" } ];

const success: boolean = response.jqXHR.pfArgs.success; // works
const message: string = response.jqXHR.pfArgs.message; // works
const message: string = response.jqXHR.pfArgs.errormessage; // error

returns

An array type of request parameters where the name can be one of the keys of T and the value is the corresponding value from T. Array values are mapped to the item type, so that RemoteCommandParams<{names: string[]}> is the same as RemoteCommandParams<{names: string}>. This is done because multiple values for the same name should be send by including multiple items in the request callback parameter array.