​
epx custom-entities

Reads and changes custom entity types: entities a tenant defines. create, update and delete change types; export exports types with their schemas (opt-in), which import imports. epx custom-entities instances reads and changes the instances of a type. Its reads require different OAuth scopes; the help of each names them. Opt-in: epx requests a write-capable scope for a read only when given --allow-write-scope. Its writes require different OAuth scopes; the help of each names them. Command: epx custom-entities [flags], epx custom-entities [command] Flags: only the global flags. Subcommands

​
epx custom-entities create

Create a custom entity type. Creates the custom entity type in --file, a JSON object with its id and name, such as {"id": "CUSTOM_DOCUMENT", "name": {"en": "Document"}}, and prints the id that Emporix answers with; one that exists already is a conflict. The id has capital letters, digits and underscores, the first a letter. Emporix also creates the scopes that read and manage the instances of the type, such as custom.custom_document_manage, which it grants only minutes later: until then, the instance commands of the type exit with code 3. Built-in types, such as AVAILABILITY and LOCATION, cannot be created. Localized text in the body is a map of translations, e.g. {"en": "Acme", "de": "Acme"}, as -o json of a read prints it, sent with Content-Language: *. Emporix refuses a string in its place. Changes data: on a terminal, epx asks before it sends POST. --yes sends without asking (required without a terminal, or with --file -); --dry-run prints the request instead of sending it. Requires the schema.schema_manage scope. Command: epx custom-entities create [flags] Flags
  • --dry-run
    Print the request instead of sending it (excludes -o).
  • --file <PATH>
    JSON request body in PATH, sent byte for byte (- reads standard input; sending it then needs --yes; required).
  • -o, --output <format>
    Format of the response: json or yaml. Default: json.
  • --yes
    Send without asking (required without a terminal, or with --file -).
Also takes the global flags.

​
epx custom-entities delete

Delete a custom entity type. Deletes the custom entity type ID. Emporix refuses to delete a type that schemas or instances use (400 Bad Request), and answers an unknown ID as deleted, not as not found. The scopes that Emporix created with the type remain granted: the instances of a deleted type then read as an empty list. Deletes data, which cannot be undone. On a terminal, epx sends DELETE only once you type ID at its prompt. --yes sends without asking (required without a terminal); --dry-run prints the request instead of sending it. Requires the schema.schema_manage scope. Command: epx custom-entities delete ID [flags] Flags
  • --dry-run
    Print the request instead of sending it (excludes -o).
  • -o, --output <format>
    Format of the response: json or yaml. Default: json.
  • --yes
    Send without asking (required without a terminal).
Also takes the global flags.

​
epx custom-entities export

Export custom entity types with their schemas. Reads an export package of the custom entity types that --type names (the ID that epx custom-entities list shows): each type with its schemas, without metadata, and none of their instances. Emporix leaves out an ID that names no custom entity type (a built-in type such as PRODUCT too); if none is left, it answers with an empty package (exit 0). Emporix refuses an empty selection (--body with [], exit 1). Changes nothing: Emporix serves this read as POST with a JSON body, which the flags make or --body gives whole. DATA is the package, base64-encoded and cut in the table; -o json prints the package whole, as an import on another tenant takes it. Requires the schema.schema_manage scope. Opt-in: epx requests a write-capable scope for a read only when given --allow-write-scope. Command: epx custom-entities export [flags] Flags
  • --allow-write-scope
    Opt in to requesting schema.schema_manage, which can also change data (required).
  • --body <FILE>
    Send the JSON request body in FILE as given (- reads standard input) instead of the one the other flags make.
  • --columns <names>
    Print only these columns of table and csv, in this order: comma-separated names (any case) among DATA, EXPORTED AT.
  • --no-headers
    Print table and csv without the header row.
  • -o, --output <format>
    Output format: table, json, yaml or csv (csv: the table’s rows; json and yaml: the whole response). Default: table.
  • --type <ID>
    A custom entity type ID to export (repeatable; required without --body).
Also takes the global flags.

​
epx custom-entities get

