Version: 8
restore

Contents

Introduction

On this page we will learn how to browse instruction definitions available in your Tachyon installation.

We will assume that instruction definitions have already been uploaded into Tachyon and organised into Instruction Sets (please refer to Add and Remove Instruction definitions and organise them into instruction sets), with all necessary permissions assigned (please refer to Set up Principals, Roles and Permissions).

C# examples assume you are using Tachyon Consumer SDK and assume that you already have a correctly instantiated instance of Tachyon connector class in an object called 'connector'.

Another thing to remember is that all SDK methods return the same class called ApiCallResponse. Inside the object of that class you'll find a property called ReceivedObject. That object is the actual data received from the API. We will be omitting this detail in the examples and simply saying that the return object contains the data. So when we're saying that XYZ object will contain such-and-such data, what we mean in that the ReceivedObject contains that data, since that is always the case.

When this page mentions permissions on instructions, what it means is Instruction set permissions and not Instruction set management permissions, as those are a separate category of permissions. Instruction set permissions gain Principals access to all instructions within a specific set or all sets.

It is possible to have a permission on given, or even all, Instruction sets, thus being able to issue instructions without being able to manage the instruction sets, so without having instruction set management permissions.

The reverse is also possible and the Principal that is allowed to assign instruction definitions to instruction set may not have permission to issue any of those instructions.

What is an instruction definition?

An instruction definition is a template that is used to create instructions that are then sent to devices running Tachyon Agent for processing.

Instruction definition defines what should the agent do when executing the instruction, what data is returned and if its aggregated, what the parameters for the instruction are, how to present the results to the user and so on.

When an instruction is being issued, some information is copied from the definition that the instruction is based on (like instruction name and type) while other come from information provided with the request to issue the instruction. Please refer to Issue an instruction, track its progress and retrieve responses for details.

What properties can be used to uniquely identify an instruction definition?

Instruction definition has two properties that can be used to identify it.

The first is the Id, which is a number assigned to the instruction definition when it is imported into Tachyon. This means that you cannot foresee it before the instruction is imported and it will be different between Tachyon installations. Also, if you remove the instruction definition and then import it again in the future, it will be given a different Id to the one it had before.

The second property is the name, which must be unique within given installation of Tachyon. An attempt to import and instruction definition with the same name as one that already exists is treated as an upgrade attempt of the existing instruction definition.

The API allows you to use both Id and Name when locating specific instruction definition or issuing an instruction.

How to uniquely identify an instruction?

Instructions can only be identified by their Id, which is assigned when an instruction is created (issued).

They cannot be located by Name, because that it is not unique. Every instruction based on the same instruction definition will have the same name.

How is an instruction created from an instruction definition

Although full details of this process are outside the scope of this page we will cover the basics.

When an instruction is created (which is also called issuing an instruction), the following will happen:

  • The name of the instruction definition will be copied into the newly created instruction
  • The payload and readable payload will be copied into the newly created instruction. Any parameters (provided by the issuer of the instruction), environment variables and global settings will be filled in.
  • Instruction TTL and Response TTL are filled with the values provided by the issuer of the instruction
  • Schema and Aggregation schema are copied from the instruction definition
  • Scope provided by the issuer of the instruction is combined with any compulsory scope resulting from issuing Principal permissions.

although this is not an exhaustive list.

Searching for instruction definitions

Instruction definitions are retrieved for two reasons - to issue instructions and to manage instructions within instruction sets.

When instruction definitions are retrieved for the reason of issuing an instruction, instruction set related permissions of the Principal have to be taken into account. Those permissions will limit which instructions the caller is allowed to issue. This limitation will be enforced by the API endpoint.

When instruction definitions are retrieved fro the reason of managing instruction sets, the Principal retrieving them requires permission to manage instruction sets and doesn't need to have any permissions to the instructions themselves.

