DebugAdapterProtocolGenerated.pmod

// This source has been automatically generated by quicktype.
// ( https://github.com/quicktype/quicktype )
//
// To use this code, simply import it into your project as a Pike module.
// To JSON-encode your object, you can pass it to `Standards.JSON.encode`
// or call `encode_json` on it.
//
// To decode a JSON string, first pass it to `Standards.JSON.decode`,
// and then pass the result to `<YourClass>_from_JSON`.
// It will return an instance of <YourClass>.
// Bear in mind that these functions have unexpected behavior,
// and will likely throw an error, if the JSON string does not
// match the expected interface, even if the JSON itself is valid.

typedef mapping(string:mixed) ConfigurationDoneArguments;

ConfigurationDoneArguments ConfigurationDoneArguments_from_JSON(mixed json) {
    mapping(string:mixed) retval = ([]);
    foreach (json; string k; mixed v) {
        retval[k] = (mixed) v;
    }
    return retval;
}

typedef mapping(string:mixed) RestartArguments;

RestartArguments RestartArguments_from_JSON(mixed json) {
    mapping(string:mixed) retval = ([]);
    foreach (json; string k; mixed v) {
        retval[k] = (mixed) v;
    }
    return retval;
}

typedef mapping(string:mixed) LoadedSourcesArguments;

LoadedSourcesArguments LoadedSourcesArguments_from_JSON(mixed json) {
    mapping(string:mixed) retval = ([]);
    foreach (json; string k; mixed v) {
        retval[k] = (mixed) v;
    }
    return retval;
}

// Base class of requests, responses, and events.
class ProtocolMessage {
    int    seq;  // json: "seq"
    string type; // json: "type"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
        ]);

        return Standards.JSON.encode(json);
    }
}

ProtocolMessage ProtocolMessage_from_JSON(mixed json) {
    ProtocolMessage retval = ProtocolMessage();

    retval.seq = json["seq"];
    retval.type = json["type"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
class Request {
    int    seq;       // json: "seq"
    mixed  type;      // json: "type"
    mixed  arguments; // json: "arguments"
    string command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

Request Request_from_JSON(mixed json) {
    Request retval = Request();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Object containing arguments for the command.
//
// Event-specific information.
//
// Contains request result if success is true and optional error details if success is
// false.
//
// A debug adapter may set 'restart' to true (or to an arbitrary object) to request that the
// front end restarts the session.
// The value is not interpreted by the client and passed unmodified as an attribute
// '__restart' to the 'launch' and 'attach' requests.
//
// Optional data to report. For the 'telemetry' category the data will be sent to telemetry,
// for the other categories the data is shown in JSON format.
//
// Optional data that a debug adapter might want to loop through the client. The client
// should leave the data intact and persist it across sessions. The client should not
// interpret the data.
//
// Optional data from the previous, restarted session.
// The data is sent as the 'restart' attribute of the 'terminated' event.
// The client should leave the data intact.
typedef array(mixed)|mapping(string:mixed)|bool|float|int|string Arguments;

Arguments Arguments_from_JSON(mixed json) {
    return json;
}

constant REQUEST = "request"; // json: "request"

// Base class of requests, responses, and events.
//
// A debug adapter initiated event.
class Event {
    int    seq;   // json: "seq"
    mixed  type;  // json: "type"
    mixed  body;  // json: "body"
    string event; // json: "event"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "event" : event,
        ]);

        return Standards.JSON.encode(json);
    }
}

Event Event_from_JSON(mixed json) {
    Event retval = Event();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.event = json["event"];

    return retval;
}

constant EVENT = "event"; // json: "event"

// Base class of requests, responses, and events.
//
// Response for a request.
class Response {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

Response Response_from_JSON(mixed json) {
    Response retval = Response();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

constant RESPONSE = "response"; // json: "response"

// Base class of requests, responses, and events.
//
// Response for a request.
//
// On error (whenever 'success' is false), the body can provide more details.
class ErrorResponse {
    int               seq;         // json: "seq"
    mixed             type;        // json: "type"
    ErrorResponseBody body;        // json: "body"
    string            command;     // json: "command"
    mixed             message;     // json: "message"
    int               request_seq; // json: "request_seq"
    bool              success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

ErrorResponse ErrorResponse_from_JSON(mixed json) {
    ErrorResponse retval = ErrorResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class ErrorResponseBody {
    mixed error; // json: "error"

    string encode_json() {
        mapping(string:mixed) json = ([
            "error" : error,
        ]);

        return Standards.JSON.encode(json);
    }
}

ErrorResponseBody ErrorResponseBody_from_JSON(mixed json) {
    ErrorResponseBody retval = ErrorResponseBody();

    retval.error = json["error"];

    return retval;
}

// An optional, structured error message.
//
// A structured message object. Used to return errors from requests.
class Message {
    string format;         // json: "format"
    int    id;             // json: "id"
    mixed  send_telemetry; // json: "sendTelemetry"
    mixed  show_user;      // json: "showUser"
    mixed  url;            // json: "url"
    mixed  url_label;      // json: "urlLabel"
    mixed  variables;      // json: "variables"

    string encode_json() {
        mapping(string:mixed) json = ([
            "format" : format,
            "id" : id,
            "sendTelemetry" : send_telemetry,
            "showUser" : show_user,
            "url" : url,
            "urlLabel" : url_label,
            "variables" : variables,
        ]);

        return Standards.JSON.encode(json);
    }
}

Message Message_from_JSON(mixed json) {
    Message retval = Message();

    retval.format = json["format"];
    retval.id = json["id"];
    retval.send_telemetry = json["sendTelemetry"];
    retval.show_user = json["showUser"];
    retval.url = json["url"];
    retval.url_label = json["urlLabel"];
    retval.variables = json["variables"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A debug adapter initiated event.
//
// This event indicates that the debug adapter is ready to accept configuration requests
// (e.g. SetBreakpointsRequest, SetExceptionBreakpointsRequest).
// A debug adapter is expected to send this event when it is ready to accept configuration
// requests (but not before the 'initialize' request has finished).
// The sequence of events/requests is as follows:
// - adapters sends 'initialized' event (after the 'initialize' request has returned)
// - frontend sends zero or more 'setBreakpoints' requests
// - frontend sends one 'setFunctionBreakpoints' request
// - frontend sends a 'setExceptionBreakpoints' request if one or more
// 'exceptionBreakpointFilters' have been defined (or if 'supportsConfigurationDoneRequest'
// is not defined or false)
// - frontend sends other future configuration requests
// - frontend sends one 'configurationDone' request to indicate the end of the configuration.
class InitializedEvent {
    int   seq;   // json: "seq"
    mixed type;  // json: "type"
    mixed body;  // json: "body"
    mixed event; // json: "event"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "event" : event,
        ]);

        return Standards.JSON.encode(json);
    }
}

InitializedEvent InitializedEvent_from_JSON(mixed json) {
    InitializedEvent retval = InitializedEvent();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.event = json["event"];

    return retval;
}

constant INITIALIZED = "initialized"; // json: "initialized"

// Base class of requests, responses, and events.
//
// A debug adapter initiated event.
//
// The event indicates that the execution of the debuggee has stopped due to some condition.
// This can be caused by a break point previously set, a stepping action has completed, by
// executing a debugger statement etc.
class StoppedEvent {
    int              seq;   // json: "seq"
    mixed            type;  // json: "type"
    StoppedEventBody body;  // json: "body"
    mixed            event; // json: "event"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "event" : event,
        ]);

        return Standards.JSON.encode(json);
    }
}

StoppedEvent StoppedEvent_from_JSON(mixed json) {
    StoppedEvent retval = StoppedEvent();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.event = json["event"];

    return retval;
}

class StoppedEventBody {
    mixed  all_threads_stopped; // json: "allThreadsStopped"
    mixed  description;         // json: "description"
    mixed  preserve_focus_hint; // json: "preserveFocusHint"
    string reason;              // json: "reason"
    mixed  text;                // json: "text"
    mixed  thread_id;           // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "allThreadsStopped" : all_threads_stopped,
            "description" : description,
            "preserveFocusHint" : preserve_focus_hint,
            "reason" : reason,
            "text" : text,
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

StoppedEventBody StoppedEventBody_from_JSON(mixed json) {
    StoppedEventBody retval = StoppedEventBody();

    retval.all_threads_stopped = json["allThreadsStopped"];
    retval.description = json["description"];
    retval.preserve_focus_hint = json["preserveFocusHint"];
    retval.reason = json["reason"];
    retval.text = json["text"];
    retval.thread_id = json["threadId"];

    return retval;
}

constant STOPPED = "stopped"; // json: "stopped"

// Base class of requests, responses, and events.
//
// A debug adapter initiated event.
//
// The event indicates that the execution of the debuggee has continued.
// Please note: a debug adapter is not expected to send this event in response to a request
// that implies that execution continues, e.g. 'launch' or 'continue'.
// It is only necessary to send a 'continued' event if there was no previous request that
// implied this.
class ContinuedEvent {
    int                seq;   // json: "seq"
    mixed              type;  // json: "type"
    ContinuedEventBody body;  // json: "body"
    mixed              event; // json: "event"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "event" : event,
        ]);

        return Standards.JSON.encode(json);
    }
}

ContinuedEvent ContinuedEvent_from_JSON(mixed json) {
    ContinuedEvent retval = ContinuedEvent();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.event = json["event"];

    return retval;
}

class ContinuedEventBody {
    mixed all_threads_continued; // json: "allThreadsContinued"
    int   thread_id;             // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "allThreadsContinued" : all_threads_continued,
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

ContinuedEventBody ContinuedEventBody_from_JSON(mixed json) {
    ContinuedEventBody retval = ContinuedEventBody();

    retval.all_threads_continued = json["allThreadsContinued"];
    retval.thread_id = json["threadId"];

    return retval;
}

constant CONTINUED = "continued"; // json: "continued"

// Base class of requests, responses, and events.
//
// A debug adapter initiated event.
//
// The event indicates that the debuggee has exited and returns its exit code.
class ExitedEvent {
    int             seq;   // json: "seq"
    mixed           type;  // json: "type"
    ExitedEventBody body;  // json: "body"
    mixed           event; // json: "event"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "event" : event,
        ]);

        return Standards.JSON.encode(json);
    }
}

ExitedEvent ExitedEvent_from_JSON(mixed json) {
    ExitedEvent retval = ExitedEvent();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.event = json["event"];

    return retval;
}

class ExitedEventBody {
    int exit_code; // json: "exitCode"

    string encode_json() {
        mapping(string:mixed) json = ([
            "exitCode" : exit_code,
        ]);

        return Standards.JSON.encode(json);
    }
}

ExitedEventBody ExitedEventBody_from_JSON(mixed json) {
    ExitedEventBody retval = ExitedEventBody();

    retval.exit_code = json["exitCode"];

    return retval;
}

constant EXITED = "exited"; // json: "exited"

// Base class of requests, responses, and events.
//
// A debug adapter initiated event.
//
// The event indicates that debugging of the debuggee has terminated. This does **not** mean
// that the debuggee itself has exited.
class TerminatedEvent {
    int   seq;   // json: "seq"
    mixed type;  // json: "type"
    mixed body;  // json: "body"
    mixed event; // json: "event"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "event" : event,
        ]);

        return Standards.JSON.encode(json);
    }
}

TerminatedEvent TerminatedEvent_from_JSON(mixed json) {
    TerminatedEvent retval = TerminatedEvent();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.event = json["event"];

    return retval;
}

class TerminatedEventBody {
    mixed restart; // json: "restart"

    string encode_json() {
        mapping(string:mixed) json = ([
            "restart" : restart,
        ]);

        return Standards.JSON.encode(json);
    }
}

TerminatedEventBody TerminatedEventBody_from_JSON(mixed json) {
    TerminatedEventBody retval = TerminatedEventBody();

    retval.restart = json["restart"];

    return retval;
}

constant TERMINATED = "terminated"; // json: "terminated"

// Base class of requests, responses, and events.
//
// A debug adapter initiated event.
//
// The event indicates that a thread has started or exited.
class ThreadEvent {
    int             seq;   // json: "seq"
    mixed           type;  // json: "type"
    ThreadEventBody body;  // json: "body"
    mixed           event; // json: "event"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "event" : event,
        ]);

        return Standards.JSON.encode(json);
    }
}

ThreadEvent ThreadEvent_from_JSON(mixed json) {
    ThreadEvent retval = ThreadEvent();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.event = json["event"];

    return retval;
}

class ThreadEventBody {
    string reason;    // json: "reason"
    int    thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "reason" : reason,
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

ThreadEventBody ThreadEventBody_from_JSON(mixed json) {
    ThreadEventBody retval = ThreadEventBody();

    retval.reason = json["reason"];
    retval.thread_id = json["threadId"];

    return retval;
}

constant THREAD = "thread"; // json: "thread"

// Base class of requests, responses, and events.
//
// A debug adapter initiated event.
//
// The event indicates that the target has produced some output.
class OutputEvent {
    int             seq;   // json: "seq"
    mixed           type;  // json: "type"
    OutputEventBody body;  // json: "body"
    mixed           event; // json: "event"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "event" : event,
        ]);

        return Standards.JSON.encode(json);
    }
}

OutputEvent OutputEvent_from_JSON(mixed json) {
    OutputEvent retval = OutputEvent();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.event = json["event"];

    return retval;
}

class OutputEventBody {
    mixed  category;            // json: "category"
    mixed  column;              // json: "column"
    mixed  data;                // json: "data"
    mixed  line;                // json: "line"
    string output;              // json: "output"
    mixed  source;              // json: "source"
    mixed  variables_reference; // json: "variablesReference"

    string encode_json() {
        mapping(string:mixed) json = ([
            "category" : category,
            "column" : column,
            "data" : data,
            "line" : line,
            "output" : output,
            "source" : source,
            "variablesReference" : variables_reference,
        ]);

        return Standards.JSON.encode(json);
    }
}

OutputEventBody OutputEventBody_from_JSON(mixed json) {
    OutputEventBody retval = OutputEventBody();

    retval.category = json["category"];
    retval.column = json["column"];
    retval.data = json["data"];
    retval.line = json["line"];
    retval.output = json["output"];
    retval.source = json["source"];
    retval.variables_reference = json["variablesReference"];

    return retval;
}

// An optional source location where the output was produced.
//
// A Source is a descriptor for source code. It is returned from the debug adapter as part
// of a StackFrame and it is used by clients when specifying breakpoints.
//
// The source where the breakpoint is located.
//
// The new, changed, or removed source.
//
// The source location of the breakpoints; either 'source.path' or 'source.reference' must
// be specified.
//
// The optional source of the frame.
//
// Optional source for this scope.
//
// Specifies the source content to load. Either source.path or source.sourceReference must
// be specified.
//
// The source location for which the goto targets are determined.
class Source {
    mixed adapter_data;      // json: "adapterData"
    mixed checksums;         // json: "checksums"
    mixed name;              // json: "name"
    mixed origin;            // json: "origin"
    mixed path;              // json: "path"
    mixed presentation_hint; // json: "presentationHint"
    mixed source_reference;  // json: "sourceReference"
    mixed sources;           // json: "sources"

    string encode_json() {
        mapping(string:mixed) json = ([
            "adapterData" : adapter_data,
            "checksums" : checksums,
            "name" : name,
            "origin" : origin,
            "path" : path,
            "presentationHint" : presentation_hint,
            "sourceReference" : source_reference,
            "sources" : sources,
        ]);

        return Standards.JSON.encode(json);
    }
}

Source Source_from_JSON(mixed json) {
    Source retval = Source();

    retval.adapter_data = json["adapterData"];
    retval.checksums = json["checksums"];
    retval.name = json["name"];
    retval.origin = json["origin"];
    retval.path = json["path"];
    retval.presentation_hint = json["presentationHint"];
    retval.source_reference = json["sourceReference"];
    retval.sources = json["sources"];

    return retval;
}

// The checksum of an item calculated by the specified algorithm.
class Checksum {
    mixed  algorithm; // json: "algorithm"
    string checksum;  // json: "checksum"

    string encode_json() {
        mapping(string:mixed) json = ([
            "algorithm" : algorithm,
            "checksum" : checksum,
        ]);

        return Standards.JSON.encode(json);
    }
}

Checksum Checksum_from_JSON(mixed json) {
    Checksum retval = Checksum();

    retval.algorithm = json["algorithm"];
    retval.checksum = json["checksum"];

    return retval;
}