Show one custom entity. Reads custom entity types: entities a tenant defines. epx custom-entities instances reads and changes the instances of a type. No OAuth scope is needed. Command: epx custom-entities get ID [flags] Flags
  • --columns <names>
    Print only these columns of table and csv, in this order: comma-separated names (any case) among ID, NAME, VERSION.
  • --language <language>
    Language of localized table text; a missing translation shows another, labeled (-o json prints all). Default: en.
  • --no-headers
    Print table and csv without the header row.
  • -o, --output <format>
    Output format: table, json, yaml or csv (csv: the table’s rows; json and yaml: the whole response). Default: table.
Also takes the global flags.

​
epx custom-entities import

Import custom entity types with their schemas. Imports the custom entity types and their schemas of the export package in --file, as epx custom-entities export -o json prints it, e.g. on another tenant. A type or schema that exists already is created again, its id followed by _COPY, such as CUSTOM_DOCUMENT_COPY, and the references of its schemas then name the copy. Changes data: on a terminal, epx asks before it sends POST. --yes sends without asking (required without a terminal, or with --file -); --dry-run prints the request instead of sending it. Requires the schema.schema_manage scope. Command: epx custom-entities import [flags] Flags
  • --dry-run
    Print the request instead of sending it (excludes -o).
  • --file <PATH>
    JSON request body in PATH, sent byte for byte (- reads standard input; sending it then needs --yes; required).
  • -o, --output <format>
    Format of the response: json or yaml. Default: json.
  • --yes
    Send without asking (required without a terminal, or with --file -).
Also takes the global flags.

​
epx custom-entities instances

Read and change the instances of a custom entity type. Reads the instances of a custom entity type, every one (list), those a filter finds (search) or one (get), and creates, changes and deletes them, one at a time or in bulk. Its reads require the custom.<type>_read scope. Its writes require the custom.<type>_manage scope. <type> is the custom entity type in lower case (custom.document_manage, custom.document_read for DOCUMENT). Command: epx custom-entities instances [flags], epx custom-entities instances [command] Flags: only the global flags. Subcommands

​
epx custom-entities instances bulk-create

Create instances of a custom entity type in bulk. Creates instances of the custom entity type CUSTOM_ENTITY_ID from --file, a JSON array of instances, each as create takes it. CUSTOM_ENTITY_ID is the ID that epx custom-entities list shows. With --validate-references true, Emporix checks the items that the references of each instance name with epx’s token, which reads the instances of CUSTOM_ENTITY_ID alone: an instance with a reference to an item that does not exist fails with 500 Internal Server Error (nothing is created), as one with a reference to an instance of another custom entity type is expected to, and one with a reference to another kind of item, such as a product, may. Localized text in the body is a map of translations, e.g. {"en": "Acme", "de": "Acme"}, as -o json of a read prints it, sent with Content-Language: *. Emporix refuses a string in its place. Emporix takes up to 200 items in one request (epx refuses more), carries out each on its own and answers with the result of each: when one failed, epx prints the response, lists the items that failed on standard error (one that failed with 500, 502, 503 or 504 may have been carried out all the same) and exits with the code that their failures share (for example 5 for a 409 Conflict, 4 for a 404), else 1. Changes data: on a terminal, epx asks before it sends POST. --yes sends without asking (required without a terminal, or with --file -); --dry-run prints the request instead of sending it. Where --validate-references is true, epx also requests the custom.<type>_read scope. Requires the custom.<type>_manage scope. <type> is the custom entity type in lower case (custom.document_manage for DOCUMENT). Command: epx custom-entities instances bulk-create CUSTOM_ENTITY_ID [flags] Flags
  • --dry-run
    Print the request instead of sending it (excludes -o).
  • --file <PATH>
    JSON request body in PATH, sent byte for byte (- reads standard input; sending it then needs --yes; required).
  • -o, --output <format>
    Format of the response: json or yaml. Default: json.
  • --validate-references <string>
    Whether Emporix checks that the items that references in the body name exist (false without it), requesting custom.<type>_read where it is true: true or false.
  • --yes
    Send without asking (required without a terminal, or with --file -).
Also takes the global flags.

​
epx custom-entities instances bulk-delete