This is important because if you retrieve all instruction definitions using the endpoint designed for instruction set management, you might not be able to issue all of those instructions because the list you receive will not be filtered down using your permissions.

Retrieving all instruction definitions

In this example we'll retrieve all instruction definitions that we can issue.

Direct Consumer API callC# code using Consumer SDK library

Making a GET request to https://my.tachyon.server/Consumer/InstructionDefinitions

Response received from https://my.tachyon.server/Consumer/InstructionDefinitions
[{
    "Id": 1,
    "Name": "1E-Explorer-Examples-CountEventLogErrorsInLastX",
    "Description": "Returns event log entries aggregated on event ID (EventCode) of a specified type in the a specified Windows event log in the last few days. Specifying a long period may result in a large amount of data from each agent.",
    "InstructionSetId": 2,
    "InstructionSetName": "Wszystko",
    "InstructionType": 0,
    "ReadablePayload": "Which event IDs of type %type% have been logged in the Windows %logname% event log in the last %numDays% days?",
    "Parameters": [{
        "Name": "type",
        "Pattern": "%type%",
        "DataType": "string",
        "ControlType": "valuePicker",
        "ControlMetadata": null,
        "Placeholder": "event type",
        "DefaultValue": null,
        "Validation": {
            "Regex": null,
            "MaxLength": null,
            "AllowedValues": ["information",
            "warning",
            "error"],
            "NumValueRestrictions": null
        },
        "Value": null,
        "HintText": null,
        "Source": null
    },
    {
        "Name": "logname",
        "Pattern": "%logname%",
        "DataType": "string",
        "ControlType": "valuePicker",
        "ControlMetadata": null,
        "Placeholder": "log name'",
        "DefaultValue": null,
        "Validation": {
            "Regex": null,
            "MaxLength": null,
            "AllowedValues": ["application",
            "security",
            "setup",
            "system"],
            "NumValueRestrictions": null
        },
        "Value": null,
        "HintText": null,
        "Source": null
    },
    {
        "Name": "numDays",
        "Pattern": "%numDays%",
        "DataType": "int",
        "ControlType": "freeText",
        "ControlMetadata": null,
        "Placeholder": "number of days",
        "DefaultValue": null,
        "Validation": {
            "Regex": null,
            "MaxLength": null,
            "AllowedValues": null,
            "NumValueRestrictions": null
        },
        "Value": null,
        "HintText": null,
        "Source": null
    }],
    "Schema": [{
        "Name": "Category",
        "Type": "int64",
        "Length": 0,
        "RenderAs": null
    },
    {
        "Name": "CategoryString",
        "Type": "String",
        "Length": 256,
        "RenderAs": null
    },
    {
        "Name": "EventCode",
        "Type": "int64",
        "Length": 0,
        "RenderAs": null
    },
    {
        "Name": "EventIdentifier",
        "Type": "int64",
        "Length": 0,
        "RenderAs": null
    },
    {
        "Name": "Message",
        "Type": "String",
        "Length": 4096,
        "RenderAs": null
    },
    {
        "Name": "RecordNumber",
        "Type": "int64",
        "Length": 0,
        "RenderAs": null
    },
    {
        "Name": "SourceName",
        "Type": "String",
        "Length": 256,
        "RenderAs": null
    },
    {
        "Name": "GeneratedTimeStamp",
        "Type": "datetime",
        "Length": 0,
        "RenderAs": null
    },
    {
        "Name": "User",
        "Type": "String",
        "Length": 256,
        "RenderAs": null
    }],
    "Aggregation": {
        "Schema": [{
            "Name": "EventCode",
            "Type": "int64",
            "Length": 0,
            "RenderAs": null
        },
        {
            "Name": "Count",
            "Type": "int32",
            "Length": 0,
            "RenderAs": null
        }],
        "GroupBy": "EventCode",
        "Operations": [{
            "Name": "Count",
            "Type": "count"
        }]
    },
    "InstructionTtlMinutes": 30,
    "ResponseTtlMinutes": 30,
    "MinimumInstructionTtlMinutes": 10,
    "MaximumInstructionTtlMinutes": 10080,
    "MinimumResponseTtlMinutes": 10,
    "MaximumResponseTtlMinutes": 10080,
    "Workflow": null,
    "ResponseTemplateId": 1,
    "OriginalFileName": null,
    "ResponseTemplateConfiguration": {
        "Name": "default",
        "TemplateConfigurations": [{
            "Id": "leftpie",
            "Title": "Number of EventIds across devices",
            "Type": "Pie",
            "X": "EventCode",
            "Y": "Count",
            "PostProcessor": "processingFunction",
            "Size": 1,
            "Row": 1
        }],
        "PostProcessors": [{
            "Name": "processingFunction",
            "Function": "ProcessSingleSeries('EventCode', 'Count', '9', 'Number of events', 'true')"
        }]
    },
    "Version": "3",
    "Author": "1E",
    "IsLicensed": true,
    "UploadedTimestampUtc": "2019-03-19T10:14:32.227Z",
    "NumberOfTimesExecuted": 0,
    "Executable": true
},
{
    "Id": 2,
    "Name": "1E-Explorer-Examples-DeleteCertificates",
    "Description": "Deletes all certificates with a given SHA1 thumbprint in the 'local machine' certificate store for these stores: Personal (My), Intermediate Certification Authorities (CA), Trusted Root Certification Authorities (Root), Third-Party Certification Authorities (AuthRoot), Enterprise Trust (Trust), Other People (AddressBook), Trusted People (TrustedPeople), Trusted Publishers (TrustedPublisher) and Untrusted Certificates (Disallowed). Certificates are not retrievable once marked for deletion. Please use with caution - deleting a certificate may case a number of things to stop working.",
    "InstructionSetId": 2,
    "InstructionSetName": "Wszystko",
    "InstructionType": 1,
    "ReadablePayload": "Delete all certificates with a SHA1 thumbprint of %thumbprint% from the 'local machine' certificate store.",
    "Parameters": [{
        "Name": "thumbprint",
        "Pattern": "%thumbprint%",
        "DataType": "string",
        "ControlType": "freeText",
        "ControlMetadata": null,
        "Placeholder": "thumbprint",
        "DefaultValue": null,
        "Validation": {
            "Regex": null,
            "MaxLength": "256",
            "AllowedValues": null,
            "NumValueRestrictions": null
        },
        "Value": null,
        "HintText": null,
        "Source": null
    }],
    "Schema": [{
        "Name": "Subject",
        "Type": "String",
        "Length": 256,
        "RenderAs": null
    },
    {
        "Name": "Thumbprint",
        "Type": "String",
        "Length": 128,
        "RenderAs": null
    },
    {
        "Name": "StoreName",
        "Type": "String",
        "Length": 256,
        "RenderAs": null
    },
    {
        "Name": "DeletionTime",
        "Type": "String",
        "Length": 256,
        "RenderAs": null
    }],
    "Aggregation": null,
    "InstructionTtlMinutes": 60,
    "ResponseTtlMinutes": 120,
    "MinimumInstructionTtlMinutes": 10,
    "MaximumInstructionTtlMinutes": 10080,
    "MinimumResponseTtlMinutes": 10,
    "MaximumResponseTtlMinutes": 10080,
    "Workflow": null,
    "ResponseTemplateId": null,
    "OriginalFileName": null,
    "ResponseTemplateConfiguration": null,
    "Version": "3",
    "Author": "1E",
    "IsLicensed": true,
    "UploadedTimestampUtc": "2019-03-19T10:14:32.227Z",
    "NumberOfTimesExecuted": 0,
    "Executable": true
}]