constant MD5 = "MD5";             // json: "MD5"
constant SHA1 = "SHA1";           // json: "SHA1"
constant SHA256 = "SHA256";       // json: "SHA256"
constant TIMESTAMP = "timestamp"; // json: "timestamp"

constant DEEMPHASIZE = "deemphasize"; // json: "deemphasize"
constant EMPHASIZE = "emphasize";     // json: "emphasize"
constant PURPLE_NORMAL = "normal";    // json: "normal"

constant OUTPUT = "output"; // json: "output"

// Base class of requests, responses, and events.
//
// A debug adapter initiated event.
//
// The event indicates that some information about a breakpoint has changed.
class BreakpointEvent {
    int                 seq;   // json: "seq"
    mixed               type;  // json: "type"
    BreakpointEventBody body;  // json: "body"
    mixed               event; // json: "event"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "event" : event,
        ]);

        return Standards.JSON.encode(json);
    }
}

BreakpointEvent BreakpointEvent_from_JSON(mixed json) {
    BreakpointEvent retval = BreakpointEvent();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.event = json["event"];

    return retval;
}

class BreakpointEventBody {
    Breakpoint breakpoint; // json: "breakpoint"
    string     reason;     // json: "reason"

    string encode_json() {
        mapping(string:mixed) json = ([
            "breakpoint" : breakpoint,
            "reason" : reason,
        ]);

        return Standards.JSON.encode(json);
    }
}

BreakpointEventBody BreakpointEventBody_from_JSON(mixed json) {
    BreakpointEventBody retval = BreakpointEventBody();

    retval.breakpoint = json["breakpoint"];
    retval.reason = json["reason"];

    return retval;
}

// The 'id' attribute is used to find the target breakpoint and the other attributes are
// used as the new values.
//
// Information about a Breakpoint created in setBreakpoints or setFunctionBreakpoints.
class Breakpoint {
    mixed column;     // json: "column"
    mixed end_column; // json: "endColumn"
    mixed end_line;   // json: "endLine"
    mixed id;         // json: "id"
    mixed line;       // json: "line"
    mixed message;    // json: "message"
    mixed source;     // json: "source"
    bool  verified;   // json: "verified"

    string encode_json() {
        mapping(string:mixed) json = ([
            "column" : column,
            "endColumn" : end_column,
            "endLine" : end_line,
            "id" : id,
            "line" : line,
            "message" : message,
            "source" : source,
            "verified" : verified,
        ]);

        return Standards.JSON.encode(json);
    }
}

Breakpoint Breakpoint_from_JSON(mixed json) {
    Breakpoint retval = Breakpoint();

    retval.column = json["column"];
    retval.end_column = json["endColumn"];
    retval.end_line = json["endLine"];
    retval.id = json["id"];
    retval.line = json["line"];
    retval.message = json["message"];
    retval.source = json["source"];
    retval.verified = json["verified"];

    return retval;
}

constant BREAKPOINT = "breakpoint"; // json: "breakpoint"

// Base class of requests, responses, and events.
//
// A debug adapter initiated event.
//
// The event indicates that some information about a module has changed.
class ModuleEvent {
    int             seq;   // json: "seq"
    mixed           type;  // json: "type"
    ModuleEventBody body;  // json: "body"
    mixed           event; // json: "event"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "event" : event,
        ]);

        return Standards.JSON.encode(json);
    }
}

ModuleEvent ModuleEvent_from_JSON(mixed json) {
    ModuleEvent retval = ModuleEvent();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.event = json["event"];

    return retval;
}

class ModuleEventBody {
    Module module; // json: "module"
    mixed  reason; // json: "reason"

    string encode_json() {
        mapping(string:mixed) json = ([
            "module" : module,
            "reason" : reason,
        ]);

        return Standards.JSON.encode(json);
    }
}

ModuleEventBody ModuleEventBody_from_JSON(mixed json) {
    ModuleEventBody retval = ModuleEventBody();

    retval.module = json["module"];
    retval.reason = json["reason"];

    return retval;
}

// The new, changed, or removed module. In case of 'removed' only the module id is used.
//
// A Module object represents a row in the modules view.
// Two attributes are mandatory: an id identifies a module in the modules view and is used
// in a ModuleEvent for identifying a module for adding, updating or deleting.
// The name is used to minimally render the module in the UI.
//
// Additional attributes can be added to the module. They will show up in the module View if
// they have a corresponding ColumnDescriptor.
//
// To avoid an unnecessary proliferation of additional attributes with similar semantics but
// different names
// we recommend to re-use attributes from the 'recommended' list below first, and only
// introduce new attributes if nothing appropriate could be found.
class Module {
    mixed  address_range;    // json: "addressRange"
    mixed  date_time_stamp;  // json: "dateTimeStamp"
    mixed  id;               // json: "id"
    mixed  is_optimized;     // json: "isOptimized"
    mixed  is_user_code;     // json: "isUserCode"
    string name;             // json: "name"
    mixed  path;             // json: "path"
    mixed  symbol_file_path; // json: "symbolFilePath"
    mixed  symbol_status;    // json: "symbolStatus"
    mixed  version;          // json: "version"

    string encode_json() {
        mapping(string:mixed) json = ([
            "addressRange" : address_range,
            "dateTimeStamp" : date_time_stamp,
            "id" : id,
            "isOptimized" : is_optimized,
            "isUserCode" : is_user_code,
            "name" : name,
            "path" : path,
            "symbolFilePath" : symbol_file_path,
            "symbolStatus" : symbol_status,
            "version" : version,
        ]);

        return Standards.JSON.encode(json);
    }
}

Module Module_from_JSON(mixed json) {
    Module retval = Module();

    retval.address_range = json["addressRange"];
    retval.date_time_stamp = json["dateTimeStamp"];
    retval.id = json["id"];
    retval.is_optimized = json["isOptimized"];
    retval.is_user_code = json["isUserCode"];
    retval.name = json["name"];
    retval.path = json["path"];
    retval.symbol_file_path = json["symbolFilePath"];
    retval.symbol_status = json["symbolStatus"];
    retval.version = json["version"];

    return retval;
}

// Unique identifier for the module.
//
// The module associated with this frame, if any.
typedef int|string IdUnion;

IdUnion IdUnion_from_JSON(mixed json) {
    return json;
}

constant CHANGED = "changed"; // json: "changed"
constant NEW = "new";         // json: "new"
constant REMOVED = "removed"; // json: "removed"

constant ARAK_GROUNDHOG_MODULE = "module"; // json: "module"

// Base class of requests, responses, and events.
//
// A debug adapter initiated event.
//
// The event indicates that some source has been added, changed, or removed from the set of
// all loaded sources.
class LoadedSourceEvent {
    int                   seq;   // json: "seq"
    mixed                 type;  // json: "type"
    LoadedSourceEventBody body;  // json: "body"
    mixed                 event; // json: "event"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "event" : event,
        ]);

        return Standards.JSON.encode(json);
    }
}

LoadedSourceEvent LoadedSourceEvent_from_JSON(mixed json) {
    LoadedSourceEvent retval = LoadedSourceEvent();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.event = json["event"];

    return retval;
}

class LoadedSourceEventBody {
    mixed  reason; // json: "reason"
    Source source; // json: "source"

    string encode_json() {
        mapping(string:mixed) json = ([
            "reason" : reason,
            "source" : source,
        ]);

        return Standards.JSON.encode(json);
    }
}

LoadedSourceEventBody LoadedSourceEventBody_from_JSON(mixed json) {
    LoadedSourceEventBody retval = LoadedSourceEventBody();

    retval.reason = json["reason"];
    retval.source = json["source"];

    return retval;
}

constant LOADED_SOURCE = "loadedSource"; // json: "loadedSource"

// Base class of requests, responses, and events.
//
// A debug adapter initiated event.
//
// The event indicates that the debugger has begun debugging a new process. Either one that
// it has launched, or one that it has attached to.
class ProcessEvent {
    int              seq;   // json: "seq"
    mixed            type;  // json: "type"
    ProcessEventBody body;  // json: "body"
    mixed            event; // json: "event"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "event" : event,
        ]);

        return Standards.JSON.encode(json);
    }
}

ProcessEvent ProcessEvent_from_JSON(mixed json) {
    ProcessEvent retval = ProcessEvent();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.event = json["event"];

    return retval;
}

class ProcessEventBody {
    mixed  is_local_process;  // json: "isLocalProcess"
    string name;              // json: "name"
    mixed  start_method;      // json: "startMethod"
    mixed  system_process_id; // json: "systemProcessId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "isLocalProcess" : is_local_process,
            "name" : name,
            "startMethod" : start_method,
            "systemProcessId" : system_process_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

ProcessEventBody ProcessEventBody_from_JSON(mixed json) {
    ProcessEventBody retval = ProcessEventBody();

    retval.is_local_process = json["isLocalProcess"];
    retval.name = json["name"];
    retval.start_method = json["startMethod"];
    retval.system_process_id = json["systemProcessId"];

    return retval;
}

constant ATTACH_FOR_SUSPENDED_LAUNCH = "attachForSuspendedLaunch"; // json: "attachForSuspendedLaunch"
constant START_METHOD_ATTACH = "attach";                           // json: "attach"
constant START_METHOD_LAUNCH = "launch";                           // json: "launch"

constant PROCESS = "process"; // json: "process"

// Base class of requests, responses, and events.
//
// A debug adapter initiated event.
//
// The event indicates that one or more capabilities have changed.
// Since the capabilities are dependent on the frontend and its UI, it might not be possible
// to change that at random times (or too late).
// Consequently this event has a hint characteristic: a frontend can only be expected to
// make a 'best effort' in honouring individual capabilities but there are no guarantees.
// Only changed capabilities need to be included, all other capabilities keep their values.
class CapabilitiesEvent {
    int                   seq;   // json: "seq"
    mixed                 type;  // json: "type"
    CapabilitiesEventBody body;  // json: "body"
    mixed                 event; // json: "event"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "event" : event,
        ]);

        return Standards.JSON.encode(json);
    }
}

CapabilitiesEvent CapabilitiesEvent_from_JSON(mixed json) {
    CapabilitiesEvent retval = CapabilitiesEvent();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.event = json["event"];

    return retval;
}

class CapabilitiesEventBody {
    Capabilities capabilities; // json: "capabilities"

    string encode_json() {
        mapping(string:mixed) json = ([
            "capabilities" : capabilities,
        ]);

        return Standards.JSON.encode(json);
    }
}

CapabilitiesEventBody CapabilitiesEventBody_from_JSON(mixed json) {
    CapabilitiesEventBody retval = CapabilitiesEventBody();

    retval.capabilities = json["capabilities"];

    return retval;
}

// The set of updated capabilities.
//
// Information about the capabilities of a debug adapter.
//
// The capabilities of this debug adapter.
class Capabilities {
    // json: "additionalModuleColumns"
    array(ColumnDescriptor) additional_module_columns;
    // json: "exceptionBreakpointFilters"
    array(ExceptionBreakpointsFilter) exception_breakpoint_filters;
    // json: "supportedChecksumAlgorithms"
    array(string) supported_checksum_algorithms;
    int supports_completions_request;         // json: "supportsCompletionsRequest"
    int supports_conditional_breakpoints;     // json: "supportsConditionalBreakpoints"
    int supports_configuration_done_request;  // json: "supportsConfigurationDoneRequest"
    int supports_delayed_stack_trace_loading; // json: "supportsDelayedStackTraceLoading"
    int supports_evaluate_for_hovers;         // json: "supportsEvaluateForHovers"
    int supports_exception_info_request;      // json: "supportsExceptionInfoRequest"
    int supports_exception_options;           // json: "supportsExceptionOptions"
    int supports_function_breakpoints;        // json: "supportsFunctionBreakpoints"
    int supports_goto_targets_request;        // json: "supportsGotoTargetsRequest"
    int supports_hit_conditional_breakpoints; // json: "supportsHitConditionalBreakpoints"
    int supports_loaded_sources_request;      // json: "supportsLoadedSourcesRequest"
    int supports_log_points;                  // json: "supportsLogPoints"
    int supports_modules_request;             // json: "supportsModulesRequest"
    int supports_restart_frame;               // json: "supportsRestartFrame"
    int supports_restart_request;             // json: "supportsRestartRequest"
    int supports_set_expression;              // json: "supportsSetExpression"
    int supports_set_variable;                // json: "supportsSetVariable"
    int supports_step_back;                   // json: "supportsStepBack"
    int supports_step_in_targets_request;     // json: "supportsStepInTargetsRequest"
    int supports_terminate_request;           // json: "supportsTerminateRequest"
    int supports_terminate_threads_request;   // json: "supportsTerminateThreadsRequest"
    int supports_value_formatting_options;    // json: "supportsValueFormattingOptions"
    int supports_terminate_debuggee;           // json: "supportTerminateDebuggee" !!!

    string encode_json() {
        mapping(string:mixed) json = ([
            "additionalModuleColumns" : additional_module_columns,
            "exceptionBreakpointFilters" : exception_breakpoint_filters,
            "supportedChecksumAlgorithms" : supported_checksum_algorithms,
            "supportsCompletionsRequest" : supports_completions_request,
            "supportsConditionalBreakpoints" : supports_conditional_breakpoints,
            "supportsConfigurationDoneRequest" : supports_configuration_done_request,
            "supportsDelayedStackTraceLoading" : supports_delayed_stack_trace_loading,
            "supportsEvaluateForHovers" : supports_evaluate_for_hovers,
            "supportsExceptionInfoRequest" : supports_exception_info_request,
            "supportsExceptionOptions" : supports_exception_options,
            "supportsFunctionBreakpoints" : supports_function_breakpoints,
            "supportsGotoTargetsRequest" : supports_goto_targets_request,
            "supportsHitConditionalBreakpoints" : supports_hit_conditional_breakpoints,
            "supportsLoadedSourcesRequest" : supports_loaded_sources_request,
            "supportsLogPoints" : supports_log_points,
            "supportsModulesRequest" : supports_modules_request,
            "supportsRestartFrame" : supports_restart_frame,
            "supportsRestartRequest" : supports_restart_request,
            "supportsSetExpression" : supports_set_expression,
            "supportsSetVariable" : supports_set_variable,
            "supportsStepBack" : supports_step_back,
            "supportsStepInTargetsRequest" : supports_step_in_targets_request,
            "supportsTerminateRequest" : supports_terminate_request,
            "supportsTerminateThreadsRequest" : supports_terminate_threads_request,
            "supportsValueFormattingOptions" : supports_value_formatting_options,
            "supportTerminateDebuggee" : support_terminate_debuggee,
        ]);

        return Standards.JSON.encode(json);
    }
}

Capabilities Capabilities_from_JSON(mixed json) {
    Capabilities retval = Capabilities();

    retval.additional_module_columns = map(json["additionalModuleColumns"], ColumnDescriptor);
    retval.exception_breakpoint_filters = json["exceptionBreakpointFilters"];
    retval.supported_checksum_algorithms = json["supportedChecksumAlgorithms"];
    retval.supports_completions_request = json["supportsCompletionsRequest"];
    retval.supports_conditional_breakpoints = json["supportsConditionalBreakpoints"];
    retval.supports_configuration_done_request = json["supportsConfigurationDoneRequest"];
    retval.supports_delayed_stack_trace_loading = json["supportsDelayedStackTraceLoading"];
    retval.supports_evaluate_for_hovers = json["supportsEvaluateForHovers"];
    retval.supports_exception_info_request = json["supportsExceptionInfoRequest"];
    retval.supports_exception_options = json["supportsExceptionOptions"];
    retval.supports_function_breakpoints = json["supportsFunctionBreakpoints"];
    retval.supports_goto_targets_request = json["supportsGotoTargetsRequest"];
    retval.supports_hit_conditional_breakpoints = json["supportsHitConditionalBreakpoints"];
    retval.supports_loaded_sources_request = json["supportsLoadedSourcesRequest"];
    retval.supports_log_points = json["supportsLogPoints"];
    retval.supports_modules_request = json["supportsModulesRequest"];
    retval.supports_restart_frame = json["supportsRestartFrame"];
    retval.supports_restart_request = json["supportsRestartRequest"];
    retval.supports_set_expression = json["supportsSetExpression"];
    retval.supports_set_variable = json["supportsSetVariable"];
    retval.supports_step_back = json["supportsStepBack"];
    retval.supports_step_in_targets_request = json["supportsStepInTargetsRequest"];
    retval.supports_terminate_request = json["supportsTerminateRequest"];
    retval.supports_terminate_threads_request = json["supportsTerminateThreadsRequest"];
    retval.supports_value_formatting_options = json["supportsValueFormattingOptions"];
    retval.support_terminate_debuggee = json["supportTerminateDebuggee"];

    return retval;
}