Delete instances of a custom entity type in bulk. Deletes the instances of the custom entity type CUSTOM_ENTITY_ID whose ids --file lists, a JSON array of strings, such as ["123", "124"]; Emporix answers an unknown id as deleted. CUSTOM_ENTITY_ID is the ID that epx custom-entities list shows. Emporix takes up to 1000 items in one request (epx refuses more), carries out each on its own and answers with the result of each: when one failed, epx prints the response, lists the items that failed on standard error (one that failed with 500, 502, 503 or 504 may have been carried out all the same) and exits with the code that their failures share (for example 5 for a 409 Conflict, 4 for a 404), else 1. Deletes the instances of a custom entity type that --file names with one request, which cannot be undone. On a terminal, epx sends DELETE only once you type CUSTOM_ENTITY_ID at its prompt. --yes sends without asking (required without a terminal, or with --file -); --dry-run prints the request instead of sending it. Requires the custom.<type>_manage scope. <type> is the custom entity type in lower case (custom.document_manage for DOCUMENT). Command: epx custom-entities instances bulk-delete CUSTOM_ENTITY_ID [flags] Flags
  • --dry-run
    Print the request instead of sending it (excludes -o).
  • --file <PATH>
    JSON request body in PATH, sent byte for byte (- reads standard input; sending it then needs --yes; required).
  • -o, --output <format>
    Format of the response: json or yaml. Default: json.
  • --yes
    Send without asking (required without a terminal, or with --file -).
Also takes the global flags.

​
epx custom-entities instances bulk-patch

Change instances of a custom entity type in bulk. Changes instances of the custom entity type CUSTOM_ENTITY_ID as --file says: a JSON array with the id of each instance and the JSON Patch operations that change it, as patch takes them, such as [{"id": "123", "data": [{"op": "replace", "path": "/name/en", "value": "Report"}]}]. CUSTOM_ENTITY_ID is the ID that epx custom-entities list shows. With --validate-references true, Emporix checks the items that the references of each instance name with epx’s token, which reads the instances of CUSTOM_ENTITY_ID alone: an instance with a reference to an item that does not exist fails with 500 Internal Server Error (nothing is created), as one with a reference to an instance of another custom entity type is expected to, and one with a reference to another kind of item, such as a product, may. Localized text in the body is a map of translations, e.g. {"en": "Acme", "de": "Acme"}, as -o json of a read prints it, sent with Content-Language: *. Emporix refuses a string in its place. Emporix takes up to 200 items in one request (epx refuses more), carries out each on its own and answers with the result of each: when one failed, epx prints the response, lists the items that failed on standard error (one that failed with 500, 502, 503 or 504 may have been carried out all the same) and exits with the code that their failures share (for example 5 for a 409 Conflict, 4 for a 404), else 1. Changes data: on a terminal, epx asks before it sends PATCH. --yes sends without asking (required without a terminal, or with --file -); --dry-run prints the request instead of sending it. Where --validate-references is true, epx also requests the custom.<type>_read scope. Requires the custom.<type>_manage scope. <type> is the custom entity type in lower case (custom.document_manage for DOCUMENT). Command: epx custom-entities instances bulk-patch CUSTOM_ENTITY_ID [flags] Flags
  • --dry-run
    Print the request instead of sending it (excludes -o).
  • --file <PATH>
    JSON request body in PATH, sent byte for byte (- reads standard input; sending it then needs --yes; required).
  • -o, --output <format>
    Format of the response: json or yaml. Default: json.
  • --validate-references <string>
    Whether Emporix checks that the items that references in the body name exist (false without it, although its reference says true), requesting custom.<type>_read where it is true: true or false.
  • --yes
    Send without asking (required without a terminal, or with --file -).
Also takes the global flags.

​
epx custom-entities instances bulk-update