The payload has been trimmed to just two entries to give you an example of what can be expected, but chances are in your installation of Tachyon there will be a lot more instruction definitions, perhaps well into hundreds.

Use InstructionDefinitions object inside the Tachyon connector instance.

Retrieving all instruction definitions the caller has permissions to
var definitions = connector.InstructionDefinitions.Get(null);

Definitions object will contain the same data you can see in the JSON response on the left.

Retrieving only instruction definitions of a specific type

In some cases, you may want to retrieve all instruction definitions of a given type that you can issue. This is used, for instance, by Explorer on the Follow-up question and Follow-up action tabs on the instruction details page.

This can be achieved by using the optional query string parameter on the same call as the one made we made in the last example.

Let's look at an example where we get only the Questions we're allowed to issue.

Direct Consumer API callC# code using Consumer SDK library

Make a GET request to https://my.tachyon.server/Consumer/InstructionDefinitions?instructionType=question

The return payload will have the same structure as the payload seen when we were retrieving all the instruction definitions in the previous example.

Use InstructionDefinitions object inside the Tachyon connector instance.

Retrieving all instruction definitions of a specific type that the caller is allowed to issue
var definitions = connector.InstructionDefinitions.Get(new List<InstructionType>{InstructionType.Question});

Definitions object will contain information very similar to what we've see in the previous example.