// A ColumnDescriptor specifies what module attribute to show in a column of the
// ModulesView, how to format it, and what the column's label should be.
// It is only used if the underlying UI actually supports this level of customization.
class ColumnDescriptor {
    string attribute_name; // json: "attributeName"
    mixed  format;         // json: "format"
    string label;          // json: "label"
    mixed  type;           // json: "type"
    mixed  width;          // json: "width"

    string encode_json() {
        mapping(string:mixed) json = ([
            "attributeName" : attribute_name,
            "format" : format,
            "label" : label,
            "type" : type,
            "width" : width,
        ]);

        return Standards.JSON.encode(json);
    }
}

ColumnDescriptor ColumnDescriptor_from_JSON(mixed json) {
    ColumnDescriptor retval = ColumnDescriptor();

    retval.attribute_name = json["attributeName"];
    retval.format = json["format"];
    retval.label = json["label"];
    retval.type = json["type"];
    retval.width = json["width"];

    return retval;
}

constant BOOLEAN = "boolean";                     // json: "boolean"
constant NUMBER = "number";                       // json: "number"
constant STRING = "string";                       // json: "string"
constant UNIX_TIMESTAMP_UTC = "unixTimestampUTC"; // json: "unixTimestampUTC"

// An ExceptionBreakpointsFilter is shown in the UI as an option for configuring how
// exceptions are dealt with.
class ExceptionBreakpointsFilter {
    mixed  exception_breakpoints_filter_default; // json: "default"
    string filter;                               // json: "filter"
    string label;                                // json: "label"

    string encode_json() {
        mapping(string:mixed) json = ([
            "default" : exception_breakpoints_filter_default,
            "filter" : filter,
            "label" : label,
        ]);

        return Standards.JSON.encode(json);
    }
}

ExceptionBreakpointsFilter ExceptionBreakpointsFilter_from_JSON(mixed json) {
    ExceptionBreakpointsFilter retval = ExceptionBreakpointsFilter();

    retval.exception_breakpoints_filter_default = json["default"];
    retval.filter = json["filter"];
    retval.label = json["label"];

    return retval;
}

