SYNOPSIS

   command [add [ --node-type=node_path_to_the_type
                [--property-id=identifying_property] ] |
                [ --node-child=node_path_to_the_child ]
                --command-name=name_for_the_command |
            remove --command_name=command_to_remove |
            list]

DESCRIPTION

  Allows to add new, remove and list existing generic type commands.

  Generic command for a type node

  When --node-type argument is used, a created generic type command is a command 
  that is assigned to a specific node type and which allows to perform any 
  operation available for an instance of that type and/or modify any of the 
  properties exposed by the type on any existing instance of that type.

  For example, suppose there is a generic type command assigned to type
  /subsystem=datasources/data-source and named data-source. Now, data-source
  command can be used to add new datasources to the server, modify properties
  and perform any available operation on any existing datasource. To do that,
  the command needs to identify the datasource that should be affected. For
  that, there is a special argument, which can be a property exposed by the type
  and that can be used to identify the instance, e.g. in case of datasource,
  this role can be given to property 'jndi-name'. Or if there is no such
  property, generic type command will automatically add argument 'name' which,
  as its value, will accept the instance name (the last name in the node path
  of the instance)

  Here is an example of invoking operation 'flush-all-connection-in-pool' on
  datasource with jndi-name 'myds'.

  data-source flush-all-connection-in-pool --jndi-name=myds

  where flush-all-connection-in-pool is an operation name exposed by data-source
  type and jndi-name is the property name that identifies the specific
  datasource to perform the operation on. If the operation has properties, they
  can be added as command line arguments by prefixing property names with '--'
  and supplying the values after '='. E.g. This is how a new datasource could be
  added

  data-source add --jndi-name=my-new-ds --driver-name=h2 \
                  --connection-url=db:url --pool-name=my-ds-pool

  To modify properties of an existing type instance, just use property names as
  arguments like the operation arguments in the example above. E.g.

  data-source --jndi-name=my-new-ds --min-pool-size=11 --max-pool-size=22

  Generic command for a child node

  When --node-child argument is used, a created generic type command is a 
  command that is assigned to a specific child node instance and which allows 
  to perform any operation available for that instance and/or modify any of its 
  properties. The child node must already exist in the management model. It can't
  be added using the created generic command.

  For example:

  To create an 'authorization' command named 'authorization' for the 
  access=authorization child node:

  command add --node-child=/core-service=management/access=authorization 
              --command-name=authorization
  
  To write some attributes of the access=authorization child node:

  authorization --provider=rbac --permission-combination-policy=permissive 
                --use-identity-roles=false

  To call the operation 'read-attribute' on the access=authorization child node:

  authorization read-attribute --name=provider
  
  Tab-completion will help completing operation and property names.

  Generic type commands support --help option. The content of the help will be
  generated from the description of the operations and properties provided by
  the model on the server. E.g. the following command will describe the type
  itself:

  data-source --help

  The following will list all the operations exposed by the type:

  data-source --help --commands

  This will list all the properties exposed by the type:

  data-source --help --properties

  And this will describe the specific operation, in this case
  flush-all-connection-in-pool:

  data-source flush-all-connection-in-pool --help


ARGUMENTS

  add     - adds a new generic type command. The following arguments are used to
            add a new command:

              --node-type     - (required if no --node-child) specifies the node 
                              path which ends on a type, for which the generic 
                              command should be created;

              --node-child    - (required if no --node-type) specifies the node 
                              path which ends on a child, for which the generic 
                              command should be created;

              --property-id   - (optional, only usable with --node-type) a 
                              property name exposed by the type that should be 
                              used to identify instances of the type. If not 
                              specified, argument '--name' will be used with the 
                              instance name as its value to identify the target 
                              instance.

              --command-name  - (required) the name for the command.

  remove  - removes an existing generic type command. There is a single required
            argument --command-name which identifies the command that should be
            removed.
			
  list    - lists existing generic type commands.