Retrieving all instruction definitions regardless of caller's permissions

As mentioned above, retrieving all definitions should only be used when managing instruction sets.

Direct Consumer API callC# code using Consumer SDK library

Making a GET request to https://my.tachyon.server/Consumer/InstructionDefinitions/All

The return payload will have the same structure as the payload seen when we were retrieving all the instruction definitions in the previous examples.

Use InstructionDefinitions object inside the Tachyon connector instance.

Retrieving all instruction definitions in the system, regardless of caller's permissions
var definitions = connector.InstructionDefinitions.GetAllInstructionDefinitions();
Definitions object will contain information very similar to what we've see in previous examples.

It is also worth remembering that this endpoint requires Instruction set management related permissions to work.

Using search-as-you-type feature

This is the feature seen on Explorer's home page "I want to know" in form of a search box, into which you can type text and Tachyon will return instruction definitions you have permissions to use that match the string entered into the search box.

The match is done by searching for the words (defined as a string of characters separated by a space) in instruction definition's readable payload (which is what the Explorer displays after you've picked up an instruction definition) and description (which Explorer displays in the tooltip available after an instruction definition has been selected).

In our example, we'll look for the word "bios" and retrieve all instruction definitions that contain that word in either description or readable payload.

Direct Consumer API callC# code using Consumer SDK library

Making a GET request to https://my.tachyon.server/Consumer/InstructionDefinitions/Search/Ymlvcw== will yield result similar to following:

{
    "Result": 0,
    "Error": null,
    "Instructions": [
        {
            "Id": 66,
            "Name": "1E-Explorer-TachyonCore-BiosDetails",
            "ReadableName": "What BIOS firmware is installed?",
            "Description": "Returns details of BIOS firmware.",
            "Category": "SomeCategory",
            "WordMatchCount": 1,
            "InstructionType": 0,
            "InstructionTtlMinutes": 60,
            "ResponseTtlMinutes": 60,
            "ParameterHints": null,
            "Aggregatable": true,
            "IsLicensed": true,
            "NumberOfTimesExecuted": 0,
            "Executable": null
        }
    ]
}

Use InstructionDefinitions object inside the Tachyon connector instance.

Retrieving instruction definitions matching a search term
var definitions = connector.InstructionDefinitions.FindInstructions("bios");

Definitions object will contain the same data you can see in the JSON response on the left.

Entries for Instruction definitions returned by this endpoint contain only part of the data for performance reasons. After all, this is meant to be a search-as-you-type feature so the data must be returned quickly.

Searching for instruction definitions that match specific criteria

When managing instruction sets you can also use an endpoint that allows instruction definitions to be filtered, sorted and paginated. This endpoint, like the one that allows you to retrieve all instructions regardless of calling Principal's permissions, requires permissions related to instruction set management to work.