Upsert instances of a custom entity type in bulk. Replaces the instances of the custom entity type CUSTOM_ENTITY_ID in --file, a JSON array of instances, each with its id and as update takes it, or creates those that do not exist (an upsert). CUSTOM_ENTITY_ID is the ID that epx custom-entities list shows. With --validate-references true, Emporix checks the items that the references of each instance name with epx’s token, which reads the instances of CUSTOM_ENTITY_ID alone: an instance with a reference to an item that does not exist fails with 500 Internal Server Error (nothing is created), as one with a reference to an instance of another custom entity type is expected to, and one with a reference to another kind of item, such as a product, may. Localized text in the body is a map of translations, e.g. {"en": "Acme", "de": "Acme"}, as -o json of a read prints it, sent with Content-Language: *. Emporix refuses a string in its place. Emporix takes up to 200 items in one request (epx refuses more), carries out each on its own and answers with the result of each: when one failed, epx prints the response, lists the items that failed on standard error (one that failed with 500, 502, 503 or 504 may have been carried out all the same) and exits with the code that their failures share (for example 5 for a 409 Conflict, 4 for a 404), else 1. Changes data: on a terminal, epx asks before it sends PUT. --yes sends without asking (required without a terminal, or with --file -); --dry-run prints the request instead of sending it. Where --validate-references is true, epx also requests the custom.<type>_read scope. Requires the custom.<type>_manage scope. <type> is the custom entity type in lower case (custom.document_manage for DOCUMENT). Command: epx custom-entities instances bulk-update CUSTOM_ENTITY_ID [flags] Flags
  • --dry-run
    Print the request instead of sending it (excludes -o).
  • --file <PATH>
    JSON request body in PATH, sent byte for byte (- reads standard input; sending it then needs --yes; required).
  • -o, --output <format>
    Format of the response: json or yaml. Default: json.
  • --validate-references <string>
    Whether Emporix checks that the items that references in the body name exist (false without it), requesting custom.<type>_read where it is true: true or false.
  • --yes
    Send without asking (required without a terminal, or with --file -).
Also takes the global flags.

​
epx custom-entities instances create

Create an instance of a custom entity type. Creates an instance of the custom entity type CUSTOM_ENTITY_ID from the JSON object in --file, such as {"id": "123", "name": {"en": "Report"}, "mixins": {…}}, and prints the id that Emporix answers with; it makes one unless the object names it, and an id that exists already is a conflict. An owner, such as {"type": "EMPLOYEE", "userId": "…"}, cannot change once set. The attributes of a schema go under its id, which metadata.mixins maps to its URL: {"mixins": {"SCHEMA_ID": {…}}, "metadata": {"mixins": {"SCHEMA_ID": "URL"}}}, the URL being the metadata.url that epx schemas get SCHEMA_ID -o json prints. A localized attribute, unlike the name, is a list of translations, such as [{"language": "en", "value": "Report"}]. CUSTOM_ENTITY_ID is the ID that epx custom-entities list shows. Emporix checks the items that the references of the instance name (unless --validate-references false) with epx’s token, which reads the instances of CUSTOM_ENTITY_ID alone: a reference to an instance of another custom entity type is then expected to fail with 400 Bad Request, as one to the type fails without that scope, and one to another kind of item, such as a product, may fail too. Localized text in the body is a map of translations, e.g. {"en": "Acme", "de": "Acme"}, as -o json of a read prints it, sent with Content-Language: *. Emporix refuses a string in its place. Changes data: on a terminal, epx asks before it sends POST. --yes sends without asking (required without a terminal, or with --file -); --dry-run prints the request instead of sending it. Where --validate-references is true or not given, epx also requests the custom.<type>_read scope. Requires the custom.<type>_manage scope. <type> is the custom entity type in lower case (custom.document_manage for DOCUMENT). Command: epx custom-entities instances create CUSTOM_ENTITY_ID [flags] Flags
  • --dry-run
    Print the request instead of sending it (excludes -o).
  • --file <PATH>
    JSON request body in PATH, sent byte for byte (- reads standard input; sending it then needs --yes; required).
  • -o, --output <format>
    Format of the response: json or yaml. Default: json.
  • --validate-references <string>
    Whether Emporix checks that the items that references in the body name exist (true without it), requesting custom.<type>_read where it is true or not given: true or false.
  • --yes
    Send without asking (required without a terminal, or with --file -).
Also takes the global flags.

​
epx custom-entities instances delete