constant CAPABILITIES = "capabilities"; // json: "capabilities"

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// This request is sent from the debug adapter to the client to run a command in a terminal.
// This is typically used to launch the debuggee in a terminal provided by the client.
class RunInTerminalRequest {
    int            seq;       // json: "seq"
    mixed          type;      // json: "type"
    ArgumentsClass arguments; // json: "arguments"
    mixed          command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

RunInTerminalRequest RunInTerminalRequest_from_JSON(mixed json) {
    RunInTerminalRequest retval = RunInTerminalRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'runInTerminal' request.
class ArgumentsClass {
    array(string) args;  // json: "args"
    string        cwd;   // json: "cwd"
    mixed         env;   // json: "env"
    mixed         kind;  // json: "kind"
    mixed         title; // json: "title"

    string encode_json() {
        mapping(string:mixed) json = ([
            "args" : args,
            "cwd" : cwd,
            "env" : env,
            "kind" : kind,
            "title" : title,
        ]);

        return Standards.JSON.encode(json);
    }
}

ArgumentsClass ArgumentsClass_from_JSON(mixed json) {
    ArgumentsClass retval = ArgumentsClass();

    retval.args = json["args"];
    retval.cwd = json["cwd"];
    retval.env = json["env"];
    retval.kind = json["kind"];
    retval.title = json["title"];

    return retval;
}

constant EXTERNAL = "external";     // json: "external"
constant INTEGRATED = "integrated"; // json: "integrated"

constant RUN_IN_TERMINAL = "runInTerminal"; // json: "runInTerminal"

// Arguments for 'runInTerminal' request.
class RunInTerminalRequestArguments {
    array(string) args;  // json: "args"
    string        cwd;   // json: "cwd"
    mixed         env;   // json: "env"
    mixed         kind;  // json: "kind"
    mixed         title; // json: "title"

    string encode_json() {
        mapping(string:mixed) json = ([
            "args" : args,
            "cwd" : cwd,
            "env" : env,
            "kind" : kind,
            "title" : title,
        ]);

        return Standards.JSON.encode(json);
    }
}

RunInTerminalRequestArguments RunInTerminalRequestArguments_from_JSON(mixed json) {
    RunInTerminalRequestArguments retval = RunInTerminalRequestArguments();

    retval.args = json["args"];
    retval.cwd = json["cwd"];
    retval.env = json["env"];
    retval.kind = json["kind"];
    retval.title = json["title"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'runInTerminal' request.
class RunInTerminalResponse {
    int                       seq;         // json: "seq"
    mixed                     type;        // json: "type"
    RunInTerminalResponseBody body;        // json: "body"
    string                    command;     // json: "command"
    mixed                     message;     // json: "message"
    int                       request_seq; // json: "request_seq"
    bool                      success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

RunInTerminalResponse RunInTerminalResponse_from_JSON(mixed json) {
    RunInTerminalResponse retval = RunInTerminalResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class RunInTerminalResponseBody {
    mixed process_id;       // json: "processId"
    mixed shell_process_id; // json: "shellProcessId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "processId" : process_id,
            "shellProcessId" : shell_process_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

RunInTerminalResponseBody RunInTerminalResponseBody_from_JSON(mixed json) {
    RunInTerminalResponseBody retval = RunInTerminalResponseBody();

    retval.process_id = json["processId"];
    retval.shell_process_id = json["shellProcessId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The 'initialize' request is sent as the first request from the client to the debug
// adapter in order to configure it with client capabilities and to retrieve capabilities
// from the debug adapter.
// Until the debug adapter has responded to with an 'initialize' response, the client must
// not send any additional requests or events to the debug adapter. In addition the debug
// adapter is not allowed to send any requests or events to the client until it has
// responded with an 'initialize' response.
// The 'initialize' request may only be sent once.
class InitializeRequest {
    int              seq;       // json: "seq"
    mixed            type;      // json: "type"
    RequestArguments arguments; // json: "arguments"
    mixed            command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

InitializeRequest InitializeRequest_from_JSON(mixed json) {
    InitializeRequest retval = InitializeRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'initialize' request.
class RequestArguments {
    string adapter_id;                       // json: "adapterID"
    mixed  client_id;                        // json: "clientID"
    mixed  client_name;                      // json: "clientName"
    mixed  columns_start_at1;                // json: "columnsStartAt1"
    mixed  lines_start_at1;                  // json: "linesStartAt1"
    mixed  locale;                           // json: "locale"
    mixed  path_format;                      // json: "pathFormat"
    mixed  supports_run_in_terminal_request; // json: "supportsRunInTerminalRequest"
    mixed  supports_variable_paging;         // json: "supportsVariablePaging"
    mixed  supports_variable_type;           // json: "supportsVariableType"

    string encode_json() {
        mapping(string:mixed) json = ([
            "adapterID" : adapter_id,
            "clientID" : client_id,
            "clientName" : client_name,
            "columnsStartAt1" : columns_start_at1,
            "linesStartAt1" : lines_start_at1,
            "locale" : locale,
            "pathFormat" : path_format,
            "supportsRunInTerminalRequest" : supports_run_in_terminal_request,
            "supportsVariablePaging" : supports_variable_paging,
            "supportsVariableType" : supports_variable_type,
        ]);

        return Standards.JSON.encode(json);
    }
}

RequestArguments RequestArguments_from_JSON(mixed json) {
    RequestArguments retval = RequestArguments();

    retval.adapter_id = json["adapterID"];
    retval.client_id = json["clientID"];
    retval.client_name = json["clientName"];
    retval.columns_start_at1 = json["columnsStartAt1"];
    retval.lines_start_at1 = json["linesStartAt1"];
    retval.locale = json["locale"];
    retval.path_format = json["pathFormat"];
    retval.supports_run_in_terminal_request = json["supportsRunInTerminalRequest"];
    retval.supports_variable_paging = json["supportsVariablePaging"];
    retval.supports_variable_type = json["supportsVariableType"];

    return retval;
}

constant INITIALIZE = "initialize"; // json: "initialize"

// Arguments for 'initialize' request.
class InitializeRequestArguments {
    string adapter_id;                       // json: "adapterID"
    mixed  client_id;                        // json: "clientID"
    mixed  client_name;                      // json: "clientName"
    mixed  columns_start_at1;                // json: "columnsStartAt1"
    mixed  lines_start_at1;                  // json: "linesStartAt1"
    mixed  locale;                           // json: "locale"
    mixed  path_format;                      // json: "pathFormat"
    mixed  supports_run_in_terminal_request; // json: "supportsRunInTerminalRequest"
    mixed  supports_variable_paging;         // json: "supportsVariablePaging"
    mixed  supports_variable_type;           // json: "supportsVariableType"

    string encode_json() {
        mapping(string:mixed) json = ([
            "adapterID" : adapter_id,
            "clientID" : client_id,
            "clientName" : client_name,
            "columnsStartAt1" : columns_start_at1,
            "linesStartAt1" : lines_start_at1,
            "locale" : locale,
            "pathFormat" : path_format,
            "supportsRunInTerminalRequest" : supports_run_in_terminal_request,
            "supportsVariablePaging" : supports_variable_paging,
            "supportsVariableType" : supports_variable_type,
        ]);

        return Standards.JSON.encode(json);
    }
}

InitializeRequestArguments InitializeRequestArguments_from_JSON(mixed json) {
    InitializeRequestArguments retval = InitializeRequestArguments();

    retval.adapter_id = json["adapterID"];
    retval.client_id = json["clientID"];
    retval.client_name = json["clientName"];
    retval.columns_start_at1 = json["columnsStartAt1"];
    retval.lines_start_at1 = json["linesStartAt1"];
    retval.locale = json["locale"];
    retval.path_format = json["pathFormat"];
    retval.supports_run_in_terminal_request = json["supportsRunInTerminalRequest"];
    retval.supports_variable_paging = json["supportsVariablePaging"];
    retval.supports_variable_type = json["supportsVariableType"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'initialize' request.
class InitializeResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

InitializeResponse InitializeResponse_from_JSON(mixed json) {
    InitializeResponse retval = InitializeResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// The set of updated capabilities.
//
// Information about the capabilities of a debug adapter.
//
// The capabilities of this debug adapter.
class Types {
    mixed additional_module_columns;            // json: "additionalModuleColumns"
    mixed exception_breakpoint_filters;         // json: "exceptionBreakpointFilters"
    mixed supported_checksum_algorithms;        // json: "supportedChecksumAlgorithms"
    mixed supports_completions_request;         // json: "supportsCompletionsRequest"
    mixed supports_conditional_breakpoints;     // json: "supportsConditionalBreakpoints"
    mixed supports_configuration_done_request;  // json: "supportsConfigurationDoneRequest"
    mixed supports_delayed_stack_trace_loading; // json: "supportsDelayedStackTraceLoading"
    mixed supports_evaluate_for_hovers;         // json: "supportsEvaluateForHovers"
    mixed supports_exception_info_request;      // json: "supportsExceptionInfoRequest"
    mixed supports_exception_options;           // json: "supportsExceptionOptions"
    mixed supports_function_breakpoints;        // json: "supportsFunctionBreakpoints"
    mixed supports_goto_targets_request;        // json: "supportsGotoTargetsRequest"
    mixed supports_hit_conditional_breakpoints; // json: "supportsHitConditionalBreakpoints"
    mixed supports_loaded_sources_request;      // json: "supportsLoadedSourcesRequest"
    mixed supports_log_points;                  // json: "supportsLogPoints"
    mixed supports_modules_request;             // json: "supportsModulesRequest"
    mixed supports_restart_frame;               // json: "supportsRestartFrame"
    mixed supports_restart_request;             // json: "supportsRestartRequest"
    mixed supports_set_expression;              // json: "supportsSetExpression"
    mixed supports_set_variable;                // json: "supportsSetVariable"
    mixed supports_step_back;                   // json: "supportsStepBack"
    mixed supports_step_in_targets_request;     // json: "supportsStepInTargetsRequest"
    mixed supports_terminate_request;           // json: "supportsTerminateRequest"
    mixed supports_terminate_threads_request;   // json: "supportsTerminateThreadsRequest"
    mixed supports_value_formatting_options;    // json: "supportsValueFormattingOptions"
    mixed support_terminate_debuggee;           // json: "supportTerminateDebuggee"

    string encode_json() {
        mapping(string:mixed) json = ([
            "additionalModuleColumns" : additional_module_columns,
            "exceptionBreakpointFilters" : exception_breakpoint_filters,
            "supportedChecksumAlgorithms" : supported_checksum_algorithms,
            "supportsCompletionsRequest" : supports_completions_request,
            "supportsConditionalBreakpoints" : supports_conditional_breakpoints,
            "supportsConfigurationDoneRequest" : supports_configuration_done_request,
            "supportsDelayedStackTraceLoading" : supports_delayed_stack_trace_loading,
            "supportsEvaluateForHovers" : supports_evaluate_for_hovers,
            "supportsExceptionInfoRequest" : supports_exception_info_request,
            "supportsExceptionOptions" : supports_exception_options,
            "supportsFunctionBreakpoints" : supports_function_breakpoints,
            "supportsGotoTargetsRequest" : supports_goto_targets_request,
            "supportsHitConditionalBreakpoints" : supports_hit_conditional_breakpoints,
            "supportsLoadedSourcesRequest" : supports_loaded_sources_request,
            "supportsLogPoints" : supports_log_points,
            "supportsModulesRequest" : supports_modules_request,
            "supportsRestartFrame" : supports_restart_frame,
            "supportsRestartRequest" : supports_restart_request,
            "supportsSetExpression" : supports_set_expression,
            "supportsSetVariable" : supports_set_variable,
            "supportsStepBack" : supports_step_back,
            "supportsStepInTargetsRequest" : supports_step_in_targets_request,
            "supportsTerminateRequest" : supports_terminate_request,
            "supportsTerminateThreadsRequest" : supports_terminate_threads_request,
            "supportsValueFormattingOptions" : supports_value_formatting_options,
            "supportTerminateDebuggee" : support_terminate_debuggee,
        ]);

        return Standards.JSON.encode(json);
    }
}

Types Types_from_JSON(mixed json) {
    Types retval = Types();

    retval.additional_module_columns = json["additionalModuleColumns"];
    retval.exception_breakpoint_filters = json["exceptionBreakpointFilters"];
    retval.supported_checksum_algorithms = json["supportedChecksumAlgorithms"];
    retval.supports_completions_request = json["supportsCompletionsRequest"];
    retval.supports_conditional_breakpoints = json["supportsConditionalBreakpoints"];
    retval.supports_configuration_done_request = json["supportsConfigurationDoneRequest"];
    retval.supports_delayed_stack_trace_loading = json["supportsDelayedStackTraceLoading"];
    retval.supports_evaluate_for_hovers = json["supportsEvaluateForHovers"];
    retval.supports_exception_info_request = json["supportsExceptionInfoRequest"];
    retval.supports_exception_options = json["supportsExceptionOptions"];
    retval.supports_function_breakpoints = json["supportsFunctionBreakpoints"];
    retval.supports_goto_targets_request = json["supportsGotoTargetsRequest"];
    retval.supports_hit_conditional_breakpoints = json["supportsHitConditionalBreakpoints"];
    retval.supports_loaded_sources_request = json["supportsLoadedSourcesRequest"];
    retval.supports_log_points = json["supportsLogPoints"];
    retval.supports_modules_request = json["supportsModulesRequest"];
    retval.supports_restart_frame = json["supportsRestartFrame"];
    retval.supports_restart_request = json["supportsRestartRequest"];
    retval.supports_set_expression = json["supportsSetExpression"];
    retval.supports_set_variable = json["supportsSetVariable"];
    retval.supports_step_back = json["supportsStepBack"];
    retval.supports_step_in_targets_request = json["supportsStepInTargetsRequest"];
    retval.supports_terminate_request = json["supportsTerminateRequest"];
    retval.supports_terminate_threads_request = json["supportsTerminateThreadsRequest"];
    retval.supports_value_formatting_options = json["supportsValueFormattingOptions"];
    retval.support_terminate_debuggee = json["supportTerminateDebuggee"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The client of the debug protocol must send this request at the end of the sequence of
// configuration requests (which was started by the 'initialized' event).
class ConfigurationDoneRequest {
    int   seq;       // json: "seq"
    mixed type;      // json: "type"
    mixed arguments; // json: "arguments"
    mixed command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

ConfigurationDoneRequest ConfigurationDoneRequest_from_JSON(mixed json) {
    ConfigurationDoneRequest retval = ConfigurationDoneRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

constant CONFIGURATION_DONE = "configurationDone"; // json: "configurationDone"

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'configurationDone' request. This is just an acknowledgement, so no body
// field is required.
class ConfigurationDoneResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

ConfigurationDoneResponse ConfigurationDoneResponse_from_JSON(mixed json) {
    ConfigurationDoneResponse retval = ConfigurationDoneResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The launch request is sent from the client to the debug adapter to start the debuggee
// with or without debugging (if 'noDebug' is true). Since launching is debugger/runtime
// specific, the arguments for this request are not part of this specification.
class LaunchRequest {
    int                         seq;       // json: "seq"
    mixed                       type;      // json: "type"
    LaunchRequestArgumentsClass arguments; // json: "arguments"
    mixed                       command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

LaunchRequest LaunchRequest_from_JSON(mixed json) {
    LaunchRequest retval = LaunchRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'launch' request. Additional attributes are implementation specific.
class LaunchRequestArgumentsClass {
    mixed restart;  // json: "__restart"
    mixed no_debug; // json: "noDebug"

    string encode_json() {
        mapping(string:mixed) json = ([
            "__restart" : restart,
            "noDebug" : no_debug,
        ]);

        return Standards.JSON.encode(json);
    }
}

LaunchRequestArgumentsClass LaunchRequestArgumentsClass_from_JSON(mixed json) {
    LaunchRequestArgumentsClass retval = LaunchRequestArgumentsClass();

    retval.restart = json["__restart"];
    retval.no_debug = json["noDebug"];

    return retval;
}

constant ARAK_GROUNDHOG_LAUNCH = "launch"; // json: "launch"

// Arguments for 'launch' request. Additional attributes are implementation specific.
class LaunchRequestArguments {
    mixed restart;  // json: "__restart"
    mixed no_debug; // json: "noDebug"

    string encode_json() {
        mapping(string:mixed) json = ([
            "__restart" : restart,
            "noDebug" : no_debug,
        ]);

        return Standards.JSON.encode(json);
    }
}

LaunchRequestArguments LaunchRequestArguments_from_JSON(mixed json) {
    LaunchRequestArguments retval = LaunchRequestArguments();

    retval.restart = json["__restart"];
    retval.no_debug = json["noDebug"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'launch' request. This is just an acknowledgement, so no body field is
// required.
class LaunchResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

LaunchResponse LaunchResponse_from_JSON(mixed json) {
    LaunchResponse retval = LaunchResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The attach request is sent from the client to the debug adapter to attach to a debuggee
// that is already running. Since attaching is debugger/runtime specific, the arguments for
// this request are not part of this specification.
class AttachRequest {
    int                         seq;       // json: "seq"
    mixed                       type;      // json: "type"
    AttachRequestArgumentsClass arguments; // json: "arguments"
    mixed                       command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

AttachRequest AttachRequest_from_JSON(mixed json) {
    AttachRequest retval = AttachRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'attach' request. Additional attributes are implementation specific.
class AttachRequestArgumentsClass {
    mixed restart; // json: "__restart"

    string encode_json() {
        mapping(string:mixed) json = ([
            "__restart" : restart,
        ]);

        return Standards.JSON.encode(json);
    }
}

AttachRequestArgumentsClass AttachRequestArgumentsClass_from_JSON(mixed json) {
    AttachRequestArgumentsClass retval = AttachRequestArgumentsClass();

    retval.restart = json["__restart"];

    return retval;
}

constant ARAK_GROUNDHOG_ATTACH = "attach"; // json: "attach"

// Arguments for 'attach' request. Additional attributes are implementation specific.
class AttachRequestArguments {
    mixed restart; // json: "__restart"

    string encode_json() {
        mapping(string:mixed) json = ([
            "__restart" : restart,
        ]);

        return Standards.JSON.encode(json);
    }
}

AttachRequestArguments AttachRequestArguments_from_JSON(mixed json) {
    AttachRequestArguments retval = AttachRequestArguments();

    retval.restart = json["__restart"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'attach' request. This is just an acknowledgement, so no body field is
// required.
class AttachResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

AttachResponse AttachResponse_from_JSON(mixed json) {
    AttachResponse retval = AttachResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// Restarts a debug session. If the capability 'supportsRestartRequest' is missing or has
// the value false,
// the client will implement 'restart' by terminating the debug adapter first and then
// launching it anew.
// A debug adapter can override this default behaviour by implementing a restart request
// and setting the capability 'supportsRestartRequest' to true.
class RestartRequest {
    int   seq;       // json: "seq"
    mixed type;      // json: "type"
    mixed arguments; // json: "arguments"
    mixed command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

RestartRequest RestartRequest_from_JSON(mixed json) {
    RestartRequest retval = RestartRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

constant RESTART = "restart"; // json: "restart"

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'restart' request. This is just an acknowledgement, so no body field is
// required.
class RestartResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

RestartResponse RestartResponse_from_JSON(mixed json) {
    RestartResponse retval = RestartResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The 'disconnect' request is sent from the client to the debug adapter in order to stop
// debugging. It asks the debug adapter to disconnect from the debuggee and to terminate the
// debug adapter. If the debuggee has been started with the 'launch' request, the
// 'disconnect' request terminates the debuggee. If the 'attach' request was used to connect
// to the debuggee, 'disconnect' does not terminate the debuggee. This behavior can be
// controlled with the 'terminateDebuggee' argument (if supported by the debug adapter).
class DisconnectRequest {
    int   seq;       // json: "seq"
    mixed type;      // json: "type"
    mixed arguments; // json: "arguments"
    mixed command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

DisconnectRequest DisconnectRequest_from_JSON(mixed json) {
    DisconnectRequest retval = DisconnectRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'disconnect' request.
class DisconnectRequestArguments {
    mixed restart;            // json: "restart"
    mixed terminate_debuggee; // json: "terminateDebuggee"

    string encode_json() {
        mapping(string:mixed) json = ([
            "restart" : restart,
            "terminateDebuggee" : terminate_debuggee,
        ]);

        return Standards.JSON.encode(json);
    }
}

DisconnectRequestArguments DisconnectRequestArguments_from_JSON(mixed json) {
    DisconnectRequestArguments retval = DisconnectRequestArguments();

    retval.restart = json["restart"];
    retval.terminate_debuggee = json["terminateDebuggee"];

    return retval;
}

constant DISCONNECT = "disconnect"; // json: "disconnect"

// Arguments for 'disconnect' request.
class DisconnectArguments {
    mixed restart;            // json: "restart"
    mixed terminate_debuggee; // json: "terminateDebuggee"

    string encode_json() {
        mapping(string:mixed) json = ([
            "restart" : restart,
            "terminateDebuggee" : terminate_debuggee,
        ]);

        return Standards.JSON.encode(json);
    }
}

DisconnectArguments DisconnectArguments_from_JSON(mixed json) {
    DisconnectArguments retval = DisconnectArguments();

    retval.restart = json["restart"];
    retval.terminate_debuggee = json["terminateDebuggee"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'disconnect' request. This is just an acknowledgement, so no body field is
// required.
class DisconnectResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

DisconnectResponse DisconnectResponse_from_JSON(mixed json) {
    DisconnectResponse retval = DisconnectResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The 'terminate' request is sent from the client to the debug adapter in order to give the
// debuggee a chance for terminating itself.
class TerminateRequest {
    int   seq;       // json: "seq"
    mixed type;      // json: "type"
    mixed arguments; // json: "arguments"
    mixed command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

TerminateRequest TerminateRequest_from_JSON(mixed json) {
    TerminateRequest retval = TerminateRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'terminate' request.
class TerminateRequestArguments {
    mixed restart; // json: "restart"

    string encode_json() {
        mapping(string:mixed) json = ([
            "restart" : restart,
        ]);

        return Standards.JSON.encode(json);
    }
}

TerminateRequestArguments TerminateRequestArguments_from_JSON(mixed json) {
    TerminateRequestArguments retval = TerminateRequestArguments();

    retval.restart = json["restart"];

    return retval;
}

constant TERMINATE = "terminate"; // json: "terminate"

// Arguments for 'terminate' request.
class TerminateArguments {
    mixed restart; // json: "restart"

    string encode_json() {
        mapping(string:mixed) json = ([
            "restart" : restart,
        ]);

        return Standards.JSON.encode(json);
    }
}

TerminateArguments TerminateArguments_from_JSON(mixed json) {
    TerminateArguments retval = TerminateArguments();

    retval.restart = json["restart"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'terminate' request. This is just an acknowledgement, so no body field is
// required.
class TerminateResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

TerminateResponse TerminateResponse_from_JSON(mixed json) {
    TerminateResponse retval = TerminateResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// Sets multiple breakpoints for a single source and clears all previous breakpoints in that
// source.
// To clear all breakpoint for a source, specify an empty array.
// When a breakpoint is hit, a 'stopped' event (with reason 'breakpoint') is generated.
class SetBreakpointsRequest {
    int                            seq;       // json: "seq"
    mixed                          type;      // json: "type"
    SetBreakpointsRequestArguments arguments; // json: "arguments"
    mixed                          command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetBreakpointsRequest SetBreakpointsRequest_from_JSON(mixed json) {
    SetBreakpointsRequest retval = SetBreakpointsRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'setBreakpoints' request.
class SetBreakpointsRequestArguments {
    mixed  breakpoints;     // json: "breakpoints"
    mixed  lines;           // json: "lines"
    Source source;          // json: "source"
    mixed  source_modified; // json: "sourceModified"

    string encode_json() {
        mapping(string:mixed) json = ([
            "breakpoints" : breakpoints,
            "lines" : lines,
            "source" : source,
            "sourceModified" : source_modified,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetBreakpointsRequestArguments SetBreakpointsRequestArguments_from_JSON(mixed json) {
    SetBreakpointsRequestArguments retval = SetBreakpointsRequestArguments();

    retval.breakpoints = json["breakpoints"];
    retval.lines = json["lines"];
    retval.source = json["source"];
    retval.source_modified = json["sourceModified"];

    return retval;
}

// Properties of a breakpoint or logpoint passed to the setBreakpoints request.
class SourceBreakpoint {
    mixed column;        // json: "column"
    mixed condition;     // json: "condition"
    mixed hit_condition; // json: "hitCondition"
    int   line;          // json: "line"
    mixed log_message;   // json: "logMessage"

    string encode_json() {
        mapping(string:mixed) json = ([
            "column" : column,
            "condition" : condition,
            "hitCondition" : hit_condition,
            "line" : line,
            "logMessage" : log_message,
        ]);

        return Standards.JSON.encode(json);
    }
}

SourceBreakpoint SourceBreakpoint_from_JSON(mixed json) {
    SourceBreakpoint retval = SourceBreakpoint();

    retval.column = json["column"];
    retval.condition = json["condition"];
    retval.hit_condition = json["hitCondition"];
    retval.line = json["line"];
    retval.log_message = json["logMessage"];

    return retval;
}

constant SET_BREAKPOINTS = "setBreakpoints"; // json: "setBreakpoints"

// Arguments for 'setBreakpoints' request.
class SetBreakpointsArguments {
    mixed  breakpoints;     // json: "breakpoints"
    mixed  lines;           // json: "lines"
    Source source;          // json: "source"
    mixed  source_modified; // json: "sourceModified"

    string encode_json() {
        mapping(string:mixed) json = ([
            "breakpoints" : breakpoints,
            "lines" : lines,
            "source" : source,
            "sourceModified" : source_modified,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetBreakpointsArguments SetBreakpointsArguments_from_JSON(mixed json) {
    SetBreakpointsArguments retval = SetBreakpointsArguments();

    retval.breakpoints = json["breakpoints"];
    retval.lines = json["lines"];
    retval.source = json["source"];
    retval.source_modified = json["sourceModified"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'setBreakpoints' request.
// Returned is information about each breakpoint created by this request.
// This includes the actual code location and whether the breakpoint could be verified.
// The breakpoints returned are in the same order as the elements of the 'breakpoints'
// (or the deprecated 'lines') array in the arguments.
class SetBreakpointsResponse {
    int                        seq;         // json: "seq"
    mixed                      type;        // json: "type"
    SetBreakpointsResponseBody body;        // json: "body"
    string                     command;     // json: "command"
    mixed                      message;     // json: "message"
    int                        request_seq; // json: "request_seq"
    bool                       success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetBreakpointsResponse SetBreakpointsResponse_from_JSON(mixed json) {
    SetBreakpointsResponse retval = SetBreakpointsResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class SetBreakpointsResponseBody {
    array(Breakpoint) breakpoints; // json: "breakpoints"

    string encode_json() {
        mapping(string:mixed) json = ([
            "breakpoints" : breakpoints,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetBreakpointsResponseBody SetBreakpointsResponseBody_from_JSON(mixed json) {
    SetBreakpointsResponseBody retval = SetBreakpointsResponseBody();

    retval.breakpoints = json["breakpoints"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// Sets multiple function breakpoints and clears all previous function breakpoints.
// To clear all function breakpoint, specify an empty array.
// When a function breakpoint is hit, a 'stopped' event (event type 'function breakpoint')
// is generated.
class SetFunctionBreakpointsRequest {
    int                                    seq;       // json: "seq"
    mixed                                  type;      // json: "type"
    SetFunctionBreakpointsRequestArguments arguments; // json: "arguments"
    mixed                                  command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetFunctionBreakpointsRequest SetFunctionBreakpointsRequest_from_JSON(mixed json) {
    SetFunctionBreakpointsRequest retval = SetFunctionBreakpointsRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'setFunctionBreakpoints' request.
class SetFunctionBreakpointsRequestArguments {
    array(FunctionBreakpoint) breakpoints; // json: "breakpoints"

    string encode_json() {
        mapping(string:mixed) json = ([
            "breakpoints" : breakpoints,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetFunctionBreakpointsRequestArguments SetFunctionBreakpointsRequestArguments_from_JSON(mixed json) {
    SetFunctionBreakpointsRequestArguments retval = SetFunctionBreakpointsRequestArguments();

    retval.breakpoints = json["breakpoints"];

    return retval;
}

// Properties of a breakpoint passed to the setFunctionBreakpoints request.
class FunctionBreakpoint {
    mixed  condition;     // json: "condition"
    mixed  hit_condition; // json: "hitCondition"
    string name;          // json: "name"

    string encode_json() {
        mapping(string:mixed) json = ([
            "condition" : condition,
            "hitCondition" : hit_condition,
            "name" : name,
        ]);

        return Standards.JSON.encode(json);
    }
}

FunctionBreakpoint FunctionBreakpoint_from_JSON(mixed json) {
    FunctionBreakpoint retval = FunctionBreakpoint();

    retval.condition = json["condition"];
    retval.hit_condition = json["hitCondition"];
    retval.name = json["name"];

    return retval;
}

constant SET_FUNCTION_BREAKPOINTS = "setFunctionBreakpoints"; // json: "setFunctionBreakpoints"

// Arguments for 'setFunctionBreakpoints' request.
class SetFunctionBreakpointsArguments {
    array(FunctionBreakpoint) breakpoints; // json: "breakpoints"

    string encode_json() {
        mapping(string:mixed) json = ([
            "breakpoints" : breakpoints,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetFunctionBreakpointsArguments SetFunctionBreakpointsArguments_from_JSON(mixed json) {
    SetFunctionBreakpointsArguments retval = SetFunctionBreakpointsArguments();

    retval.breakpoints = json["breakpoints"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'setFunctionBreakpoints' request.
// Returned is information about each breakpoint created by this request.
class SetFunctionBreakpointsResponse {
    int                                seq;         // json: "seq"
    mixed                              type;        // json: "type"
    SetFunctionBreakpointsResponseBody body;        // json: "body"
    string                             command;     // json: "command"
    mixed                              message;     // json: "message"
    int                                request_seq; // json: "request_seq"
    bool                               success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetFunctionBreakpointsResponse SetFunctionBreakpointsResponse_from_JSON(mixed json) {
    SetFunctionBreakpointsResponse retval = SetFunctionBreakpointsResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class SetFunctionBreakpointsResponseBody {
    array(Breakpoint) breakpoints; // json: "breakpoints"

    string encode_json() {
        mapping(string:mixed) json = ([
            "breakpoints" : breakpoints,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetFunctionBreakpointsResponseBody SetFunctionBreakpointsResponseBody_from_JSON(mixed json) {
    SetFunctionBreakpointsResponseBody retval = SetFunctionBreakpointsResponseBody();

    retval.breakpoints = json["breakpoints"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request configures the debuggers response to thrown exceptions. If an exception is
// configured to break, a 'stopped' event is fired (with reason 'exception').
class SetExceptionBreakpointsRequest {
    int                                     seq;       // json: "seq"
    mixed                                   type;      // json: "type"
    SetExceptionBreakpointsRequestArguments arguments; // json: "arguments"
    mixed                                   command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetExceptionBreakpointsRequest SetExceptionBreakpointsRequest_from_JSON(mixed json) {
    SetExceptionBreakpointsRequest retval = SetExceptionBreakpointsRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'setExceptionBreakpoints' request.
class SetExceptionBreakpointsRequestArguments {
    mixed         exception_options; // json: "exceptionOptions"
    array(string) filters;           // json: "filters"

    string encode_json() {
        mapping(string:mixed) json = ([
            "exceptionOptions" : exception_options,
            "filters" : filters,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetExceptionBreakpointsRequestArguments SetExceptionBreakpointsRequestArguments_from_JSON(mixed json) {
    SetExceptionBreakpointsRequestArguments retval = SetExceptionBreakpointsRequestArguments();

    retval.exception_options = json["exceptionOptions"];
    retval.filters = json["filters"];

    return retval;
}

// An ExceptionOptions assigns configuration options to a set of exceptions.
class ExceptionOptions {
    mixed break_mode; // json: "breakMode"
    mixed path;       // json: "path"

    string encode_json() {
        mapping(string:mixed) json = ([
            "breakMode" : break_mode,
            "path" : path,
        ]);

        return Standards.JSON.encode(json);
    }
}

ExceptionOptions ExceptionOptions_from_JSON(mixed json) {
    ExceptionOptions retval = ExceptionOptions();

    retval.break_mode = json["breakMode"];
    retval.path = json["path"];

    return retval;
}

constant ALWAYS = "always";                // json: "always"
constant NEVER = "never";                  // json: "never"
constant UNHANDLED = "unhandled";          // json: "unhandled"
constant USER_UNHANDLED = "userUnhandled"; // json: "userUnhandled"

// An ExceptionPathSegment represents a segment in a path that is used to match leafs or
// nodes in a tree of exceptions. If a segment consists of more than one name, it matches
// the names provided if 'negate' is false or missing or it matches anything except the
// names provided if 'negate' is true.
class ExceptionPathSegment {
    array(string) names;  // json: "names"
    mixed         negate; // json: "negate"

    string encode_json() {
        mapping(string:mixed) json = ([
            "names" : names,
            "negate" : negate,
        ]);

        return Standards.JSON.encode(json);
    }
}

ExceptionPathSegment ExceptionPathSegment_from_JSON(mixed json) {
    ExceptionPathSegment retval = ExceptionPathSegment();

    retval.names = json["names"];
    retval.negate = json["negate"];

    return retval;
}

constant SET_EXCEPTION_BREAKPOINTS = "setExceptionBreakpoints"; // json: "setExceptionBreakpoints"

// Arguments for 'setExceptionBreakpoints' request.
class SetExceptionBreakpointsArguments {
    mixed         exception_options; // json: "exceptionOptions"
    array(string) filters;           // json: "filters"

    string encode_json() {
        mapping(string:mixed) json = ([
            "exceptionOptions" : exception_options,
            "filters" : filters,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetExceptionBreakpointsArguments SetExceptionBreakpointsArguments_from_JSON(mixed json) {
    SetExceptionBreakpointsArguments retval = SetExceptionBreakpointsArguments();

    retval.exception_options = json["exceptionOptions"];
    retval.filters = json["filters"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'setExceptionBreakpoints' request. This is just an acknowledgement, so no
// body field is required.
class SetExceptionBreakpointsResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetExceptionBreakpointsResponse SetExceptionBreakpointsResponse_from_JSON(mixed json) {
    SetExceptionBreakpointsResponse retval = SetExceptionBreakpointsResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request starts the debuggee to run again.
class ContinueRequest {
    int                      seq;       // json: "seq"
    mixed                    type;      // json: "type"
    ContinueRequestArguments arguments; // json: "arguments"
    mixed                    command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

ContinueRequest ContinueRequest_from_JSON(mixed json) {
    ContinueRequest retval = ContinueRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'continue' request.
class ContinueRequestArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

ContinueRequestArguments ContinueRequestArguments_from_JSON(mixed json) {
    ContinueRequestArguments retval = ContinueRequestArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

constant CONTINUE = "continue"; // json: "continue"

// Arguments for 'continue' request.
class ContinueArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

ContinueArguments ContinueArguments_from_JSON(mixed json) {
    ContinueArguments retval = ContinueArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'continue' request.
class ContinueResponse {
    int                  seq;         // json: "seq"
    mixed                type;        // json: "type"
    ContinueResponseBody body;        // json: "body"
    string               command;     // json: "command"
    mixed                message;     // json: "message"
    int                  request_seq; // json: "request_seq"
    bool                 success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

ContinueResponse ContinueResponse_from_JSON(mixed json) {
    ContinueResponse retval = ContinueResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class ContinueResponseBody {
    mixed all_threads_continued; // json: "allThreadsContinued"

    string encode_json() {
        mapping(string:mixed) json = ([
            "allThreadsContinued" : all_threads_continued,
        ]);

        return Standards.JSON.encode(json);
    }
}

ContinueResponseBody ContinueResponseBody_from_JSON(mixed json) {
    ContinueResponseBody retval = ContinueResponseBody();

    retval.all_threads_continued = json["allThreadsContinued"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request starts the debuggee to run again for one step.
// The debug adapter first sends the response and then a 'stopped' event (with reason
// 'step') after the step has completed.
class NextRequest {
    int                  seq;       // json: "seq"
    mixed                type;      // json: "type"
    NextRequestArguments arguments; // json: "arguments"
    mixed                command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

NextRequest NextRequest_from_JSON(mixed json) {
    NextRequest retval = NextRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'next' request.
class NextRequestArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

NextRequestArguments NextRequestArguments_from_JSON(mixed json) {
    NextRequestArguments retval = NextRequestArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

constant NEXT = "next"; // json: "next"

// Arguments for 'next' request.
class NextArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

NextArguments NextArguments_from_JSON(mixed json) {
    NextArguments retval = NextArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'next' request. This is just an acknowledgement, so no body field is required.
class NextResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

NextResponse NextResponse_from_JSON(mixed json) {
    NextResponse retval = NextResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request starts the debuggee to step into a function/method if possible.
// If it cannot step into a target, 'stepIn' behaves like 'next'.
// The debug adapter first sends the response and then a 'stopped' event (with reason
// 'step') after the step has completed.
// If there are multiple function/method calls (or other targets) on the source line,
// the optional argument 'targetId' can be used to control into which target the 'stepIn'
// should occur.
// The list of possible targets for a given source line can be retrieved via the
// 'stepInTargets' request.
class StepInRequest {
    int                    seq;       // json: "seq"
    mixed                  type;      // json: "type"
    StepInRequestArguments arguments; // json: "arguments"
    mixed                  command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepInRequest StepInRequest_from_JSON(mixed json) {
    StepInRequest retval = StepInRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'stepIn' request.
class StepInRequestArguments {
    mixed target_id; // json: "targetId"
    int   thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "targetId" : target_id,
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepInRequestArguments StepInRequestArguments_from_JSON(mixed json) {
    StepInRequestArguments retval = StepInRequestArguments();

    retval.target_id = json["targetId"];
    retval.thread_id = json["threadId"];

    return retval;
}

constant STEP_IN = "stepIn"; // json: "stepIn"

// Arguments for 'stepIn' request.
class StepInArguments {
    mixed target_id; // json: "targetId"
    int   thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "targetId" : target_id,
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepInArguments StepInArguments_from_JSON(mixed json) {
    StepInArguments retval = StepInArguments();

    retval.target_id = json["targetId"];
    retval.thread_id = json["threadId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'stepIn' request. This is just an acknowledgement, so no body field is
// required.
class StepInResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepInResponse StepInResponse_from_JSON(mixed json) {
    StepInResponse retval = StepInResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request starts the debuggee to run again for one step.
// The debug adapter first sends the response and then a 'stopped' event (with reason
// 'step') after the step has completed.
class StepOutRequest {
    int                     seq;       // json: "seq"
    mixed                   type;      // json: "type"
    StepOutRequestArguments arguments; // json: "arguments"
    mixed                   command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepOutRequest StepOutRequest_from_JSON(mixed json) {
    StepOutRequest retval = StepOutRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'stepOut' request.
class StepOutRequestArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepOutRequestArguments StepOutRequestArguments_from_JSON(mixed json) {
    StepOutRequestArguments retval = StepOutRequestArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

constant STEP_OUT = "stepOut"; // json: "stepOut"

// Arguments for 'stepOut' request.
class StepOutArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepOutArguments StepOutArguments_from_JSON(mixed json) {
    StepOutArguments retval = StepOutArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'stepOut' request. This is just an acknowledgement, so no body field is
// required.
class StepOutResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepOutResponse StepOutResponse_from_JSON(mixed json) {
    StepOutResponse retval = StepOutResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request starts the debuggee to run one step backwards.
// The debug adapter first sends the response and then a 'stopped' event (with reason
// 'step') after the step has completed. Clients should only call this request if the
// capability 'supportsStepBack' is true.
class StepBackRequest {
    int                      seq;       // json: "seq"
    mixed                    type;      // json: "type"
    StepBackRequestArguments arguments; // json: "arguments"
    mixed                    command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepBackRequest StepBackRequest_from_JSON(mixed json) {
    StepBackRequest retval = StepBackRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'stepBack' request.
class StepBackRequestArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepBackRequestArguments StepBackRequestArguments_from_JSON(mixed json) {
    StepBackRequestArguments retval = StepBackRequestArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

constant STEP_BACK = "stepBack"; // json: "stepBack"

// Arguments for 'stepBack' request.
class StepBackArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepBackArguments StepBackArguments_from_JSON(mixed json) {
    StepBackArguments retval = StepBackArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'stepBack' request. This is just an acknowledgement, so no body field is
// required.
class StepBackResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepBackResponse StepBackResponse_from_JSON(mixed json) {
    StepBackResponse retval = StepBackResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request starts the debuggee to run backward. Clients should only call this request if
// the capability 'supportsStepBack' is true.
class ReverseContinueRequest {
    int                             seq;       // json: "seq"
    mixed                           type;      // json: "type"
    ReverseContinueRequestArguments arguments; // json: "arguments"
    mixed                           command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

ReverseContinueRequest ReverseContinueRequest_from_JSON(mixed json) {
    ReverseContinueRequest retval = ReverseContinueRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'reverseContinue' request.
class ReverseContinueRequestArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

ReverseContinueRequestArguments ReverseContinueRequestArguments_from_JSON(mixed json) {
    ReverseContinueRequestArguments retval = ReverseContinueRequestArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

constant REVERSE_CONTINUE = "reverseContinue"; // json: "reverseContinue"

// Arguments for 'reverseContinue' request.
class ReverseContinueArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

ReverseContinueArguments ReverseContinueArguments_from_JSON(mixed json) {
    ReverseContinueArguments retval = ReverseContinueArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'reverseContinue' request. This is just an acknowledgement, so no body field
// is required.
class ReverseContinueResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

ReverseContinueResponse ReverseContinueResponse_from_JSON(mixed json) {
    ReverseContinueResponse retval = ReverseContinueResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request restarts execution of the specified stackframe.
// The debug adapter first sends the response and then a 'stopped' event (with reason
// 'restart') after the restart has completed.
class RestartFrameRequest {
    int                          seq;       // json: "seq"
    mixed                        type;      // json: "type"
    RestartFrameRequestArguments arguments; // json: "arguments"
    mixed                        command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

RestartFrameRequest RestartFrameRequest_from_JSON(mixed json) {
    RestartFrameRequest retval = RestartFrameRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'restartFrame' request.
class RestartFrameRequestArguments {
    int frame_id; // json: "frameId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "frameId" : frame_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

RestartFrameRequestArguments RestartFrameRequestArguments_from_JSON(mixed json) {
    RestartFrameRequestArguments retval = RestartFrameRequestArguments();

    retval.frame_id = json["frameId"];

    return retval;
}

constant RESTART_FRAME = "restartFrame"; // json: "restartFrame"

// Arguments for 'restartFrame' request.
class RestartFrameArguments {
    int frame_id; // json: "frameId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "frameId" : frame_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

RestartFrameArguments RestartFrameArguments_from_JSON(mixed json) {
    RestartFrameArguments retval = RestartFrameArguments();

    retval.frame_id = json["frameId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'restartFrame' request. This is just an acknowledgement, so no body field is
// required.
class RestartFrameResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

RestartFrameResponse RestartFrameResponse_from_JSON(mixed json) {
    RestartFrameResponse retval = RestartFrameResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request sets the location where the debuggee will continue to run.
// This makes it possible to skip the execution of code or to executed code again.
// The code between the current location and the goto target is not executed but skipped.
// The debug adapter first sends the response and then a 'stopped' event with reason 'goto'.
class GotoRequest {
    int                  seq;       // json: "seq"
    mixed                type;      // json: "type"
    GotoRequestArguments arguments; // json: "arguments"
    mixed                command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

GotoRequest GotoRequest_from_JSON(mixed json) {
    GotoRequest retval = GotoRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'goto' request.
class GotoRequestArguments {
    int target_id; // json: "targetId"
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "targetId" : target_id,
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

GotoRequestArguments GotoRequestArguments_from_JSON(mixed json) {
    GotoRequestArguments retval = GotoRequestArguments();

    retval.target_id = json["targetId"];
    retval.thread_id = json["threadId"];

    return retval;
}

constant GOTO = "goto"; // json: "goto"

// Arguments for 'goto' request.
class GotoArguments {
    int target_id; // json: "targetId"
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "targetId" : target_id,
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

GotoArguments GotoArguments_from_JSON(mixed json) {
    GotoArguments retval = GotoArguments();

    retval.target_id = json["targetId"];
    retval.thread_id = json["threadId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'goto' request. This is just an acknowledgement, so no body field is required.
class GotoResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

GotoResponse GotoResponse_from_JSON(mixed json) {
    GotoResponse retval = GotoResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request suspenses the debuggee.
// The debug adapter first sends the response and then a 'stopped' event (with reason
// 'pause') after the thread has been paused successfully.
class PauseRequest {
    int                   seq;       // json: "seq"
    mixed                 type;      // json: "type"
    PauseRequestArguments arguments; // json: "arguments"
    mixed                 command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

PauseRequest PauseRequest_from_JSON(mixed json) {
    PauseRequest retval = PauseRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'pause' request.
class PauseRequestArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

PauseRequestArguments PauseRequestArguments_from_JSON(mixed json) {
    PauseRequestArguments retval = PauseRequestArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

constant PAUSE = "pause"; // json: "pause"

// Arguments for 'pause' request.
class PauseArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

PauseArguments PauseArguments_from_JSON(mixed json) {
    PauseArguments retval = PauseArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'pause' request. This is just an acknowledgement, so no body field is
// required.
class PauseResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

PauseResponse PauseResponse_from_JSON(mixed json) {
    PauseResponse retval = PauseResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request returns a stacktrace from the current execution state.
class StackTraceRequest {
    int                        seq;       // json: "seq"
    mixed                      type;      // json: "type"
    StackTraceRequestArguments arguments; // json: "arguments"
    mixed                      command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

StackTraceRequest StackTraceRequest_from_JSON(mixed json) {
    StackTraceRequest retval = StackTraceRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'stackTrace' request.
class StackTraceRequestArguments {
    mixed format;      // json: "format"
    mixed levels;      // json: "levels"
    mixed start_frame; // json: "startFrame"
    int   thread_id;   // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "format" : format,
            "levels" : levels,
            "startFrame" : start_frame,
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

StackTraceRequestArguments StackTraceRequestArguments_from_JSON(mixed json) {
    StackTraceRequestArguments retval = StackTraceRequestArguments();

    retval.format = json["format"];
    retval.levels = json["levels"];
    retval.start_frame = json["startFrame"];
    retval.thread_id = json["threadId"];

    return retval;
}

// Specifies details on how to format the stack frames.
//
// Provides formatting information for a value.
//
// Specifies details on how to format the Variable values.
//
// Specifies details on how to format the response value.
//
// Specifies details on how to format the Evaluate result.
//
// Specifies how the resulting value should be formatted.
//
// Provides formatting information for a stack frame.
class StackFrameFormat {
    mixed hex;              // json: "hex"
    mixed include_all;      // json: "includeAll"
    mixed line;             // json: "line"
    mixed module;           // json: "module"
    mixed parameter_names;  // json: "parameterNames"
    mixed parameters;       // json: "parameters"
    mixed parameter_types;  // json: "parameterTypes"
    mixed parameter_values; // json: "parameterValues"

    string encode_json() {
        mapping(string:mixed) json = ([
            "hex" : hex,
            "includeAll" : include_all,
            "line" : line,
            "module" : module,
            "parameterNames" : parameter_names,
            "parameters" : parameters,
            "parameterTypes" : parameter_types,
            "parameterValues" : parameter_values,
        ]);

        return Standards.JSON.encode(json);
    }
}

StackFrameFormat StackFrameFormat_from_JSON(mixed json) {
    StackFrameFormat retval = StackFrameFormat();

    retval.hex = json["hex"];
    retval.include_all = json["includeAll"];
    retval.line = json["line"];
    retval.module = json["module"];
    retval.parameter_names = json["parameterNames"];
    retval.parameters = json["parameters"];
    retval.parameter_types = json["parameterTypes"];
    retval.parameter_values = json["parameterValues"];

    return retval;
}

constant STACK_TRACE = "stackTrace"; // json: "stackTrace"

// Arguments for 'stackTrace' request.
class StackTraceArguments {
    mixed format;      // json: "format"
    mixed levels;      // json: "levels"
    mixed start_frame; // json: "startFrame"
    int   thread_id;   // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "format" : format,
            "levels" : levels,
            "startFrame" : start_frame,
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

StackTraceArguments StackTraceArguments_from_JSON(mixed json) {
    StackTraceArguments retval = StackTraceArguments();

    retval.format = json["format"];
    retval.levels = json["levels"];
    retval.start_frame = json["startFrame"];
    retval.thread_id = json["threadId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'stackTrace' request.
class StackTraceResponse {
    int                    seq;         // json: "seq"
    mixed                  type;        // json: "type"
    StackTraceResponseBody body;        // json: "body"
    string                 command;     // json: "command"
    mixed                  message;     // json: "message"
    int                    request_seq; // json: "request_seq"
    bool                   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

StackTraceResponse StackTraceResponse_from_JSON(mixed json) {
    StackTraceResponse retval = StackTraceResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class StackTraceResponseBody {
    array(StackFrame) stack_frames; // json: "stackFrames"
    mixed             total_frames; // json: "totalFrames"

    string encode_json() {
        mapping(string:mixed) json = ([
            "stackFrames" : stack_frames,
            "totalFrames" : total_frames,
        ]);

        return Standards.JSON.encode(json);
    }
}

StackTraceResponseBody StackTraceResponseBody_from_JSON(mixed json) {
    StackTraceResponseBody retval = StackTraceResponseBody();

    retval.stack_frames = json["stackFrames"];
    retval.total_frames = json["totalFrames"];

    return retval;
}

// A Stackframe contains the source location.
class StackFrame {
    int    column;            // json: "column"
    mixed  end_column;        // json: "endColumn"
    mixed  end_line;          // json: "endLine"
    int    id;                // json: "id"
    int    line;              // json: "line"
    mixed  module_id;         // json: "moduleId"
    string name;              // json: "name"
    mixed  presentation_hint; // json: "presentationHint"
    mixed  source;            // json: "source"

    string encode_json() {
        mapping(string:mixed) json = ([
            "column" : column,
            "endColumn" : end_column,
            "endLine" : end_line,
            "id" : id,
            "line" : line,
            "moduleId" : module_id,
            "name" : name,
            "presentationHint" : presentation_hint,
            "source" : source,
        ]);

        return Standards.JSON.encode(json);
    }
}

StackFrame StackFrame_from_JSON(mixed json) {
    StackFrame retval = StackFrame();

    retval.column = json["column"];
    retval.end_column = json["endColumn"];
    retval.end_line = json["endLine"];
    retval.id = json["id"];
    retval.line = json["line"];
    retval.module_id = json["moduleId"];
    retval.name = json["name"];
    retval.presentation_hint = json["presentationHint"];
    retval.source = json["source"];

    return retval;
}

// Unique identifier for the module.
//
// The module associated with this frame, if any.
typedef int|string ModuleIdUnion;

ModuleIdUnion ModuleIdUnion_from_JSON(mixed json) {
    return json;
}

constant FLUFFY_NORMAL = "normal"; // json: "normal"
constant LABEL = "label";          // json: "label"
constant SUBTLE = "subtle";        // json: "subtle"

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request returns the variable scopes for a given stackframe ID.
class ScopesRequest {
    int                    seq;       // json: "seq"
    mixed                  type;      // json: "type"
    ScopesRequestArguments arguments; // json: "arguments"
    mixed                  command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

ScopesRequest ScopesRequest_from_JSON(mixed json) {
    ScopesRequest retval = ScopesRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'scopes' request.
class ScopesRequestArguments {
    int frame_id; // json: "frameId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "frameId" : frame_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

ScopesRequestArguments ScopesRequestArguments_from_JSON(mixed json) {
    ScopesRequestArguments retval = ScopesRequestArguments();

    retval.frame_id = json["frameId"];

    return retval;
}

constant SCOPES = "scopes"; // json: "scopes"

// Arguments for 'scopes' request.
class ScopesArguments {
    int frame_id; // json: "frameId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "frameId" : frame_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

ScopesArguments ScopesArguments_from_JSON(mixed json) {
    ScopesArguments retval = ScopesArguments();

    retval.frame_id = json["frameId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'scopes' request.
class ScopesResponse {
    int                seq;         // json: "seq"
    mixed              type;        // json: "type"
    ScopesResponseBody body;        // json: "body"
    string             command;     // json: "command"
    mixed              message;     // json: "message"
    int                request_seq; // json: "request_seq"
    bool               success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

ScopesResponse ScopesResponse_from_JSON(mixed json) {
    ScopesResponse retval = ScopesResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class ScopesResponseBody {
    array(Scope) scopes; // json: "scopes"

    string encode_json() {
        mapping(string:mixed) json = ([
            "scopes" : scopes,
        ]);

        return Standards.JSON.encode(json);
    }
}

ScopesResponseBody ScopesResponseBody_from_JSON(mixed json) {
    ScopesResponseBody retval = ScopesResponseBody();

    retval.scopes = json["scopes"];

    return retval;
}

// A Scope is a named container for variables. Optionally a scope can map to a source or a
// range within a source.
class Scope {
    mixed  column;              // json: "column"
    mixed  end_column;          // json: "endColumn"
    mixed  end_line;            // json: "endLine"
    bool   expensive;           // json: "expensive"
    mixed  indexed_variables;   // json: "indexedVariables"
    mixed  line;                // json: "line"
    string name;                // json: "name"
    mixed  named_variables;     // json: "namedVariables"
    mixed  source;              // json: "source"
    int    variables_reference; // json: "variablesReference"

    string encode_json() {
        mapping(string:mixed) json = ([
            "column" : column,
            "endColumn" : end_column,
            "endLine" : end_line,
            "expensive" : expensive,
            "indexedVariables" : indexed_variables,
            "line" : line,
            "name" : name,
            "namedVariables" : named_variables,
            "source" : source,
            "variablesReference" : variables_reference,
        ]);

        return Standards.JSON.encode(json);
    }
}

Scope Scope_from_JSON(mixed json) {
    Scope retval = Scope();

    retval.column = json["column"];
    retval.end_column = json["endColumn"];
    retval.end_line = json["endLine"];
    retval.expensive = json["expensive"];
    retval.indexed_variables = json["indexedVariables"];
    retval.line = json["line"];
    retval.name = json["name"];
    retval.named_variables = json["namedVariables"];
    retval.source = json["source"];
    retval.variables_reference = json["variablesReference"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// Retrieves all child variables for the given variable reference.
// An optional filter can be used to limit the fetched children to either named or indexed
// children.
class VariablesRequest {
    int                       seq;       // json: "seq"
    mixed                     type;      // json: "type"
    VariablesRequestArguments arguments; // json: "arguments"
    mixed                     command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

VariablesRequest VariablesRequest_from_JSON(mixed json) {
    VariablesRequest retval = VariablesRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'variables' request.
class VariablesRequestArguments {
    mixed count;               // json: "count"
    mixed filter;              // json: "filter"
    mixed format;              // json: "format"
    mixed start;               // json: "start"
    int   variables_reference; // json: "variablesReference"

    string encode_json() {
        mapping(string:mixed) json = ([
            "count" : count,
            "filter" : filter,
            "format" : format,
            "start" : start,
            "variablesReference" : variables_reference,
        ]);

        return Standards.JSON.encode(json);
    }
}

VariablesRequestArguments VariablesRequestArguments_from_JSON(mixed json) {
    VariablesRequestArguments retval = VariablesRequestArguments();

    retval.count = json["count"];
    retval.filter = json["filter"];
    retval.format = json["format"];
    retval.start = json["start"];
    retval.variables_reference = json["variablesReference"];

    return retval;
}

constant INDEXED = "indexed"; // json: "indexed"
constant NAMED = "named";     // json: "named"

// Provides formatting information for a value.
//
// Specifies details on how to format the Variable values.
//
// Specifies details on how to format the response value.
//
// Specifies details on how to format the Evaluate result.
//
// Specifies how the resulting value should be formatted.
class ValueFormat {
    mixed hex; // json: "hex"

    string encode_json() {
        mapping(string:mixed) json = ([
            "hex" : hex,
        ]);

        return Standards.JSON.encode(json);
    }
}

ValueFormat ValueFormat_from_JSON(mixed json) {
    ValueFormat retval = ValueFormat();

    retval.hex = json["hex"];

    return retval;
}

constant VARIABLES = "variables"; // json: "variables"

// Arguments for 'variables' request.
class VariablesArguments {
    mixed count;               // json: "count"
    mixed filter;              // json: "filter"
    mixed format;              // json: "format"
    mixed start;               // json: "start"
    int   variables_reference; // json: "variablesReference"

    string encode_json() {
        mapping(string:mixed) json = ([
            "count" : count,
            "filter" : filter,
            "format" : format,
            "start" : start,
            "variablesReference" : variables_reference,
        ]);

        return Standards.JSON.encode(json);
    }
}

VariablesArguments VariablesArguments_from_JSON(mixed json) {
    VariablesArguments retval = VariablesArguments();

    retval.count = json["count"];
    retval.filter = json["filter"];
    retval.format = json["format"];
    retval.start = json["start"];
    retval.variables_reference = json["variablesReference"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'variables' request.
class VariablesResponse {
    int                   seq;         // json: "seq"
    mixed                 type;        // json: "type"
    VariablesResponseBody body;        // json: "body"
    string                command;     // json: "command"
    mixed                 message;     // json: "message"
    int                   request_seq; // json: "request_seq"
    bool                  success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

VariablesResponse VariablesResponse_from_JSON(mixed json) {
    VariablesResponse retval = VariablesResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class VariablesResponseBody {
    array(Variable) variables; // json: "variables"

    string encode_json() {
        mapping(string:mixed) json = ([
            "variables" : variables,
        ]);

        return Standards.JSON.encode(json);
    }
}

VariablesResponseBody VariablesResponseBody_from_JSON(mixed json) {
    VariablesResponseBody retval = VariablesResponseBody();

    retval.variables = json["variables"];

    return retval;
}

// A Variable is a name/value pair.
// Optionally a variable can have a 'type' that is shown if space permits or when hovering
// over the variable's name.
// An optional 'kind' is used to render additional properties of the variable, e.g.
// different icons can be used to indicate that a variable is public or private.
// If the value is structured (has children), a handle is provided to retrieve the children
// with the VariablesRequest.
// If the number of named or indexed children is large, the numbers should be returned via
// the optional 'namedVariables' and 'indexedVariables' attributes.
// The client can use this optional information to present the children in a paged UI and
// fetch them in chunks.
class Variable {
    mixed  evaluate_name;       // json: "evaluateName"
    mixed  indexed_variables;   // json: "indexedVariables"
    string name;                // json: "name"
    mixed  named_variables;     // json: "namedVariables"
    mixed  presentation_hint;   // json: "presentationHint"
    mixed  type;                // json: "type"
    string value;               // json: "value"
    int    variables_reference; // json: "variablesReference"

    string encode_json() {
        mapping(string:mixed) json = ([
            "evaluateName" : evaluate_name,
            "indexedVariables" : indexed_variables,
            "name" : name,
            "namedVariables" : named_variables,
            "presentationHint" : presentation_hint,
            "type" : type,
            "value" : value,
            "variablesReference" : variables_reference,
        ]);

        return Standards.JSON.encode(json);
    }
}

Variable Variable_from_JSON(mixed json) {
    Variable retval = Variable();

    retval.evaluate_name = json["evaluateName"];
    retval.indexed_variables = json["indexedVariables"];
    retval.name = json["name"];
    retval.named_variables = json["namedVariables"];
    retval.presentation_hint = json["presentationHint"];
    retval.type = json["type"];
    retval.value = json["value"];
    retval.variables_reference = json["variablesReference"];

    return retval;
}

// Properties of a variable that can be used to determine how to render the variable in the
// UI.
//
// Optional properties of a variable that can be used to determine how to render the
// variable in the UI.
//
// Properties of a evaluate result that can be used to determine how to render the result in
// the UI.
//
// Properties of a value that can be used to determine how to render the result in the UI.
class VariablePresentationHint {
    mixed attributes; // json: "attributes"
    mixed kind;       // json: "kind"
    mixed visibility; // json: "visibility"

    string encode_json() {
        mapping(string:mixed) json = ([
            "attributes" : attributes,
            "kind" : kind,
            "visibility" : visibility,
        ]);

        return Standards.JSON.encode(json);
    }
}

VariablePresentationHint VariablePresentationHint_from_JSON(mixed json) {
    VariablePresentationHint retval = VariablePresentationHint();

    retval.attributes = json["attributes"];
    retval.kind = json["kind"];
    retval.visibility = json["visibility"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// Set the variable with the given name in the variable container to a new value.
class SetVariableRequest {
    int                         seq;       // json: "seq"
    mixed                       type;      // json: "type"
    SetVariableRequestArguments arguments; // json: "arguments"
    mixed                       command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetVariableRequest SetVariableRequest_from_JSON(mixed json) {
    SetVariableRequest retval = SetVariableRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'setVariable' request.
class SetVariableRequestArguments {
    mixed  format;              // json: "format"
    string name;                // json: "name"
    string value;               // json: "value"
    int    variables_reference; // json: "variablesReference"

    string encode_json() {
        mapping(string:mixed) json = ([
            "format" : format,
            "name" : name,
            "value" : value,
            "variablesReference" : variables_reference,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetVariableRequestArguments SetVariableRequestArguments_from_JSON(mixed json) {
    SetVariableRequestArguments retval = SetVariableRequestArguments();

    retval.format = json["format"];
    retval.name = json["name"];
    retval.value = json["value"];
    retval.variables_reference = json["variablesReference"];

    return retval;
}

constant SET_VARIABLE = "setVariable"; // json: "setVariable"

// Arguments for 'setVariable' request.
class SetVariableArguments {
    mixed  format;              // json: "format"
    string name;                // json: "name"
    string value;               // json: "value"
    int    variables_reference; // json: "variablesReference"

    string encode_json() {
        mapping(string:mixed) json = ([
            "format" : format,
            "name" : name,
            "value" : value,
            "variablesReference" : variables_reference,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetVariableArguments SetVariableArguments_from_JSON(mixed json) {
    SetVariableArguments retval = SetVariableArguments();

    retval.format = json["format"];
    retval.name = json["name"];
    retval.value = json["value"];
    retval.variables_reference = json["variablesReference"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'setVariable' request.
class SetVariableResponse {
    int                     seq;         // json: "seq"
    mixed                   type;        // json: "type"
    SetVariableResponseBody body;        // json: "body"
    string                  command;     // json: "command"
    mixed                   message;     // json: "message"
    int                     request_seq; // json: "request_seq"
    bool                    success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetVariableResponse SetVariableResponse_from_JSON(mixed json) {
    SetVariableResponse retval = SetVariableResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class SetVariableResponseBody {
    mixed  indexed_variables;   // json: "indexedVariables"
    mixed  named_variables;     // json: "namedVariables"
    mixed  type;                // json: "type"
    string value;               // json: "value"
    mixed  variables_reference; // json: "variablesReference"

    string encode_json() {
        mapping(string:mixed) json = ([
            "indexedVariables" : indexed_variables,
            "namedVariables" : named_variables,
            "type" : type,
            "value" : value,
            "variablesReference" : variables_reference,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetVariableResponseBody SetVariableResponseBody_from_JSON(mixed json) {
    SetVariableResponseBody retval = SetVariableResponseBody();

    retval.indexed_variables = json["indexedVariables"];
    retval.named_variables = json["namedVariables"];
    retval.type = json["type"];
    retval.value = json["value"];
    retval.variables_reference = json["variablesReference"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request retrieves the source code for a given source reference.
class SourceRequest {
    int                    seq;       // json: "seq"
    mixed                  type;      // json: "type"
    SourceRequestArguments arguments; // json: "arguments"
    mixed                  command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

SourceRequest SourceRequest_from_JSON(mixed json) {
    SourceRequest retval = SourceRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'source' request.
class SourceRequestArguments {
    mixed source;           // json: "source"
    int   source_reference; // json: "sourceReference"

    string encode_json() {
        mapping(string:mixed) json = ([
            "source" : source,
            "sourceReference" : source_reference,
        ]);

        return Standards.JSON.encode(json);
    }
}

SourceRequestArguments SourceRequestArguments_from_JSON(mixed json) {
    SourceRequestArguments retval = SourceRequestArguments();

    retval.source = json["source"];
    retval.source_reference = json["sourceReference"];

    return retval;
}

constant SOURCE = "source"; // json: "source"

// Arguments for 'source' request.
class SourceArguments {
    mixed source;           // json: "source"
    int   source_reference; // json: "sourceReference"

    string encode_json() {
        mapping(string:mixed) json = ([
            "source" : source,
            "sourceReference" : source_reference,
        ]);

        return Standards.JSON.encode(json);
    }
}

SourceArguments SourceArguments_from_JSON(mixed json) {
    SourceArguments retval = SourceArguments();

    retval.source = json["source"];
    retval.source_reference = json["sourceReference"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'source' request.
class SourceResponse {
    int                seq;         // json: "seq"
    mixed              type;        // json: "type"
    SourceResponseBody body;        // json: "body"
    string             command;     // json: "command"
    mixed              message;     // json: "message"
    int                request_seq; // json: "request_seq"
    bool               success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

SourceResponse SourceResponse_from_JSON(mixed json) {
    SourceResponse retval = SourceResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class SourceResponseBody {
    string content;   // json: "content"
    mixed  mime_type; // json: "mimeType"

    string encode_json() {
        mapping(string:mixed) json = ([
            "content" : content,
            "mimeType" : mime_type,
        ]);

        return Standards.JSON.encode(json);
    }
}

SourceResponseBody SourceResponseBody_from_JSON(mixed json) {
    SourceResponseBody retval = SourceResponseBody();

    retval.content = json["content"];
    retval.mime_type = json["mimeType"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request retrieves a list of all threads.
class ThreadsRequest {
    int   seq;       // json: "seq"
    mixed type;      // json: "type"
    mixed arguments; // json: "arguments"
    mixed command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

ThreadsRequest ThreadsRequest_from_JSON(mixed json) {
    ThreadsRequest retval = ThreadsRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

constant THREADS = "threads"; // json: "threads"

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'threads' request.
class ThreadsResponse {
    int                 seq;         // json: "seq"
    mixed               type;        // json: "type"
    ThreadsResponseBody body;        // json: "body"
    string              command;     // json: "command"
    mixed               message;     // json: "message"
    int                 request_seq; // json: "request_seq"
    bool                success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

ThreadsResponse ThreadsResponse_from_JSON(mixed json) {
    ThreadsResponse retval = ThreadsResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class ThreadsResponseBody {
    array(Thread) threads; // json: "threads"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threads" : threads,
        ]);

        return Standards.JSON.encode(json);
    }
}

ThreadsResponseBody ThreadsResponseBody_from_JSON(mixed json) {
    ThreadsResponseBody retval = ThreadsResponseBody();

    retval.threads = json["threads"];

    return retval;
}

// A Thread
class Thread {
    int    id;   // json: "id"
    string name; // json: "name"

    string encode_json() {
        mapping(string:mixed) json = ([
            "id" : id,
            "name" : name,
        ]);

        return Standards.JSON.encode(json);
    }
}

Thread Thread_from_JSON(mixed json) {
    Thread retval = Thread();

    retval.id = json["id"];
    retval.name = json["name"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// The request terminates the threads with the given ids.
class TerminateThreadsRequest {
    int                              seq;       // json: "seq"
    mixed                            type;      // json: "type"
    TerminateThreadsRequestArguments arguments; // json: "arguments"
    mixed                            command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

TerminateThreadsRequest TerminateThreadsRequest_from_JSON(mixed json) {
    TerminateThreadsRequest retval = TerminateThreadsRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'terminateThreads' request.
class TerminateThreadsRequestArguments {
    mixed thread_ids; // json: "threadIds"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadIds" : thread_ids,
        ]);

        return Standards.JSON.encode(json);
    }
}

TerminateThreadsRequestArguments TerminateThreadsRequestArguments_from_JSON(mixed json) {
    TerminateThreadsRequestArguments retval = TerminateThreadsRequestArguments();

    retval.thread_ids = json["threadIds"];

    return retval;
}

constant TERMINATE_THREADS = "terminateThreads"; // json: "terminateThreads"

// Arguments for 'terminateThreads' request.
class TerminateThreadsArguments {
    mixed thread_ids; // json: "threadIds"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadIds" : thread_ids,
        ]);

        return Standards.JSON.encode(json);
    }
}

TerminateThreadsArguments TerminateThreadsArguments_from_JSON(mixed json) {
    TerminateThreadsArguments retval = TerminateThreadsArguments();

    retval.thread_ids = json["threadIds"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'terminateThreads' request. This is just an acknowledgement, so no body field
// is required.
class TerminateThreadsResponse {
    int    seq;         // json: "seq"
    mixed  type;        // json: "type"
    mixed  body;        // json: "body"
    string command;     // json: "command"
    mixed  message;     // json: "message"
    int    request_seq; // json: "request_seq"
    bool   success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

TerminateThreadsResponse TerminateThreadsResponse_from_JSON(mixed json) {
    TerminateThreadsResponse retval = TerminateThreadsResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// Modules can be retrieved from the debug adapter with the ModulesRequest which can either
// return all modules or a range of modules to support paging.
class ModulesRequest {
    int                     seq;       // json: "seq"
    mixed                   type;      // json: "type"
    ModulesRequestArguments arguments; // json: "arguments"
    mixed                   command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

ModulesRequest ModulesRequest_from_JSON(mixed json) {
    ModulesRequest retval = ModulesRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'modules' request.
class ModulesRequestArguments {
    mixed module_count; // json: "moduleCount"
    mixed start_module; // json: "startModule"

    string encode_json() {
        mapping(string:mixed) json = ([
            "moduleCount" : module_count,
            "startModule" : start_module,
        ]);

        return Standards.JSON.encode(json);
    }
}

ModulesRequestArguments ModulesRequestArguments_from_JSON(mixed json) {
    ModulesRequestArguments retval = ModulesRequestArguments();

    retval.module_count = json["moduleCount"];
    retval.start_module = json["startModule"];

    return retval;
}

constant MODULES = "modules"; // json: "modules"

// Arguments for 'modules' request.
class ModulesArguments {
    mixed module_count; // json: "moduleCount"
    mixed start_module; // json: "startModule"

    string encode_json() {
        mapping(string:mixed) json = ([
            "moduleCount" : module_count,
            "startModule" : start_module,
        ]);

        return Standards.JSON.encode(json);
    }
}

ModulesArguments ModulesArguments_from_JSON(mixed json) {
    ModulesArguments retval = ModulesArguments();

    retval.module_count = json["moduleCount"];
    retval.start_module = json["startModule"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'modules' request.
class ModulesResponse {
    int                 seq;         // json: "seq"
    mixed               type;        // json: "type"
    ModulesResponseBody body;        // json: "body"
    string              command;     // json: "command"
    mixed               message;     // json: "message"
    int                 request_seq; // json: "request_seq"
    bool                success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

ModulesResponse ModulesResponse_from_JSON(mixed json) {
    ModulesResponse retval = ModulesResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class ModulesResponseBody {
    array(Module) modules;       // json: "modules"
    mixed         total_modules; // json: "totalModules"

    string encode_json() {
        mapping(string:mixed) json = ([
            "modules" : modules,
            "totalModules" : total_modules,
        ]);

        return Standards.JSON.encode(json);
    }
}

ModulesResponseBody ModulesResponseBody_from_JSON(mixed json) {
    ModulesResponseBody retval = ModulesResponseBody();

    retval.modules = json["modules"];
    retval.total_modules = json["totalModules"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// Retrieves the set of all sources currently loaded by the debugged process.
class LoadedSourcesRequest {
    int   seq;       // json: "seq"
    mixed type;      // json: "type"
    mixed arguments; // json: "arguments"
    mixed command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

LoadedSourcesRequest LoadedSourcesRequest_from_JSON(mixed json) {
    LoadedSourcesRequest retval = LoadedSourcesRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

constant LOADED_SOURCES = "loadedSources"; // json: "loadedSources"

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'loadedSources' request.
class LoadedSourcesResponse {
    int                       seq;         // json: "seq"
    mixed                     type;        // json: "type"
    LoadedSourcesResponseBody body;        // json: "body"
    string                    command;     // json: "command"
    mixed                     message;     // json: "message"
    int                       request_seq; // json: "request_seq"
    bool                      success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

LoadedSourcesResponse LoadedSourcesResponse_from_JSON(mixed json) {
    LoadedSourcesResponse retval = LoadedSourcesResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class LoadedSourcesResponseBody {
    array(Source) sources; // json: "sources"

    string encode_json() {
        mapping(string:mixed) json = ([
            "sources" : sources,
        ]);

        return Standards.JSON.encode(json);
    }
}

LoadedSourcesResponseBody LoadedSourcesResponseBody_from_JSON(mixed json) {
    LoadedSourcesResponseBody retval = LoadedSourcesResponseBody();

    retval.sources = json["sources"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// Evaluates the given expression in the context of the top most stack frame.
// The expression has access to any variables and arguments that are in scope.
class EvaluateRequest {
    int                      seq;       // json: "seq"
    mixed                    type;      // json: "type"
    EvaluateRequestArguments arguments; // json: "arguments"
    mixed                    command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

EvaluateRequest EvaluateRequest_from_JSON(mixed json) {
    EvaluateRequest retval = EvaluateRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'evaluate' request.
class EvaluateRequestArguments {
    mixed  context;    // json: "context"
    string expression; // json: "expression"
    mixed  format;     // json: "format"
    mixed  frame_id;   // json: "frameId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "context" : context,
            "expression" : expression,
            "format" : format,
            "frameId" : frame_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

EvaluateRequestArguments EvaluateRequestArguments_from_JSON(mixed json) {
    EvaluateRequestArguments retval = EvaluateRequestArguments();

    retval.context = json["context"];
    retval.expression = json["expression"];
    retval.format = json["format"];
    retval.frame_id = json["frameId"];

    return retval;
}

constant EVALUATE = "evaluate"; // json: "evaluate"

// Arguments for 'evaluate' request.
class EvaluateArguments {
    mixed  context;    // json: "context"
    string expression; // json: "expression"
    mixed  format;     // json: "format"
    mixed  frame_id;   // json: "frameId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "context" : context,
            "expression" : expression,
            "format" : format,
            "frameId" : frame_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

EvaluateArguments EvaluateArguments_from_JSON(mixed json) {
    EvaluateArguments retval = EvaluateArguments();

    retval.context = json["context"];
    retval.expression = json["expression"];
    retval.format = json["format"];
    retval.frame_id = json["frameId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'evaluate' request.
class EvaluateResponse {
    int                  seq;         // json: "seq"
    mixed                type;        // json: "type"
    EvaluateResponseBody body;        // json: "body"
    string               command;     // json: "command"
    mixed                message;     // json: "message"
    int                  request_seq; // json: "request_seq"
    bool                 success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

EvaluateResponse EvaluateResponse_from_JSON(mixed json) {
    EvaluateResponse retval = EvaluateResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class EvaluateResponseBody {
    mixed  indexed_variables;   // json: "indexedVariables"
    mixed  named_variables;     // json: "namedVariables"
    mixed  presentation_hint;   // json: "presentationHint"
    string result;              // json: "result"
    mixed  type;                // json: "type"
    float  variables_reference; // json: "variablesReference"

    string encode_json() {
        mapping(string:mixed) json = ([
            "indexedVariables" : indexed_variables,
            "namedVariables" : named_variables,
            "presentationHint" : presentation_hint,
            "result" : result,
            "type" : type,
            "variablesReference" : variables_reference,
        ]);

        return Standards.JSON.encode(json);
    }
}

EvaluateResponseBody EvaluateResponseBody_from_JSON(mixed json) {
    EvaluateResponseBody retval = EvaluateResponseBody();

    retval.indexed_variables = json["indexedVariables"];
    retval.named_variables = json["namedVariables"];
    retval.presentation_hint = json["presentationHint"];
    retval.result = json["result"];
    retval.type = json["type"];
    retval.variables_reference = json["variablesReference"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// Evaluates the given 'value' expression and assigns it to the 'expression' which must be a
// modifiable l-value.
// The expressions have access to any variables and arguments that are in scope of the
// specified frame.
class SetExpressionRequest {
    int                           seq;       // json: "seq"
    mixed                         type;      // json: "type"
    SetExpressionRequestArguments arguments; // json: "arguments"
    mixed                         command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetExpressionRequest SetExpressionRequest_from_JSON(mixed json) {
    SetExpressionRequest retval = SetExpressionRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'setExpression' request.
class SetExpressionRequestArguments {
    string expression; // json: "expression"
    mixed  format;     // json: "format"
    mixed  frame_id;   // json: "frameId"
    string value;      // json: "value"

    string encode_json() {
        mapping(string:mixed) json = ([
            "expression" : expression,
            "format" : format,
            "frameId" : frame_id,
            "value" : value,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetExpressionRequestArguments SetExpressionRequestArguments_from_JSON(mixed json) {
    SetExpressionRequestArguments retval = SetExpressionRequestArguments();

    retval.expression = json["expression"];
    retval.format = json["format"];
    retval.frame_id = json["frameId"];
    retval.value = json["value"];

    return retval;
}

constant SET_EXPRESSION = "setExpression"; // json: "setExpression"

// Arguments for 'setExpression' request.
class SetExpressionArguments {
    string expression; // json: "expression"
    mixed  format;     // json: "format"
    mixed  frame_id;   // json: "frameId"
    string value;      // json: "value"

    string encode_json() {
        mapping(string:mixed) json = ([
            "expression" : expression,
            "format" : format,
            "frameId" : frame_id,
            "value" : value,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetExpressionArguments SetExpressionArguments_from_JSON(mixed json) {
    SetExpressionArguments retval = SetExpressionArguments();

    retval.expression = json["expression"];
    retval.format = json["format"];
    retval.frame_id = json["frameId"];
    retval.value = json["value"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'setExpression' request.
class SetExpressionResponse {
    int                       seq;         // json: "seq"
    mixed                     type;        // json: "type"
    SetExpressionResponseBody body;        // json: "body"
    string                    command;     // json: "command"
    mixed                     message;     // json: "message"
    int                       request_seq; // json: "request_seq"
    bool                      success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetExpressionResponse SetExpressionResponse_from_JSON(mixed json) {
    SetExpressionResponse retval = SetExpressionResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class SetExpressionResponseBody {
    mixed  indexed_variables;   // json: "indexedVariables"
    mixed  named_variables;     // json: "namedVariables"
    mixed  presentation_hint;   // json: "presentationHint"
    mixed  type;                // json: "type"
    string value;               // json: "value"
    mixed  variables_reference; // json: "variablesReference"

    string encode_json() {
        mapping(string:mixed) json = ([
            "indexedVariables" : indexed_variables,
            "namedVariables" : named_variables,
            "presentationHint" : presentation_hint,
            "type" : type,
            "value" : value,
            "variablesReference" : variables_reference,
        ]);

        return Standards.JSON.encode(json);
    }
}

SetExpressionResponseBody SetExpressionResponseBody_from_JSON(mixed json) {
    SetExpressionResponseBody retval = SetExpressionResponseBody();

    retval.indexed_variables = json["indexedVariables"];
    retval.named_variables = json["namedVariables"];
    retval.presentation_hint = json["presentationHint"];
    retval.type = json["type"];
    retval.value = json["value"];
    retval.variables_reference = json["variablesReference"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// This request retrieves the possible stepIn targets for the specified stack frame.
// These targets can be used in the 'stepIn' request.
// The StepInTargets may only be called if the 'supportsStepInTargetsRequest' capability
// exists and is true.
class StepInTargetsRequest {
    int                           seq;       // json: "seq"
    mixed                         type;      // json: "type"
    StepInTargetsRequestArguments arguments; // json: "arguments"
    mixed                         command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepInTargetsRequest StepInTargetsRequest_from_JSON(mixed json) {
    StepInTargetsRequest retval = StepInTargetsRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'stepInTargets' request.
class StepInTargetsRequestArguments {
    int frame_id; // json: "frameId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "frameId" : frame_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepInTargetsRequestArguments StepInTargetsRequestArguments_from_JSON(mixed json) {
    StepInTargetsRequestArguments retval = StepInTargetsRequestArguments();

    retval.frame_id = json["frameId"];

    return retval;
}

constant STEP_IN_TARGETS = "stepInTargets"; // json: "stepInTargets"

// Arguments for 'stepInTargets' request.
class StepInTargetsArguments {
    int frame_id; // json: "frameId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "frameId" : frame_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepInTargetsArguments StepInTargetsArguments_from_JSON(mixed json) {
    StepInTargetsArguments retval = StepInTargetsArguments();

    retval.frame_id = json["frameId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'stepInTargets' request.
class StepInTargetsResponse {
    int                       seq;         // json: "seq"
    mixed                     type;        // json: "type"
    StepInTargetsResponseBody body;        // json: "body"
    string                    command;     // json: "command"
    mixed                     message;     // json: "message"
    int                       request_seq; // json: "request_seq"
    bool                      success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepInTargetsResponse StepInTargetsResponse_from_JSON(mixed json) {
    StepInTargetsResponse retval = StepInTargetsResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class StepInTargetsResponseBody {
    array(StepInTarget) targets; // json: "targets"

    string encode_json() {
        mapping(string:mixed) json = ([
            "targets" : targets,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepInTargetsResponseBody StepInTargetsResponseBody_from_JSON(mixed json) {
    StepInTargetsResponseBody retval = StepInTargetsResponseBody();

    retval.targets = json["targets"];

    return retval;
}

// A StepInTarget can be used in the 'stepIn' request and determines into which single
// target the stepIn request should step.
class StepInTarget {
    int    id;    // json: "id"
    string label; // json: "label"

    string encode_json() {
        mapping(string:mixed) json = ([
            "id" : id,
            "label" : label,
        ]);

        return Standards.JSON.encode(json);
    }
}

StepInTarget StepInTarget_from_JSON(mixed json) {
    StepInTarget retval = StepInTarget();

    retval.id = json["id"];
    retval.label = json["label"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// This request retrieves the possible goto targets for the specified source location.
// These targets can be used in the 'goto' request.
// The GotoTargets request may only be called if the 'supportsGotoTargetsRequest' capability
// exists and is true.
class GotoTargetsRequest {
    int                         seq;       // json: "seq"
    mixed                       type;      // json: "type"
    GotoTargetsRequestArguments arguments; // json: "arguments"
    mixed                       command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

GotoTargetsRequest GotoTargetsRequest_from_JSON(mixed json) {
    GotoTargetsRequest retval = GotoTargetsRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'gotoTargets' request.
class GotoTargetsRequestArguments {
    mixed  column; // json: "column"
    int    line;   // json: "line"
    Source source; // json: "source"

    string encode_json() {
        mapping(string:mixed) json = ([
            "column" : column,
            "line" : line,
            "source" : source,
        ]);

        return Standards.JSON.encode(json);
    }
}

GotoTargetsRequestArguments GotoTargetsRequestArguments_from_JSON(mixed json) {
    GotoTargetsRequestArguments retval = GotoTargetsRequestArguments();

    retval.column = json["column"];
    retval.line = json["line"];
    retval.source = json["source"];

    return retval;
}

constant GOTO_TARGETS = "gotoTargets"; // json: "gotoTargets"

// Arguments for 'gotoTargets' request.
class GotoTargetsArguments {
    mixed  column; // json: "column"
    int    line;   // json: "line"
    Source source; // json: "source"

    string encode_json() {
        mapping(string:mixed) json = ([
            "column" : column,
            "line" : line,
            "source" : source,
        ]);

        return Standards.JSON.encode(json);
    }
}

GotoTargetsArguments GotoTargetsArguments_from_JSON(mixed json) {
    GotoTargetsArguments retval = GotoTargetsArguments();

    retval.column = json["column"];
    retval.line = json["line"];
    retval.source = json["source"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'gotoTargets' request.
class GotoTargetsResponse {
    int                     seq;         // json: "seq"
    mixed                   type;        // json: "type"
    GotoTargetsResponseBody body;        // json: "body"
    string                  command;     // json: "command"
    mixed                   message;     // json: "message"
    int                     request_seq; // json: "request_seq"
    bool                    success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

GotoTargetsResponse GotoTargetsResponse_from_JSON(mixed json) {
    GotoTargetsResponse retval = GotoTargetsResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class GotoTargetsResponseBody {
    array(GotoTarget) targets; // json: "targets"

    string encode_json() {
        mapping(string:mixed) json = ([
            "targets" : targets,
        ]);

        return Standards.JSON.encode(json);
    }
}

GotoTargetsResponseBody GotoTargetsResponseBody_from_JSON(mixed json) {
    GotoTargetsResponseBody retval = GotoTargetsResponseBody();

    retval.targets = json["targets"];

    return retval;
}

// A GotoTarget describes a code location that can be used as a target in the 'goto'
// request.
// The possible goto targets can be determined via the 'gotoTargets' request.
class GotoTarget {
    mixed  column;     // json: "column"
    mixed  end_column; // json: "endColumn"
    mixed  end_line;   // json: "endLine"
    int    id;         // json: "id"
    string label;      // json: "label"
    int    line;       // json: "line"

    string encode_json() {
        mapping(string:mixed) json = ([
            "column" : column,
            "endColumn" : end_column,
            "endLine" : end_line,
            "id" : id,
            "label" : label,
            "line" : line,
        ]);

        return Standards.JSON.encode(json);
    }
}

GotoTarget GotoTarget_from_JSON(mixed json) {
    GotoTarget retval = GotoTarget();

    retval.column = json["column"];
    retval.end_column = json["endColumn"];
    retval.end_line = json["endLine"];
    retval.id = json["id"];
    retval.label = json["label"];
    retval.line = json["line"];

    return retval;
}

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// Returns a list of possible completions for a given caret position and text.
// The CompletionsRequest may only be called if the 'supportsCompletionsRequest' capability
// exists and is true.
class CompletionsRequest {
    int                         seq;       // json: "seq"
    mixed                       type;      // json: "type"
    CompletionsRequestArguments arguments; // json: "arguments"
    mixed                       command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

CompletionsRequest CompletionsRequest_from_JSON(mixed json) {
    CompletionsRequest retval = CompletionsRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'completions' request.
class CompletionsRequestArguments {
    int    column;   // json: "column"
    mixed  frame_id; // json: "frameId"
    mixed  line;     // json: "line"
    string text;     // json: "text"

    string encode_json() {
        mapping(string:mixed) json = ([
            "column" : column,
            "frameId" : frame_id,
            "line" : line,
            "text" : text,
        ]);

        return Standards.JSON.encode(json);
    }
}

CompletionsRequestArguments CompletionsRequestArguments_from_JSON(mixed json) {
    CompletionsRequestArguments retval = CompletionsRequestArguments();

    retval.column = json["column"];
    retval.frame_id = json["frameId"];
    retval.line = json["line"];
    retval.text = json["text"];

    return retval;
}

constant COMPLETIONS = "completions"; // json: "completions"

// Arguments for 'completions' request.
class CompletionsArguments {
    int    column;   // json: "column"
    mixed  frame_id; // json: "frameId"
    mixed  line;     // json: "line"
    string text;     // json: "text"

    string encode_json() {
        mapping(string:mixed) json = ([
            "column" : column,
            "frameId" : frame_id,
            "line" : line,
            "text" : text,
        ]);

        return Standards.JSON.encode(json);
    }
}

CompletionsArguments CompletionsArguments_from_JSON(mixed json) {
    CompletionsArguments retval = CompletionsArguments();

    retval.column = json["column"];
    retval.frame_id = json["frameId"];
    retval.line = json["line"];
    retval.text = json["text"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'completions' request.
class CompletionsResponse {
    int                     seq;         // json: "seq"
    mixed                   type;        // json: "type"
    CompletionsResponseBody body;        // json: "body"
    string                  command;     // json: "command"
    mixed                   message;     // json: "message"
    int                     request_seq; // json: "request_seq"
    bool                    success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

CompletionsResponse CompletionsResponse_from_JSON(mixed json) {
    CompletionsResponse retval = CompletionsResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class CompletionsResponseBody {
    array(CompletionItem) targets; // json: "targets"

    string encode_json() {
        mapping(string:mixed) json = ([
            "targets" : targets,
        ]);

        return Standards.JSON.encode(json);
    }
}

CompletionsResponseBody CompletionsResponseBody_from_JSON(mixed json) {
    CompletionsResponseBody retval = CompletionsResponseBody();

    retval.targets = json["targets"];

    return retval;
}

// CompletionItems are the suggestions returned from the CompletionsRequest.
class CompletionItem {
    string label;  // json: "label"
    mixed  length; // json: "length"
    mixed  start;  // json: "start"
    mixed  text;   // json: "text"
    mixed  type;   // json: "type"

    string encode_json() {
        mapping(string:mixed) json = ([
            "label" : label,
            "length" : length,
            "start" : start,
            "text" : text,
            "type" : type,
        ]);

        return Standards.JSON.encode(json);
    }
}

CompletionItem CompletionItem_from_JSON(mixed json) {
    CompletionItem retval = CompletionItem();

    retval.label = json["label"];
    retval.length = json["length"];
    retval.start = json["start"];
    retval.text = json["text"];
    retval.type = json["type"];

    return retval;
}

constant CLASS = "class";                        // json: "class"
constant COLOR = "color";                        // json: "color"
constant COMPLETION_ITEM_TYPE_MODULE = "module"; // json: "module"
constant CONSTRUCTOR = "constructor";            // json: "constructor"
constant CUSTOMCOLOR = "customcolor";            // json: "customcolor"
constant ENUM = "enum";                          // json: "enum"
constant FIELD = "field";                        // json: "field"
constant FILE = "file";                          // json: "file"
constant FUNCTION = "function";                  // json: "function"
constant INTERFACE = "interface";                // json: "interface"
constant KEYWORD = "keyword";                    // json: "keyword"
constant METHOD = "method";                      // json: "method"
constant PROPERTY = "property";                  // json: "property"
constant REFERENCE = "reference";                // json: "reference"
constant SNIPPET = "snippet";                    // json: "snippet"
constant TEXT = "text";                          // json: "text"
constant UNIT = "unit";                          // json: "unit"
constant VALUE = "value";                        // json: "value"
constant VARIABLE = "variable";                  // json: "variable"

// Base class of requests, responses, and events.
//
// A client or debug adapter initiated request.
//
// Retrieves the details of the exception that caused this event to be raised.
class ExceptionInfoRequest {
    int                           seq;       // json: "seq"
    mixed                         type;      // json: "type"
    ExceptionInfoRequestArguments arguments; // json: "arguments"
    mixed                         command;   // json: "command"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "arguments" : arguments,
            "command" : command,
        ]);

        return Standards.JSON.encode(json);
    }
}

ExceptionInfoRequest ExceptionInfoRequest_from_JSON(mixed json) {
    ExceptionInfoRequest retval = ExceptionInfoRequest();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.arguments = json["arguments"];
    retval.command = json["command"];

    return retval;
}

// Arguments for 'exceptionInfo' request.
class ExceptionInfoRequestArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

ExceptionInfoRequestArguments ExceptionInfoRequestArguments_from_JSON(mixed json) {
    ExceptionInfoRequestArguments retval = ExceptionInfoRequestArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

constant EXCEPTION_INFO = "exceptionInfo"; // json: "exceptionInfo"

// Arguments for 'exceptionInfo' request.
class ExceptionInfoArguments {
    int thread_id; // json: "threadId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "threadId" : thread_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

ExceptionInfoArguments ExceptionInfoArguments_from_JSON(mixed json) {
    ExceptionInfoArguments retval = ExceptionInfoArguments();

    retval.thread_id = json["threadId"];

    return retval;
}

// Base class of requests, responses, and events.
//
// Response for a request.
//
// Response to 'exceptionInfo' request.
class ExceptionInfoResponse {
    int                       seq;         // json: "seq"
    mixed                     type;        // json: "type"
    ExceptionInfoResponseBody body;        // json: "body"
    string                    command;     // json: "command"
    mixed                     message;     // json: "message"
    int                       request_seq; // json: "request_seq"
    bool                      success;     // json: "success"

    string encode_json() {
        mapping(string:mixed) json = ([
            "seq" : seq,
            "type" : type,
            "body" : body,
            "command" : command,
            "message" : message,
            "request_seq" : request_seq,
            "success" : success,
        ]);

        return Standards.JSON.encode(json);
    }
}

ExceptionInfoResponse ExceptionInfoResponse_from_JSON(mixed json) {
    ExceptionInfoResponse retval = ExceptionInfoResponse();

    retval.seq = json["seq"];
    retval.type = json["type"];
    retval.body = json["body"];
    retval.command = json["command"];
    retval.message = json["message"];
    retval.request_seq = json["request_seq"];
    retval.success = json["success"];

    return retval;
}

class ExceptionInfoResponseBody {
    mixed  break_mode;   // json: "breakMode"
    mixed  description;  // json: "description"
    mixed  details;      // json: "details"
    string exception_id; // json: "exceptionId"

    string encode_json() {
        mapping(string:mixed) json = ([
            "breakMode" : break_mode,
            "description" : description,
            "details" : details,
            "exceptionId" : exception_id,
        ]);

        return Standards.JSON.encode(json);
    }
}

ExceptionInfoResponseBody ExceptionInfoResponseBody_from_JSON(mixed json) {
    ExceptionInfoResponseBody retval = ExceptionInfoResponseBody();

    retval.break_mode = json["breakMode"];
    retval.description = json["description"];
    retval.details = json["details"];
    retval.exception_id = json["exceptionId"];

    return retval;
}

// Detailed information about the exception.
//
// Detailed information about an exception that has occurred.
class ExceptionDetails {
    mixed evaluate_name;   // json: "evaluateName"
    mixed full_type_name;  // json: "fullTypeName"
    mixed inner_exception; // json: "innerException"
    mixed message;         // json: "message"
    mixed stack_trace;     // json: "stackTrace"
    mixed type_name;       // json: "typeName"

    string encode_json() {
        mapping(string:mixed) json = ([
            "evaluateName" : evaluate_name,
            "fullTypeName" : full_type_name,
            "innerException" : inner_exception,
            "message" : message,
            "stackTrace" : stack_trace,
            "typeName" : type_name,
        ]);

        return Standards.JSON.encode(json);
    }
}

ExceptionDetails ExceptionDetails_from_JSON(mixed json) {
    ExceptionDetails retval = ExceptionDetails();

    retval.evaluate_name = json["evaluateName"];
    retval.full_type_name = json["fullTypeName"];
    retval.inner_exception = json["innerException"];
    retval.message = json["message"];
    retval.stack_trace = json["stackTrace"];
    retval.type_name = json["typeName"];

    return retval;
}

// The ModulesViewDescriptor is the container for all declarative configuration options of a
// ModuleView.
// For now it only specifies the columns to be shown in the modules view.
class ModulesViewDescriptor {
    array(ColumnDescriptor) columns; // json: "columns"

    string encode_json() {
        mapping(string:mixed) json = ([
            "columns" : columns,
        ]);

        return Standards.JSON.encode(json);
    }
}

ModulesViewDescriptor ModulesViewDescriptor_from_JSON(mixed json) {
    ModulesViewDescriptor retval = ModulesViewDescriptor();

    retval.columns = json["columns"];

    return retval;
}