In this example, we will look for all instruction definitions that contain the word "bios" in their name. Although on the surface it looks the same as the search-as-you-type scenario, it is looking exclusively on the Name, and not on the readable payload or the description, because our search parameters only specify the name.

Direct Consumer API callC# code using Consumer SDK library

Making a POST request to 
https://my.tachyon.server/Consumer/InstructionDefinitions/Search with following payload:

{
  "Start": 1,
  "PageSize": 200,
  "Filter": {
    "Attribute": "Name",
    "Operator": "LIKE",
    "Value": "%bios%"
  }
}

will yield a response similar to the one below:

Return payload
{
    "TotalCount": 1,
    "Items": [
        {
            "Id": 66,
            "Name": "1E-Explorer-TachyonCore-BiosDetails",
            "Description": "Returns details of BIOS firmware.",
            "InstructionSetId": 2,
            "InstructionSetName": "Wszystko",
            "InstructionType": 0,
            "ReadablePayload": "What BIOS firmware is installed?",
            "Parameters": null,
            "Schema": [
                {
                    "Name": "BIOSVersion",
                    "Type": "string",
                    "Length": 512,
                    "RenderAs": null
                },
                {
                    "Name": "Caption",
                    "Type": "string",
                    "Length": 512,
                    "RenderAs": null
                },
                {
                    "Name": "Manufacturer",
                    "Type": "string",
                    "Length": 512,
                    "RenderAs": null
                },
                {
                    "Name": "PrimaryBIOS",
                    "Type": "bool",
                    "Length": 0,
                    "RenderAs": null
                },
                {
                    "Name": "ReleaseDate",
                    "Type": "datetime",
                    "Length": 0,
                    "RenderAs": null
                },
                {
                    "Name": "SerialNumber",
                    "Type": "string",
                    "Length": 512,
                    "RenderAs": null
                }
            ],
            "Aggregation": {
                "Schema": [
                    {
                        "Name": "Manufacturer",
                        "Type": "string",
                        "Length": 512,
                        "RenderAs": null
                    },
                    {
                        "Name": "BIOSVersion",
                        "Type": "string",
                        "Length": 512,
                        "RenderAs": null
                    },
                    {
                        "Name": "Count",
                        "Type": "int64",
                        "Length": 0,
                        "RenderAs": null
                    }
                ],
                "GroupBy": "Manufacturer,BIOSVersion",
                "Operations": [
                    {
                        "Name": "Count",
                        "Type": "count"
                    }
                ]
            },
            "InstructionTtlMinutes": 60,
            "ResponseTtlMinutes": 60,
            "MinimumInstructionTtlMinutes": 10,
            "MaximumInstructionTtlMinutes": 10080,
            "MinimumResponseTtlMinutes": 10,
            "MaximumResponseTtlMinutes": 10080,
            "Workflow": null,
            "ResponseTemplateId": 1,
            "OriginalFileName": null,
            "ResponseTemplateConfiguration": {
                "Name": "default",
                "TemplateConfigurations": [
                    {
                        "Id": "mainchart",
                        "Title": "Most common BIOS manufacturers and versions",
                        "Type": "Bar",
                        "X": "BIOSVersion",
                        "Y": "Count",
                        "Z": "Manufacturer",
                        "PostProcessor": "processingFunction",
                        "Size": 1,
                        "Row": 1
                    }
                ],
                "PostProcessors": [
                    {
                        "Name": "processingFunction",
                        "Function": "ProcessMultiSeries('BIOSVersion', 'Count', 'Manufacturer', '5', '5', 'false')"
                    }
                ]
            },
            "Version": "3",
            "Author": "1E",
            "IsLicensed": true,
            "UploadedTimestampUtc": "2019-03-19T10:14:39.363Z",
            "NumberOfTimesExecuted": 0,
            "Executable": null
        }
    ]
}