Delete an instance of a custom entity type. Deletes the instance ID of the custom entity type CUSTOM_ENTITY_ID; Emporix answers an unknown ID as deleted, not as not found. CUSTOM_ENTITY_ID is the ID that epx custom-entities list shows, and ID the one that epx custom-entities instances list CUSTOM_ENTITY_ID shows. Deletes data, which cannot be undone. On a terminal, epx sends DELETE only once you type ID at its prompt. --yes sends without asking (required without a terminal); --dry-run prints the request instead of sending it. Requires the custom.<type>_manage scope. <type> is the custom entity type in lower case (custom.document_manage for DOCUMENT). Command: epx custom-entities instances delete CUSTOM_ENTITY_ID ID [flags] Flags
  • --dry-run
    Print the request instead of sending it (excludes -o).
  • -o, --output <format>
    Format of the response: json or yaml. Default: json.
  • --yes
    Send without asking (required without a terminal).
Also takes the global flags.

​
epx custom-entities instances get

Show one instance of a custom entity type. Reads one instance of a custom entity type. CUSTOM_ENTITY_ID is the ID that epx custom-entities list shows; an unknown one has no scope that Emporix grants (exit code 3), and a type created in the last minutes has none yet. ID is the ID that epx custom-entities instances list CUSTOM_ENTITY_ID shows; an unknown one is not found. OWNER is an instance’s owner, by default who created it (EMPLOYEE, CUSTOMER or SERVICE, and the user or client id); attribute values (mixins) are only in -o json. epx requests the scope of the type, not the tenant-wide schema.custominstance_read that Emporix also accepts. Requires the custom.<type>_read scope. <type> is the custom entity type in lower case (custom.document_read for DOCUMENT). Command: epx custom-entities instances get CUSTOM_ENTITY_ID ID [flags] Flags
  • --columns <names>
    Print only these columns of table and csv, in this order: comma-separated names (any case) among ID, NAME, OWNER, VERSION.
  • --language <language>
    Language of localized table text; a missing translation shows another, labeled (-o json prints all). Default: en.
  • --no-headers
    Print table and csv without the header row.
  • -o, --output <format>
    Output format: table, json, yaml or csv (csv: the table’s rows; json and yaml: the whole response). Default: table.
Also takes the global flags.

​
epx custom-entities instances list

List the instances of a custom entity type. Reads the instances of a custom entity type (epx custom-entities instances get shows one). CUSTOM_ENTITY_ID is the ID that epx custom-entities list shows; an unknown one has no scope that Emporix grants (exit code 3), and a type created in the last minutes has none yet. OWNER is an instance’s owner, by default who created it (EMPLOYEE, CUSTOMER or SERVICE, and the user or client id); attribute values (mixins) are only in -o json. epx requests the scope of the type, not the tenant-wide schema.custominstance_read that Emporix also accepts. Requires the custom.<type>_read scope. <type> is the custom entity type in lower case (custom.document_read for DOCUMENT). Command: epx custom-entities instances list CUSTOM_ENTITY_ID [flags] Flags
  • --columns <names>
    Print only these columns of table and csv, in this order: comma-separated names (any case) among ID, NAME, OWNER, VERSION.
  • --language <language>
    Language of localized table text; a missing translation shows another, labeled (-o json prints all). Default: en.
  • --limit <n>
    Print at most n items; paged reads stop early where they safely can (0: every item).
  • --no-headers
    Print table and csv without the header row.
  • -o, --output <format>
    Output format: table, json, yaml or csv (csv: the table’s rows; json and yaml: the whole response). Default: table.
  • --query <filter>
    Emporix q filter, passed as given, e.g. code:(A1,A2); space-separated conditions must all match (fields mostly as in -o json).
  • --sort <order>
    Emporix sort order, passed as given, e.g. code or name.en:desc,code; fields mostly as in -o json (Emporix may ignore an unknown one).
  • --stream
    Print items as JSON Lines as soon as they are checked, page by page on paged lists, reading up to 10000 pages where a list without it stops after 1000: a check failing on a later page exits 1 after the pages before it (excludes -o, --columns and --no-headers).
Also takes the global flags.

​
epx custom-entities instances patch