Use InstructionDefinitions object inside the Tachyon connector instance.

Retrieving filtered, sorted and paginated instruction definitions
var settings = new Search
{
    PageSize = 200,
    Start = 1,
    Filter = new ExpressionObject
    {
        Attribute = "Name",
        Operator = "LIKE",
        Value = "%bios%"
    }
};

var definitions = connector.InstructionDefinitions.FindInstructions(settings);

Definitions object will contain the same data you can see in the JSON response on the left.

But what if you wanted to search the same way as search-as-you-type feature?

You can do that by adjusting the search criteria to include Readable payload and Description columns.

Direct Consumer API callC# code using Consumer SDK library

Making a POST request to 
https://my.tachyon.server/Consumer/InstructionDefinitions/Search with following payload:

{
    "Start": 1,
    "PageSize": 200,
    "Filter": {
        "Operator": "OR",
        "Operands": [{
            "Attribute": "Name",
            "Operator": "LIKE",
            "Value": "%bios%"
        },
        {
            "Attribute": "Description",
            "Operator": "LIKE",
            "Value": "%bios%"
        },
        {
            "Attribute": "ReadablePayload",
            "Operator": "LIKE",
            "Value": "%bios%"
        }]
    }
}

will yield a response similar to the one below:

Return payload
{
    "TotalCount": 1,
    "Items": [
        {
            "Id": 66,
            "Name": "1E-Explorer-TachyonCore-BiosDetails",
            "Description": "Returns details of BIOS firmware.",
            "InstructionSetId": 2,
            "InstructionSetName": "Wszystko",
            "InstructionType": 0,
            "ReadablePayload": "What BIOS firmware is installed?",
            "Parameters": null,
            "Schema": [
                {
                    "Name": "BIOSVersion",
                    "Type": "string",
                    "Length": 512,
                    "RenderAs": null
                },
                {
                    "Name": "Caption",
                    "Type": "string",
                    "Length": 512,
                    "RenderAs": null
                },
                {
                    "Name": "Manufacturer",
                    "Type": "string",
                    "Length": 512,
                    "RenderAs": null
                },
                {
                    "Name": "PrimaryBIOS",
                    "Type": "bool",
                    "Length": 0,
                    "RenderAs": null
                },
                {
                    "Name": "ReleaseDate",
                    "Type": "datetime",
                    "Length": 0,
                    "RenderAs": null
                },
                {
                    "Name": "SerialNumber",
                    "Type": "string",
                    "Length": 512,
                    "RenderAs": null
                }
            ],
            "Aggregation": {
                "Schema": [
                    {
                        "Name": "Manufacturer",
                        "Type": "string",
                        "Length": 512,
                        "RenderAs": null
                    },
                    {
                        "Name": "BIOSVersion",
                        "Type": "string",
                        "Length": 512,
                        "RenderAs": null
                    },
                    {
                        "Name": "Count",
                        "Type": "int64",
                        "Length": 0,
                        "RenderAs": null
                    }
                ],
                "GroupBy": "Manufacturer,BIOSVersion",
                "Operations": [
                    {
                        "Name": "Count",
                        "Type": "count"
                    }
                ]
            },
            "InstructionTtlMinutes": 60,
            "ResponseTtlMinutes": 60,
            "MinimumInstructionTtlMinutes": 10,
            "MaximumInstructionTtlMinutes": 10080,
            "MinimumResponseTtlMinutes": 10,
            "MaximumResponseTtlMinutes": 10080,
            "Workflow": null,
            "ResponseTemplateId": 1,
            "OriginalFileName": null,
            "ResponseTemplateConfiguration": {
                "Name": "default",
                "TemplateConfigurations": [
                    {
                        "Id": "mainchart",
                        "Title": "Most common BIOS manufacturers and versions",
                        "Type": "Bar",
                        "X": "BIOSVersion",
                        "Y": "Count",
                        "Z": "Manufacturer",
                        "PostProcessor": "processingFunction",
                        "Size": 1,
                        "Row": 1
                    }
                ],
                "PostProcessors": [
                    {
                        "Name": "processingFunction",
                        "Function": "ProcessMultiSeries('BIOSVersion', 'Count', 'Manufacturer', '5', '5', 'false')"
                    }
                ]
            },
            "Version": "3",
            "Author": "1E",
            "IsLicensed": true,
            "UploadedTimestampUtc": "2019-03-19T10:14:39.363Z",
            "NumberOfTimesExecuted": 0,
            "Executable": null
        }
    ]
}