Change an instance of a custom entity type. Changes the instance ID of the custom entity type CUSTOM_ENTITY_ID with the JSON array of JSON Patch (RFC 6902) operations in --file, such as [{"op": "replace", "path": "/name", "value": {"en": "Report"}}]; an add whose path ends in /- appends to an array. An unknown ID is not found. CUSTOM_ENTITY_ID is the ID that epx custom-entities list shows, and ID the one that epx custom-entities instances list CUSTOM_ENTITY_ID shows. Emporix checks the items that the references of the instance name (unless --validate-references false) with epx’s token, which reads the instances of CUSTOM_ENTITY_ID alone: a reference to an instance of another custom entity type is then expected to fail with 400 Bad Request, as one to the type fails without that scope, and one to another kind of item, such as a product, may fail too. Localized text in the body is a map of translations, e.g. {"en": "Acme", "de": "Acme"}, as -o json of a read prints it, sent with Content-Language: *. Emporix refuses a string in its place. Changes data: on a terminal, epx asks before it sends PATCH. --yes sends without asking (required without a terminal, or with --file -); --dry-run prints the request instead of sending it. Where --validate-references is true or not given, epx also requests the custom.<type>_read scope. Requires the custom.<type>_manage scope. <type> is the custom entity type in lower case (custom.document_manage for DOCUMENT). Command: epx custom-entities instances patch CUSTOM_ENTITY_ID ID [flags] Flags
  • --dry-run
    Print the request instead of sending it (excludes -o).
  • --file <PATH>
    JSON request body in PATH, sent byte for byte (- reads standard input; sending it then needs --yes; required).
  • -o, --output <format>
    Format of the response: json or yaml. Default: json.
  • --validate-references <string>
    Whether Emporix checks that the items that references in the body name exist (true without it), requesting custom.<type>_read where it is true or not given: true or false.
  • --yes
    Send without asking (required without a terminal, or with --file -).
Also takes the global flags. Search the instances of a custom entity type. Reads the instances of a custom entity type that an Emporix q filter finds (--query; without it, every one). It reads and shows them as epx custom-entities instances list CUSTOM_ENTITY_ID does. CUSTOM_ENTITY_ID is the ID that epx custom-entities list shows; an unknown one has no scope that Emporix grants (exit code 3), and a type created in the last minutes has none yet. Changes nothing: Emporix serves this read as POST with a JSON body, which the flags make or --body gives whole. OWNER is an instance’s owner, by default who created it (EMPLOYEE, CUSTOMER or SERVICE, and the user or client id); attribute values (mixins) are only in -o json. epx requests the scope of the type, not the tenant-wide schema.custominstance_read that Emporix also accepts. Requires the custom.<type>_read scope. <type> is the custom entity type in lower case (custom.document_read for DOCUMENT). Command: epx custom-entities instances search CUSTOM_ENTITY_ID [flags] Flags
  • --body <FILE>
    Send the JSON request body in FILE as given (- reads standard input) instead of the one the other flags make.
  • --columns <names>
    Print only these columns of table and csv, in this order: comma-separated names (any case) among ID, NAME, OWNER, VERSION.
  • --language <language>
    Language of localized table text; a missing translation shows another, labeled (-o json prints all). Default: en.
  • --limit <n>
    Print at most n items; paged reads stop early where they safely can (0: every item).
  • --no-headers
    Print table and csv without the header row.
  • -o, --output <format>
    Output format: table, json, yaml or csv (csv: the table’s rows; json and yaml: the whole response). Default: table.
  • --query <filter>
    Emporix q filter, sent as given in the request body, not in the URL (empty: no filter), e.g. code:(A1,A2); space-separated conditions must all match (fields mostly as in -o json).
  • --sort <order>
    Emporix sort order, passed as given, e.g. code or name.en:desc,code; fields mostly as in -o json (Emporix may ignore an unknown one).
  • --stream
    Print items as JSON Lines as soon as they are checked, page by page on paged lists, reading up to 10000 pages where a list without it stops after 1000: a check failing on a later page exits 1 after the pages before it (excludes -o, --columns and --no-headers).
Also takes the global flags.

​
epx custom-entities instances update

Upsert an instance of a custom entity type. Replaces the instance ID of the custom entity type CUSTOM_ENTITY_ID with the JSON object in --file, as create takes it without the id, or creates it with that id where none exists (an upsert). With metadata.version, as epx custom-entities instances get CUSTOM_ENTITY_ID ID -o json prints it, Emporix replaces only that version: an older one is a conflict. CUSTOM_ENTITY_ID is the ID that epx custom-entities list shows, and ID the one that epx custom-entities instances list CUSTOM_ENTITY_ID shows. Emporix checks the items that the references of the instance name (unless --validate-references false) with epx’s token, which reads the instances of CUSTOM_ENTITY_ID alone: a reference to an instance of another custom entity type is then expected to fail with 400 Bad Request, as one to the type fails without that scope, and one to another kind of item, such as a product, may fail too. Localized text in the body is a map of translations, e.g. {"en": "Acme", "de": "Acme"}, as -o json of a read prints it, sent with Content-Language: *. Emporix refuses a string in its place. Changes data: on a terminal, epx asks before it sends PUT. --yes sends without asking (required without a terminal, or with --file -); --dry-run prints the request instead of sending it. Where --validate-references is true or not given, epx also requests the custom.<type>_read scope. Requires the custom.<type>_manage scope. <type> is the custom entity type in lower case (custom.document_manage for DOCUMENT). Command: epx custom-entities instances update CUSTOM_ENTITY_ID ID [flags] Flags
  • --dry-run
    Print the request instead of sending it (excludes -o).
  • --file <PATH>
    JSON request body in PATH, sent byte for byte (- reads standard input; sending it then needs --yes; required).
  • -o, --output <format>
    Format of the response: json or yaml. Default: json.
  • --validate-references <string>
    Whether Emporix checks that the items that references in the body name exist (true without it), requesting custom.<type>_read where it is true or not given: true or false.
  • --yes
    Send without asking (required without a terminal, or with --file -).
Also takes the global flags.

​
epx custom-entities list

List custom entity types. Reads custom entity types: entities a tenant defines. epx custom-entities instances reads and changes the instances of a type. No OAuth scope is needed. Command: epx custom-entities list [flags] Flags
  • --columns <names>
    Print only these columns of table and csv, in this order: comma-separated names (any case) among ID, NAME, VERSION.
  • --language <language>
    Language of localized table text; a missing translation shows another, labeled (-o json prints all). Default: en.
  • --limit <n>
    Print at most n items; paged reads stop early where they safely can (0: every item).
  • --no-headers
    Print table and csv without the header row.
  • -o, --output <format>
    Output format: table, json, yaml or csv (csv: the table’s rows; json and yaml: the whole response). Default: table.
  • --query <filter>
    Emporix q filter, passed as given, e.g. code:(A1,A2); space-separated conditions must all match (fields mostly as in -o json).
  • --sort <order>
    Emporix sort order, passed as given, e.g. code or name.en:desc,code; fields mostly as in -o json (Emporix may ignore an unknown one).
  • --stream
    Print items as JSON Lines as soon as they are checked, page by page on paged lists, reading up to 10000 pages where a list without it stops after 1000: a check failing on a later page exits 1 after the pages before it (excludes -o, --columns and --no-headers).
Also takes the global flags.

​
epx custom-entities update

Upsert a custom entity type. Replaces the name of the custom entity type ID with the one in --file, a JSON object such as {"name": {"en": "Document"}, "metadata": {"version": 1}}, or creates the type where none exists (an upsert). With metadata.version, as epx custom-entities get ID -o json prints it, Emporix replaces only that version: an older one is a conflict. Localized text in the body is a map of translations, e.g. {"en": "Acme", "de": "Acme"}, as -o json of a read prints it, sent with Content-Language: *. Emporix refuses a string in its place. Changes data: on a terminal, epx asks before it sends PUT. --yes sends without asking (required without a terminal, or with --file -); --dry-run prints the request instead of sending it. Requires the schema.schema_manage scope. Command: epx custom-entities update ID [flags] Flags
  • --dry-run
    Print the request instead of sending it (excludes -o).
  • --file <PATH>
    JSON request body in PATH, sent byte for byte (- reads standard input; sending it then needs --yes; required).
  • -o, --output <format>
    Format of the response: json or yaml. Default: json.
  • --yes
    Send without asking (required without a terminal, or with --file -).
Also takes the global flags.