Use InstructionDefinitions object inside the Tachyon connector instance.

Retrieving instruction definitions with the word "bios" in the name, description or readable payloyad
var settings = new Search
{
    PageSize = 200,
    Start = 1,
    Filter = new ExpressionObject
    {
        Operator = "OR",
        Operands = new List<ExpressionObject>
        {
            new ExpressionObject
            {
                Attribute = "Name",
                Operator = "LIKE",
                Value = "%bios%"
            },
            new ExpressionObject
            {
                Attribute = "Description",
                Operator = "LIKE",
                Value = "%bios%"
            },
            new ExpressionObject
            {
                Attribute = "ReadablePayload",
                Operator = "LIKE",
                Value = "%bios%"
            }
        }
    }
};

var definitions = connector.InstructionDefinitions.FindInstructions(settings);

Definitions object will contain the same data you can see in the JSON response on the left.

Searching for instruction definitions when issuing a follow-up instruction

When an instruction is to be issued as a follow up to another instruction, additional conditions need to be taken into account.

If you were to simply retrieve all definitions like we did above, although you would get a list of instruction definitions that you, the caller, have permission to, but you would ignore all restrictions coming from the instruction that will be the parent (the instruction you're following up on). Those restrictions stem from permissions of whoever issued the instruction you're about to follow up on and you need to use another endpoint to make sure you're searching for instruction definitions in the right context.

Retrieving all instruction definitions that can be used to issue a follow-up

You can retrieve all definitions you have permission to, much like you did here, in context of a follow-up instruction.

For this example, let's assume you will be following up on an instruction with the Id of 12. What that instruction is we will consider irrelevant for this example and focus purely on establishing what instruction definitions can be used for follow-up.

Direct Consumer API callC# code using Consumer SDK library

Make a GET request to https://my.tachyon.server/Consumer/InstructionDefinitions/Parent/12 to retrieve all instruction definitions that the caller can issue as a follow-up.

The return payload will have the same structure as the payload seen when we were retrieving all the instruction definitions in the previous example.

If you want to only get instruction definitions of a specific type, you can add a query string parameter like you did here.

For instance, if you wanted to get all Actions you'd make this GET request: https://my.tachyon.server/Consumer/InstructionDefinitions/Parent/12?instructionType=action

Use InstructionDefinitions object inside the Tachyon connector instance.

object will contain the same data you can see in the JSON response on the left.

Searching for feasible follow-up instruction definitions that match specific criteria

You can also use a type-as you search endpoint, akin to what we did here.

Direct Consumer API callC# code using Consumer SDK library

Making a POST request to will yield following response:

Use InstructionDefinitions object inside the Tachyon connector instance.

object will contain the same data you can see in the JSON response on the left.

Retrieving specific instruction definition

You can also attempt to retrieve a specific definition, either by its Id or Name.

Direct Consumer API callC# code using Consumer SDK library

Making a POST request to will yield following response:

Use InstructionDefinitions object inside the Tachyon connector instance.

object will contain the same data you can see in the JSON response on the left.

Direct Consumer API callC# code using Consumer SDK library

Making a POST request to will yield following response:

Use InstructionDefinitions object inside the Tachyon connector instance.

object will contain the same data you can see in the JSON response on the left.