gistfile1.txt

// To parse this data:
//
//   import { Convert, ProtocolMessage, Request, Event, Response, ErrorResponse, InitializedEvent, StoppedEvent, ContinuedEvent, ExitedEvent, TerminatedEvent, ThreadEvent, OutputEvent, BreakpointEvent, ModuleEvent, LoadedSourceEvent, ProcessEvent, CapabilitiesEvent, RunInTerminalRequest, RunInTerminalRequestArguments, RunInTerminalResponse, InitializeRequest, InitializeRequestArguments, InitializeResponse, ConfigurationDoneRequest, ConfigurationDoneResponse, LaunchRequest, LaunchRequestArguments, LaunchResponse, AttachRequest, AttachRequestArguments, AttachResponse, RestartRequest, RestartResponse, DisconnectRequest, DisconnectArguments, DisconnectResponse, TerminateRequest, TerminateArguments, TerminateResponse, SetBreakpointsRequest, SetBreakpointsArguments, SetBreakpointsResponse, SetFunctionBreakpointsRequest, SetFunctionBreakpointsArguments, SetFunctionBreakpointsResponse, SetExceptionBreakpointsRequest, SetExceptionBreakpointsArguments, SetExceptionBreakpointsResponse, ContinueRequest, ContinueArguments, ContinueResponse, NextRequest, NextArguments, NextResponse, StepInRequest, StepInArguments, StepInResponse, StepOutRequest, StepOutArguments, StepOutResponse, StepBackRequest, StepBackArguments, StepBackResponse, ReverseContinueRequest, ReverseContinueArguments, ReverseContinueResponse, RestartFrameRequest, RestartFrameArguments, RestartFrameResponse, GotoRequest, GotoArguments, GotoResponse, PauseRequest, PauseArguments, PauseResponse, StackTraceRequest, StackTraceArguments, StackTraceResponse, ScopesRequest, ScopesArguments, ScopesResponse, VariablesRequest, VariablesArguments, VariablesResponse, SetVariableRequest, SetVariableArguments, SetVariableResponse, SourceRequest, SourceArguments, SourceResponse, ThreadsRequest, ThreadsResponse, TerminateThreadsRequest, TerminateThreadsArguments, TerminateThreadsResponse, ModulesRequest, ModulesArguments, ModulesResponse, LoadedSourcesRequest, LoadedSourcesResponse, EvaluateRequest, EvaluateArguments, EvaluateResponse, SetExpressionRequest, SetExpressionArguments, SetExpressionResponse, StepInTargetsRequest, StepInTargetsArguments, StepInTargetsResponse, GotoTargetsRequest, GotoTargetsArguments, GotoTargetsResponse, CompletionsRequest, CompletionsArguments, CompletionsResponse, ExceptionInfoRequest, ExceptionInfoArguments, ExceptionInfoResponse, Capabilities, ExceptionBreakpointsFilter, Message, Module, ColumnDescriptor, ModulesViewDescriptor, Thread, Source, StackFrame, Scope, Variable, VariablePresentationHint, SourceBreakpoint, FunctionBreakpoint, Breakpoint, StepInTarget, GotoTarget, CompletionItem, CompletionItemType, ChecksumAlgorithm, Checksum, ValueFormat, StackFrameFormat, ExceptionOptions, ExceptionBreakMode, ExceptionPathSegment, ExceptionDetails } from "./file";
//
//   const protocolMessage = Convert.toProtocolMessage(json);
//   const request = Convert.toRequest(json);
//   const event = Convert.toEvent(json);
//   const response = Convert.toResponse(json);
//   const errorResponse = Convert.toErrorResponse(json);
//   const initializedEvent = Convert.toInitializedEvent(json);
//   const stoppedEvent = Convert.toStoppedEvent(json);
//   const continuedEvent = Convert.toContinuedEvent(json);
//   const exitedEvent = Convert.toExitedEvent(json);
//   const terminatedEvent = Convert.toTerminatedEvent(json);
//   const threadEvent = Convert.toThreadEvent(json);
//   const outputEvent = Convert.toOutputEvent(json);
//   const breakpointEvent = Convert.toBreakpointEvent(json);
//   const moduleEvent = Convert.toModuleEvent(json);
//   const loadedSourceEvent = Convert.toLoadedSourceEvent(json);
//   const processEvent = Convert.toProcessEvent(json);
//   const capabilitiesEvent = Convert.toCapabilitiesEvent(json);
//   const runInTerminalRequest = Convert.toRunInTerminalRequest(json);
//   const runInTerminalRequestArguments = Convert.toRunInTerminalRequestArguments(json);
//   const runInTerminalResponse = Convert.toRunInTerminalResponse(json);
//   const initializeRequest = Convert.toInitializeRequest(json);
//   const initializeRequestArguments = Convert.toInitializeRequestArguments(json);
//   const initializeResponse = Convert.toInitializeResponse(json);
//   const configurationDoneRequest = Convert.toConfigurationDoneRequest(json);
//   const configurationDoneArguments = Convert.toConfigurationDoneArguments(json);
//   const configurationDoneResponse = Convert.toConfigurationDoneResponse(json);
//   const launchRequest = Convert.toLaunchRequest(json);
//   const launchRequestArguments = Convert.toLaunchRequestArguments(json);
//   const launchResponse = Convert.toLaunchResponse(json);
//   const attachRequest = Convert.toAttachRequest(json);
//   const attachRequestArguments = Convert.toAttachRequestArguments(json);
//   const attachResponse = Convert.toAttachResponse(json);
//   const restartRequest = Convert.toRestartRequest(json);
//   const restartArguments = Convert.toRestartArguments(json);
//   const restartResponse = Convert.toRestartResponse(json);
//   const disconnectRequest = Convert.toDisconnectRequest(json);
//   const disconnectArguments = Convert.toDisconnectArguments(json);
//   const disconnectResponse = Convert.toDisconnectResponse(json);
//   const terminateRequest = Convert.toTerminateRequest(json);
//   const terminateArguments = Convert.toTerminateArguments(json);
//   const terminateResponse = Convert.toTerminateResponse(json);
//   const setBreakpointsRequest = Convert.toSetBreakpointsRequest(json);
//   const setBreakpointsArguments = Convert.toSetBreakpointsArguments(json);
//   const setBreakpointsResponse = Convert.toSetBreakpointsResponse(json);
//   const setFunctionBreakpointsRequest = Convert.toSetFunctionBreakpointsRequest(json);
//   const setFunctionBreakpointsArguments = Convert.toSetFunctionBreakpointsArguments(json);
//   const setFunctionBreakpointsResponse = Convert.toSetFunctionBreakpointsResponse(json);
//   const setExceptionBreakpointsRequest = Convert.toSetExceptionBreakpointsRequest(json);
//   const setExceptionBreakpointsArguments = Convert.toSetExceptionBreakpointsArguments(json);
//   const setExceptionBreakpointsResponse = Convert.toSetExceptionBreakpointsResponse(json);
//   const continueRequest = Convert.toContinueRequest(json);
//   const continueArguments = Convert.toContinueArguments(json);
//   const continueResponse = Convert.toContinueResponse(json);
//   const nextRequest = Convert.toNextRequest(json);
//   const nextArguments = Convert.toNextArguments(json);
//   const nextResponse = Convert.toNextResponse(json);
//   const stepInRequest = Convert.toStepInRequest(json);
//   const stepInArguments = Convert.toStepInArguments(json);
//   const stepInResponse = Convert.toStepInResponse(json);
//   const stepOutRequest = Convert.toStepOutRequest(json);
//   const stepOutArguments = Convert.toStepOutArguments(json);
//   const stepOutResponse = Convert.toStepOutResponse(json);
//   const stepBackRequest = Convert.toStepBackRequest(json);
//   const stepBackArguments = Convert.toStepBackArguments(json);
//   const stepBackResponse = Convert.toStepBackResponse(json);
//   const reverseContinueRequest = Convert.toReverseContinueRequest(json);
//   const reverseContinueArguments = Convert.toReverseContinueArguments(json);
//   const reverseContinueResponse = Convert.toReverseContinueResponse(json);
//   const restartFrameRequest = Convert.toRestartFrameRequest(json);
//   const restartFrameArguments = Convert.toRestartFrameArguments(json);
//   const restartFrameResponse = Convert.toRestartFrameResponse(json);
//   const gotoRequest = Convert.toGotoRequest(json);
//   const gotoArguments = Convert.toGotoArguments(json);
//   const gotoResponse = Convert.toGotoResponse(json);
//   const pauseRequest = Convert.toPauseRequest(json);
//   const pauseArguments = Convert.toPauseArguments(json);
//   const pauseResponse = Convert.toPauseResponse(json);
//   const stackTraceRequest = Convert.toStackTraceRequest(json);
//   const stackTraceArguments = Convert.toStackTraceArguments(json);
//   const stackTraceResponse = Convert.toStackTraceResponse(json);
//   const scopesRequest = Convert.toScopesRequest(json);
//   const scopesArguments = Convert.toScopesArguments(json);
//   const scopesResponse = Convert.toScopesResponse(json);
//   const variablesRequest = Convert.toVariablesRequest(json);
//   const variablesArguments = Convert.toVariablesArguments(json);
//   const variablesResponse = Convert.toVariablesResponse(json);
//   const setVariableRequest = Convert.toSetVariableRequest(json);
//   const setVariableArguments = Convert.toSetVariableArguments(json);
//   const setVariableResponse = Convert.toSetVariableResponse(json);
//   const sourceRequest = Convert.toSourceRequest(json);
//   const sourceArguments = Convert.toSourceArguments(json);
//   const sourceResponse = Convert.toSourceResponse(json);
//   const threadsRequest = Convert.toThreadsRequest(json);
//   const threadsResponse = Convert.toThreadsResponse(json);
//   const terminateThreadsRequest = Convert.toTerminateThreadsRequest(json);
//   const terminateThreadsArguments = Convert.toTerminateThreadsArguments(json);
//   const terminateThreadsResponse = Convert.toTerminateThreadsResponse(json);
//   const modulesRequest = Convert.toModulesRequest(json);
//   const modulesArguments = Convert.toModulesArguments(json);
//   const modulesResponse = Convert.toModulesResponse(json);
//   const loadedSourcesRequest = Convert.toLoadedSourcesRequest(json);
//   const loadedSourcesArguments = Convert.toLoadedSourcesArguments(json);
//   const loadedSourcesResponse = Convert.toLoadedSourcesResponse(json);
//   const evaluateRequest = Convert.toEvaluateRequest(json);
//   const evaluateArguments = Convert.toEvaluateArguments(json);
//   const evaluateResponse = Convert.toEvaluateResponse(json);
//   const setExpressionRequest = Convert.toSetExpressionRequest(json);
//   const setExpressionArguments = Convert.toSetExpressionArguments(json);
//   const setExpressionResponse = Convert.toSetExpressionResponse(json);
//   const stepInTargetsRequest = Convert.toStepInTargetsRequest(json);
//   const stepInTargetsArguments = Convert.toStepInTargetsArguments(json);
//   const stepInTargetsResponse = Convert.toStepInTargetsResponse(json);
//   const gotoTargetsRequest = Convert.toGotoTargetsRequest(json);
//   const gotoTargetsArguments = Convert.toGotoTargetsArguments(json);
//   const gotoTargetsResponse = Convert.toGotoTargetsResponse(json);
//   const completionsRequest = Convert.toCompletionsRequest(json);
//   const completionsArguments = Convert.toCompletionsArguments(json);
//   const completionsResponse = Convert.toCompletionsResponse(json);
//   const exceptionInfoRequest = Convert.toExceptionInfoRequest(json);
//   const exceptionInfoArguments = Convert.toExceptionInfoArguments(json);
//   const exceptionInfoResponse = Convert.toExceptionInfoResponse(json);
//   const capabilities = Convert.toCapabilities(json);
//   const exceptionBreakpointsFilter = Convert.toExceptionBreakpointsFilter(json);
//   const message = Convert.toMessage(json);
//   const module = Convert.toModule(json);
//   const columnDescriptor = Convert.toColumnDescriptor(json);
//   const modulesViewDescriptor = Convert.toModulesViewDescriptor(json);
//   const thread = Convert.toThread(json);
//   const source = Convert.toSource(json);
//   const stackFrame = Convert.toStackFrame(json);
//   const scope = Convert.toScope(json);
//   const variable = Convert.toVariable(json);
//   const variablePresentationHint = Convert.toVariablePresentationHint(json);
//   const sourceBreakpoint = Convert.toSourceBreakpoint(json);
//   const functionBreakpoint = Convert.toFunctionBreakpoint(json);
//   const breakpoint = Convert.toBreakpoint(json);
//   const stepInTarget = Convert.toStepInTarget(json);
//   const gotoTarget = Convert.toGotoTarget(json);
//   const completionItem = Convert.toCompletionItem(json);
//   const completionItemType = Convert.toCompletionItemType(json);
//   const checksumAlgorithm = Convert.toChecksumAlgorithm(json);
//   const checksum = Convert.toChecksum(json);
//   const valueFormat = Convert.toValueFormat(json);
//   const stackFrameFormat = Convert.toStackFrameFormat(json);
//   const exceptionOptions = Convert.toExceptionOptions(json);
//   const exceptionBreakMode = Convert.toExceptionBreakMode(json);
//   const exceptionPathSegment = Convert.toExceptionPathSegment(json);
//   const exceptionDetails = Convert.toExceptionDetails(json);
//
// These functions will throw an error if the JSON doesn't
// match the expected interface, even if the JSON is valid.

/**
 * Base class of requests, responses, and events.
 */
export interface ProtocolMessage {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: string;
}

/**
 * Base class of requests, responses, and events.
 *
 * A client or debug adapter initiated request.
 */
export interface Request {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command to execute.
     */
    command: string;
}

/**
 * Values must be strings.
 */
export enum PurpleArakGroundhog {
    Request = "request",
}

/**
 * Base class of requests, responses, and events.
 *
 * A debug adapter initiated event.
 */
export interface Event {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: FluffyArakGroundhog;
    /**
     * Event-specific information.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * Type of event.
     */
    event: string;
}

/**
 * Values must be strings.
 */
export enum FluffyArakGroundhog {
    Event = "event",
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 */
export interface Response {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * Values must be strings.
 */
export enum TentacledArakGroundhog {
    Response = "response",
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * On error (whenever 'success' is false), the body can provide more details.
 */
export interface ErrorResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: ErrorResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface ErrorResponseBody {
    /**
     * An optional, structured error message.
     */
    error?: Message;
}

/**
 * An optional, structured error message.
 *
 * A structured message object. Used to return errors from requests.
 */
export interface Message {
    /**
     * A format string for the message. Embedded variables have the form '{name}'.
     * If variable name starts with an underscore character, the variable does not contain user
     * data (PII) and can be safely used for telemetry purposes.
     */
    format: string;
    /**
     * Unique identifier for the message.
     */
    id: number;
    /**
     * If true send to telemetry.
     */
    sendTelemetry?: boolean;
    /**
     * If true show user.
     */
    showUser?: boolean;
    /**
     * An optional url where additional information about this message can be found.
     */
    url?: string;
    /**
     * An optional label that is presented to the user as the UI for opening the url.
     */
    urlLabel?: string;
    /**
     * An object used as a dictionary for looking up the variables in the format string.
     */
    variables?: { [key: string]: string };
}

/**
 * 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.
 */
export interface InitializedEvent {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: FluffyArakGroundhog;
    /**
     * Event-specific information.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * Type of event.
     */
    event: StickyArakGroundhog;
}

/**
 * Values must be strings.
 */
export enum StickyArakGroundhog {
    Initialized = "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.
 */
export interface StoppedEvent {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: FluffyArakGroundhog;
    /**
     * Event-specific information.
     */
    body: StoppedEventBody;
    /**
     * Type of event.
     */
    event: IndigoArakGroundhog;
}

export interface StoppedEventBody {
    /**
     * If 'allThreadsStopped' is true, a debug adapter can announce that all threads have
     * stopped.
     * - The client should use this information to enable that all threads can be expanded to
     * access their stacktraces.
     * - If the attribute is missing or false, only the thread with the given threadId can be
     * expanded.
     */
    allThreadsStopped?: boolean;
    /**
     * The full reason for the event, e.g. 'Paused on exception'. This string is shown in the UI
     * as is and must be translated.
     */
    description?: string;
    /**
     * A value of true hints to the frontend that this event should not change the focus.
     */
    preserveFocusHint?: boolean;
    /**
     * The reason for the event.
     * For backward compatibility this string is shown in the UI if the 'description' attribute
     * is missing (but it must not be translated).
     */
    reason: string;
    /**
     * Additional information. E.g. if reason is 'exception', text contains the exception name.
     * This string is shown in the UI.
     */
    text?: string;
    /**
     * The thread which was stopped.
     */
    threadId?: number;
}

/**
 * Values must be strings.
 */
export enum IndigoArakGroundhog {
    Stopped = "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.
 */
export interface ContinuedEvent {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: FluffyArakGroundhog;
    /**
     * Event-specific information.
     */
    body: ContinuedEventBody;
    /**
     * Type of event.
     */
    event: IndecentArakGroundhog;
}

export interface ContinuedEventBody {
    /**
     * If 'allThreadsContinued' is true, a debug adapter can announce that all threads have
     * continued.
     */
    allThreadsContinued?: boolean;
    /**
     * The thread which was continued.
     */
    threadId: number;
}

/**
 * Values must be strings.
 */
export enum IndecentArakGroundhog {
    Continued = "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.
 */
export interface ExitedEvent {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: FluffyArakGroundhog;
    /**
     * Event-specific information.
     */
    body: ExitedEventBody;
    /**
     * Type of event.
     */
    event: HilariousArakGroundhog;
}

export interface ExitedEventBody {
    /**
     * The exit code returned from the debuggee.
     */
    exitCode: number;
}

/**
 * Values must be strings.
 */
export enum HilariousArakGroundhog {
    Exited = "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.
 */
export interface TerminatedEvent {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: FluffyArakGroundhog;
    /**
     * Event-specific information.
     */
    body?: TerminatedEventBody;
    /**
     * Type of event.
     */
    event: AmbitiousArakGroundhog;
}

export interface TerminatedEventBody {
    /**
     * 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.
     */
    restart?: any[] | boolean | number | number | { [key: string]: any } | null | string;
}

/**
 * Values must be strings.
 */
export enum AmbitiousArakGroundhog {
    Terminated = "terminated",
}

/**
 * Base class of requests, responses, and events.
 *
 * A debug adapter initiated event.
 *
 * The event indicates that a thread has started or exited.
 */
export interface ThreadEvent {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: FluffyArakGroundhog;
    /**
     * Event-specific information.
     */
    body: ThreadEventBody;
    /**
     * Type of event.
     */
    event: CunningArakGroundhog;
}

export interface ThreadEventBody {
    /**
     * The reason for the event.
     */
    reason: string;
    /**
     * The identifier of the thread.
     */
    threadId: number;
}

/**
 * Values must be strings.
 */
export enum CunningArakGroundhog {
    Thread = "thread",
}

/**
 * Base class of requests, responses, and events.
 *
 * A debug adapter initiated event.
 *
 * The event indicates that the target has produced some output.
 */
export interface OutputEvent {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: FluffyArakGroundhog;
    /**
     * Event-specific information.
     */
    body: OutputEventBody;
    /**
     * Type of event.
     */
    event: MagentaArakGroundhog;
}

export interface OutputEventBody {
    /**
     * The output category. If not specified, 'console' is assumed.
     */
    category?: string;
    /**
     * An optional source location column where the output was produced.
     */
    column?: number;
    /**
     * 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.
     */
    data?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * An optional source location line where the output was produced.
     */
    line?: number;
    /**
     * The output to report.
     */
    output: string;
    /**
     * An optional source location where the output was produced.
     */
    source?: Source;
    /**
     * If an attribute 'variablesReference' exists and its value is > 0, the output contains
     * objects which can be retrieved by passing 'variablesReference' to the 'variables' request.
     */
    variablesReference?: number;
}

/**
 * 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.
 */
export interface Source {
    /**
     * 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.
     */
    adapterData?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The checksums associated with this file.
     */
    checksums?: Checksum[];
    /**
     * The short name of the source. Every source returned from the debug adapter has a name.
     * When sending a source to the debug adapter this name is optional.
     */
    name?: string;
    /**
     * The (optional) origin of this source: possible values 'internal module', 'inlined content
     * from source map', etc.
     */
    origin?: string;
    /**
     * The path of the source to be shown in the UI. It is only used to locate and load the
     * content of the source if no sourceReference is specified (or its value is 0).
     */
    path?: string;
    /**
     * An optional hint for how to present the source in the UI. A value of 'deemphasize' can be
     * used to indicate that the source is not available or that it is skipped on stepping.
     */
    presentationHint?: SourcePresentationHint;
    /**
     * If sourceReference > 0 the contents of the source must be retrieved through the
     * SourceRequest (even if a path is specified). A sourceReference is only valid for a
     * session, so it must not be used to persist a source.
     */
    sourceReference?: number;
    /**
     * An optional list of sources that are related to this source. These may be the source that
     * generated this source.
     */
    sources?: Source[];
}

/**
 * The checksum of an item calculated by the specified algorithm.
 */
export interface Checksum {
    /**
     * The algorithm used to calculate this checksum.
     */
    algorithm: ChecksumAlgorithm;
    /**
     * Value of the checksum.
     */
    checksum: string;
}

/**
 * The algorithm used to calculate this checksum.
 *
 * Names of checksum algorithms that may be supported by a debug adapter.
 */
export enum ChecksumAlgorithm {
    Md5 = "MD5",
    Sha1 = "SHA1",
    Sha256 = "SHA256",
    Timestamp = "timestamp",
}

/**
 * An optional hint for how to present the source in the UI. A value of 'deemphasize' can be
 * used to indicate that the source is not available or that it is skipped on stepping.
 */
export enum SourcePresentationHint {
    Deemphasize = "deemphasize",
    Emphasize = "emphasize",
    Normal = "normal",
}

/**
 * Values must be strings.
 */
export enum MagentaArakGroundhog {
    Output = "output",
}

/**
 * Base class of requests, responses, and events.
 *
 * A debug adapter initiated event.
 *
 * The event indicates that some information about a breakpoint has changed.
 */
export interface BreakpointEvent {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: FluffyArakGroundhog;
    /**
     * Event-specific information.
     */
    body: BreakpointEventBody;
    /**
     * Type of event.
     */
    event: FriskyArakGroundhog;
}

export interface BreakpointEventBody {
    /**
     * The 'id' attribute is used to find the target breakpoint and the other attributes are
     * used as the new values.
     */
    breakpoint: Breakpoint;
    /**
     * The reason for the event.
     */
    reason: string;
}

/**
 * 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.
 */
export interface Breakpoint {
    /**
     * An optional start column of the actual range covered by the breakpoint.
     */
    column?: number;
    /**
     * An optional end column of the actual range covered by the breakpoint. If no end line is
     * given, then the end column is assumed to be in the start line.
     */
    endColumn?: number;
    /**
     * An optional end line of the actual range covered by the breakpoint.
     */
    endLine?: number;
    /**
     * An optional identifier for the breakpoint. It is needed if breakpoint events are used to
     * update or remove breakpoints.
     */
    id?: number;
    /**
     * The start line of the actual range covered by the breakpoint.
     */
    line?: number;
    /**
     * An optional message about the state of the breakpoint. This is shown to the user and can
     * be used to explain why a breakpoint could not be verified.
     */
    message?: string;
    /**
     * The source where the breakpoint is located.
     */
    source?: Source;
    /**
     * If true breakpoint could be set (but not necessarily at the desired location).
     */
    verified: boolean;
}

/**
 * Values must be strings.
 */
export enum FriskyArakGroundhog {
    Breakpoint = "breakpoint",
}

/**
 * Base class of requests, responses, and events.
 *
 * A debug adapter initiated event.
 *
 * The event indicates that some information about a module has changed.
 */
export interface ModuleEvent {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: FluffyArakGroundhog;
    /**
     * Event-specific information.
     */
    body: ModuleEventBody;
    /**
     * Type of event.
     */
    event: MischievousArakGroundhog;
}

export interface ModuleEventBody {
    /**
     * The new, changed, or removed module. In case of 'removed' only the module id is used.
     */
    module: Module;
    /**
     * The reason for the event.
     */
    reason: Reason;
}

/**
 * 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.
 */
export interface Module {
    /**
     * Address range covered by this module.
     */
    addressRange?: string;
    /**
     * Module created or modified.
     */
    dateTimeStamp?: string;
    /**
     * Unique identifier for the module.
     */
    id: number | string;
    /**
     * True if the module is optimized.
     */
    isOptimized?: boolean;
    /**
     * True if the module is considered 'user code' by a debugger that supports 'Just My Code'.
     */
    isUserCode?: boolean;
    /**
     * A name of the module.
     */
    name: string;
    /**
     * optional but recommended attributes.
     * always try to use these first before introducing additional attributes.
     *
     * Logical full path to the module. The exact definition is implementation defined, but
     * usually this would be a full path to the on-disk file for the module.
     */
    path?: string;
    /**
     * Logical full path to the symbol file. The exact definition is implementation defined.
     */
    symbolFilePath?: string;
    /**
     * User understandable description of if symbols were found for the module (ex: 'Symbols
     * Loaded', 'Symbols not found', etc.
     */
    symbolStatus?: string;
    /**
     * Version of Module.
     */
    version?: string;
}

/**
 * The reason for the event.
 */
export enum Reason {
    Changed = "changed",
    New = "new",
    Removed = "removed",
}

/**
 * Values must be strings.
 */
export enum MischievousArakGroundhog {
    Module = "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.
 */
export interface LoadedSourceEvent {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: FluffyArakGroundhog;
    /**
     * Event-specific information.
     */
    body: LoadedSourceEventBody;
    /**
     * Type of event.
     */
    event: BraggadociousArakGroundhog;
}

export interface LoadedSourceEventBody {
    /**
     * The reason for the event.
     */
    reason: Reason;
    /**
     * The new, changed, or removed source.
     */
    source: Source;
}

/**
 * Values must be strings.
 */
export enum BraggadociousArakGroundhog {
    LoadedSource = "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.
 */
export interface ProcessEvent {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: FluffyArakGroundhog;
    /**
     * Event-specific information.
     */
    body: ProcessEventBody;
    /**
     * Type of event.
     */
    event: ArakGroundhog1;
}

export interface ProcessEventBody {
    /**
     * If true, the process is running on the same computer as the debug adapter.
     */
    isLocalProcess?: boolean;
    /**
     * The logical name of the process. This is usually the full path to process's executable
     * file. Example: /home/example/myproj/program.js.
     */
    name: string;
    /**
     * Describes how the debug engine started debugging this process.
     */
    startMethod?: StartMethod;
    /**
     * The system process id of the debugged process. This property will be missing for
     * non-system processes.
     */
    systemProcessId?: number;
}

/**
 * Describes how the debug engine started debugging this process.
 */
export enum StartMethod {
    Attach = "attach",
    AttachForSuspendedLaunch = "attachForSuspendedLaunch",
    Launch = "launch",
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog1 {
    Process = "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.
 */
export interface CapabilitiesEvent {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: FluffyArakGroundhog;
    /**
     * Event-specific information.
     */
    body: CapabilitiesEventBody;
    /**
     * Type of event.
     */
    event: ArakGroundhog2;
}

export interface CapabilitiesEventBody {
    /**
     * The set of updated capabilities.
     */
    capabilities: Capabilities;
}

/**
 * The set of updated capabilities.
 *
 * Information about the capabilities of a debug adapter.
 *
 * The capabilities of this debug adapter.
 */
export interface Capabilities {
    /**
     * The set of additional module information exposed by the debug adapter.
     */
    additionalModuleColumns?: ColumnDescriptor[];
    /**
     * Available filters or options for the setExceptionBreakpoints request.
     */
    exceptionBreakpointFilters?: ExceptionBreakpointsFilter[];
    /**
     * Checksum algorithms supported by the debug adapter.
     */
    supportedChecksumAlgorithms?: ChecksumAlgorithm[];
    /**
     * The debug adapter supports the 'completions' request.
     */
    supportsCompletionsRequest?: boolean;
    /**
     * The debug adapter supports conditional breakpoints.
     */
    supportsConditionalBreakpoints?: boolean;
    /**
     * The debug adapter supports the 'configurationDone' request.
     */
    supportsConfigurationDoneRequest?: boolean;
    /**
     * The debug adapter supports the delayed loading of parts of the stack, which requires that
     * both the 'startFrame' and 'levels' arguments and the 'totalFrames' result of the
     * 'StackTrace' request are supported.
     */
    supportsDelayedStackTraceLoading?: boolean;
    /**
     * The debug adapter supports a (side effect free) evaluate request for data hovers.
     */
    supportsEvaluateForHovers?: boolean;
    /**
     * The debug adapter supports the 'exceptionInfo' request.
     */
    supportsExceptionInfoRequest?: boolean;
    /**
     * The debug adapter supports 'exceptionOptions' on the setExceptionBreakpoints request.
     */
    supportsExceptionOptions?: boolean;
    /**
     * The debug adapter supports function breakpoints.
     */
    supportsFunctionBreakpoints?: boolean;
    /**
     * The debug adapter supports the 'gotoTargets' request.
     */
    supportsGotoTargetsRequest?: boolean;
    /**
     * The debug adapter supports breakpoints that break execution after a specified number of
     * hits.
     */
    supportsHitConditionalBreakpoints?: boolean;
    /**
     * The debug adapter supports the 'loadedSources' request.
     */
    supportsLoadedSourcesRequest?: boolean;
    /**
     * The debug adapter supports logpoints by interpreting the 'logMessage' attribute of the
     * SourceBreakpoint.
     */
    supportsLogPoints?: boolean;
    /**
     * The debug adapter supports the 'modules' request.
     */
    supportsModulesRequest?: boolean;
    /**
     * The debug adapter supports restarting a frame.
     */
    supportsRestartFrame?: boolean;
    /**
     * The debug adapter supports the 'restart' request. In this case a client should not
     * implement 'restart' by terminating and relaunching the adapter but by calling the
     * RestartRequest.
     */
    supportsRestartRequest?: boolean;
    /**
     * The debug adapter supports the 'setExpression' request.
     */
    supportsSetExpression?: boolean;
    /**
     * The debug adapter supports setting a variable to a value.
     */
    supportsSetVariable?: boolean;
    /**
     * The debug adapter supports stepping back via the 'stepBack' and 'reverseContinue'
     * requests.
     */
    supportsStepBack?: boolean;
    /**
     * The debug adapter supports the 'stepInTargets' request.
     */
    supportsStepInTargetsRequest?: boolean;
    /**
     * The debug adapter supports the 'terminate' request.
     */
    supportsTerminateRequest?: boolean;
    /**
     * The debug adapter supports the 'terminateThreads' request.
     */
    supportsTerminateThreadsRequest?: boolean;
    /**
     * The debug adapter supports a 'format' attribute on the stackTraceRequest,
     * variablesRequest, and evaluateRequest.
     */
    supportsValueFormattingOptions?: boolean;
    /**
     * The debug adapter supports the 'terminateDebuggee' attribute on the 'disconnect' request.
     */
    supportTerminateDebuggee?: boolean;
}

/**
 * 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.
 */
export interface ColumnDescriptor {
    /**
     * Name of the attribute rendered in this column.
     */
    attributeName: string;
    /**
     * Format to use for the rendered values in this column. TBD how the format strings looks
     * like.
     */
    format?: string;
    /**
     * Header UI label of column.
     */
    label: string;
    /**
     * Datatype of values in this column.  Defaults to 'string' if not specified.
     */
    type?: Type;
    /**
     * Width of this column in characters (hint only).
     */
    width?: number;
}

/**
 * Datatype of values in this column.  Defaults to 'string' if not specified.
 */
export enum Type {
    Boolean = "boolean",
    Number = "number",
    String = "string",
    UnixTimestampUTC = "unixTimestampUTC",
}

/**
 * An ExceptionBreakpointsFilter is shown in the UI as an option for configuring how
 * exceptions are dealt with.
 */
export interface ExceptionBreakpointsFilter {
    /**
     * Initial value of the filter. If not specified a value 'false' is assumed.
     */
    default?: boolean;
    /**
     * The internal ID of the filter. This value is passed to the setExceptionBreakpoints
     * request.
     */
    filter: string;
    /**
     * The name of the filter. This will be shown in the UI.
     */
    label: string;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog2 {
    Capabilities = "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.
 */
export interface RunInTerminalRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: ArgumentsObject;
    /**
     * The command to execute.
     */
    command: ArakGroundhog3;
}

/**
 * Arguments for 'runInTerminal' request.
 */
export interface ArgumentsObject {
    /**
     * List of arguments. The first argument is the command to run.
     */
    args: string[];
    /**
     * Working directory of the command.
     */
    cwd: string;
    /**
     * Environment key-value pairs that are added to or removed from the default environment.
     */
    env?: { [key: string]: null | string };
    /**
     * What kind of terminal to launch.
     */
    kind?: Kind;
    /**
     * Optional title of the terminal.
     */
    title?: string;
}

/**
 * What kind of terminal to launch.
 */
export enum Kind {
    External = "external",
    Integrated = "integrated",
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog3 {
    RunInTerminal = "runInTerminal",
}

/**
 * Arguments for 'runInTerminal' request.
 */
export interface RunInTerminalRequestArguments {
    /**
     * List of arguments. The first argument is the command to run.
     */
    args: string[];
    /**
     * Working directory of the command.
     */
    cwd: string;
    /**
     * Environment key-value pairs that are added to or removed from the default environment.
     */
    env?: { [key: string]: null | string };
    /**
     * What kind of terminal to launch.
     */
    kind?: Kind;
    /**
     * Optional title of the terminal.
     */
    title?: string;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'runInTerminal' request.
 */
export interface RunInTerminalResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: RunInTerminalResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface RunInTerminalResponseBody {
    /**
     * The process ID.
     */
    processId?: number;
    /**
     * The process ID of the terminal shell.
     */
    shellProcessId?: number;
}

/**
 * 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.
 */
export interface InitializeRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: RequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog4;
}

/**
 * Arguments for 'initialize' request.
 */
export interface RequestArguments {
    /**
     * The ID of the debug adapter.
     */
    adapterID: string;
    /**
     * The ID of the (frontend) client using this adapter.
     */
    clientID?: string;
    /**
     * The human readable name of the (frontend) client using this adapter.
     */
    clientName?: string;
    /**
     * If true all column numbers are 1-based (default).
     */
    columnsStartAt1?: boolean;
    /**
     * If true all line numbers are 1-based (default).
     */
    linesStartAt1?: boolean;
    /**
     * The ISO-639 locale of the (frontend) client using this adapter, e.g. en-US or de-CH.
     */
    locale?: string;
    /**
     * Determines in what format paths are specified. The default is 'path', which is the native
     * format.
     */
    pathFormat?: string;
    /**
     * Client supports the runInTerminal request.
     */
    supportsRunInTerminalRequest?: boolean;
    /**
     * Client supports the paging of variables.
     */
    supportsVariablePaging?: boolean;
    /**
     * Client supports the optional type attribute for variables.
     */
    supportsVariableType?: boolean;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog4 {
    Initialize = "initialize",
}

/**
 * Arguments for 'initialize' request.
 */
export interface InitializeRequestArguments {
    /**
     * The ID of the debug adapter.
     */
    adapterID: string;
    /**
     * The ID of the (frontend) client using this adapter.
     */
    clientID?: string;
    /**
     * The human readable name of the (frontend) client using this adapter.
     */
    clientName?: string;
    /**
     * If true all column numbers are 1-based (default).
     */
    columnsStartAt1?: boolean;
    /**
     * If true all line numbers are 1-based (default).
     */
    linesStartAt1?: boolean;
    /**
     * The ISO-639 locale of the (frontend) client using this adapter, e.g. en-US or de-CH.
     */
    locale?: string;
    /**
     * Determines in what format paths are specified. The default is 'path', which is the native
     * format.
     */
    pathFormat?: string;
    /**
     * Client supports the runInTerminal request.
     */
    supportsRunInTerminalRequest?: boolean;
    /**
     * Client supports the paging of variables.
     */
    supportsVariablePaging?: boolean;
    /**
     * Client supports the optional type attribute for variables.
     */
    supportsVariableType?: boolean;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'initialize' request.
 */
export interface InitializeResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is
     * false.
     *
     * The capabilities of this debug adapter.
     */
    body?: Types;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * The set of updated capabilities.
 *
 * Information about the capabilities of a debug adapter.
 *
 * The capabilities of this debug adapter.
 */
export interface Types {
    /**
     * The set of additional module information exposed by the debug adapter.
     */
    additionalModuleColumns?: ColumnDescriptor[];
    /**
     * Available filters or options for the setExceptionBreakpoints request.
     */
    exceptionBreakpointFilters?: ExceptionBreakpointsFilter[];
    /**
     * Checksum algorithms supported by the debug adapter.
     */
    supportedChecksumAlgorithms?: ChecksumAlgorithm[];
    /**
     * The debug adapter supports the 'completions' request.
     */
    supportsCompletionsRequest?: boolean;
    /**
     * The debug adapter supports conditional breakpoints.
     */
    supportsConditionalBreakpoints?: boolean;
    /**
     * The debug adapter supports the 'configurationDone' request.
     */
    supportsConfigurationDoneRequest?: boolean;
    /**
     * The debug adapter supports the delayed loading of parts of the stack, which requires that
     * both the 'startFrame' and 'levels' arguments and the 'totalFrames' result of the
     * 'StackTrace' request are supported.
     */
    supportsDelayedStackTraceLoading?: boolean;
    /**
     * The debug adapter supports a (side effect free) evaluate request for data hovers.
     */
    supportsEvaluateForHovers?: boolean;
    /**
     * The debug adapter supports the 'exceptionInfo' request.
     */
    supportsExceptionInfoRequest?: boolean;
    /**
     * The debug adapter supports 'exceptionOptions' on the setExceptionBreakpoints request.
     */
    supportsExceptionOptions?: boolean;
    /**
     * The debug adapter supports function breakpoints.
     */
    supportsFunctionBreakpoints?: boolean;
    /**
     * The debug adapter supports the 'gotoTargets' request.
     */
    supportsGotoTargetsRequest?: boolean;
    /**
     * The debug adapter supports breakpoints that break execution after a specified number of
     * hits.
     */
    supportsHitConditionalBreakpoints?: boolean;
    /**
     * The debug adapter supports the 'loadedSources' request.
     */
    supportsLoadedSourcesRequest?: boolean;
    /**
     * The debug adapter supports logpoints by interpreting the 'logMessage' attribute of the
     * SourceBreakpoint.
     */
    supportsLogPoints?: boolean;
    /**
     * The debug adapter supports the 'modules' request.
     */
    supportsModulesRequest?: boolean;
    /**
     * The debug adapter supports restarting a frame.
     */
    supportsRestartFrame?: boolean;
    /**
     * The debug adapter supports the 'restart' request. In this case a client should not
     * implement 'restart' by terminating and relaunching the adapter but by calling the
     * RestartRequest.
     */
    supportsRestartRequest?: boolean;
    /**
     * The debug adapter supports the 'setExpression' request.
     */
    supportsSetExpression?: boolean;
    /**
     * The debug adapter supports setting a variable to a value.
     */
    supportsSetVariable?: boolean;
    /**
     * The debug adapter supports stepping back via the 'stepBack' and 'reverseContinue'
     * requests.
     */
    supportsStepBack?: boolean;
    /**
     * The debug adapter supports the 'stepInTargets' request.
     */
    supportsStepInTargetsRequest?: boolean;
    /**
     * The debug adapter supports the 'terminate' request.
     */
    supportsTerminateRequest?: boolean;
    /**
     * The debug adapter supports the 'terminateThreads' request.
     */
    supportsTerminateThreadsRequest?: boolean;
    /**
     * The debug adapter supports a 'format' attribute on the stackTraceRequest,
     * variablesRequest, and evaluateRequest.
     */
    supportsValueFormattingOptions?: boolean;
    /**
     * The debug adapter supports the 'terminateDebuggee' attribute on the 'disconnect' request.
     */
    supportTerminateDebuggee?: boolean;
}

/**
 * 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).
 */
export interface ConfigurationDoneRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments?: { [key: string]: any };
    /**
     * The command to execute.
     */
    command: ArakGroundhog5;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog5 {
    ConfigurationDone = "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.
 */
export interface ConfigurationDoneResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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.
 */
export interface LaunchRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: LaunchRequestArgumentsObject;
    /**
     * The command to execute.
     */
    command: ArakGroundhog6;
}

/**
 * Arguments for 'launch' request. Additional attributes are implementation specific.
 */
export interface LaunchRequestArgumentsObject {
    /**
     * 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.
     */
    __restart?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * If noDebug is true the launch request should launch the program without enabling
     * debugging.
     */
    noDebug?: boolean;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog6 {
    Launch = "launch",
}

/**
 * Arguments for 'launch' request. Additional attributes are implementation specific.
 */
export interface LaunchRequestArguments {
    /**
     * 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.
     */
    __restart?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * If noDebug is true the launch request should launch the program without enabling
     * debugging.
     */
    noDebug?: boolean;
}

/**
 * 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.
 */
export interface LaunchResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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.
 */
export interface AttachRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: AttachRequestArgumentsObject;
    /**
     * The command to execute.
     */
    command: ArakGroundhog7;
}

/**
 * Arguments for 'attach' request. Additional attributes are implementation specific.
 */
export interface AttachRequestArgumentsObject {
    /**
     * 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.
     */
    __restart?: any[] | boolean | number | number | { [key: string]: any } | null | string;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog7 {
    Attach = "attach",
}

/**
 * Arguments for 'attach' request. Additional attributes are implementation specific.
 */
export interface AttachRequestArguments {
    /**
     * 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.
     */
    __restart?: any[] | boolean | number | number | { [key: string]: any } | null | string;
}

/**
 * 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.
 */
export interface AttachResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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.
 */
export interface RestartRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments?: { [key: string]: any };
    /**
     * The command to execute.
     */
    command: ArakGroundhog8;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog8 {
    Restart = "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.
 */
export interface RestartResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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).
 */
export interface DisconnectRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments?: DisconnectRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog9;
}

/**
 * Arguments for 'disconnect' request.
 */
export interface DisconnectRequestArguments {
    /**
     * A value of true indicates that this 'disconnect' request is part of a restart sequence.
     */
    restart?: boolean;
    /**
     * Indicates whether the debuggee should be terminated when the debugger is disconnected.
     * If unspecified, the debug adapter is free to do whatever it thinks is best.
     * A client can only rely on this attribute being properly honored if a debug adapter
     * returns true for the 'supportTerminateDebuggee' capability.
     */
    terminateDebuggee?: boolean;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog9 {
    Disconnect = "disconnect",
}

/**
 * Arguments for 'disconnect' request.
 */
export interface DisconnectArguments {
    /**
     * A value of true indicates that this 'disconnect' request is part of a restart sequence.
     */
    restart?: boolean;
    /**
     * Indicates whether the debuggee should be terminated when the debugger is disconnected.
     * If unspecified, the debug adapter is free to do whatever it thinks is best.
     * A client can only rely on this attribute being properly honored if a debug adapter
     * returns true for the 'supportTerminateDebuggee' capability.
     */
    terminateDebuggee?: boolean;
}

/**
 * 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.
 */
export interface DisconnectResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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.
 */
export interface TerminateRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments?: TerminateRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog10;
}

/**
 * Arguments for 'terminate' request.
 */
export interface TerminateRequestArguments {
    /**
     * A value of true indicates that this 'terminate' request is part of a restart sequence.
     */
    restart?: boolean;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog10 {
    Terminate = "terminate",
}

/**
 * Arguments for 'terminate' request.
 */
export interface TerminateArguments {
    /**
     * A value of true indicates that this 'terminate' request is part of a restart sequence.
     */
    restart?: boolean;
}

/**
 * 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.
 */
export interface TerminateResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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.
 */
export interface SetBreakpointsRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: SetBreakpointsRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog11;
}

/**
 * Arguments for 'setBreakpoints' request.
 */
export interface SetBreakpointsRequestArguments {
    /**
     * The code locations of the breakpoints.
     */
    breakpoints?: SourceBreakpoint[];
    /**
     * Deprecated: The code locations of the breakpoints.
     */
    lines?: number[];
    /**
     * The source location of the breakpoints; either 'source.path' or 'source.reference' must
     * be specified.
     */
    source: Source;
    /**
     * A value of true indicates that the underlying source has been modified which results in
     * new breakpoint locations.
     */
    sourceModified?: boolean;
}

/**
 * Properties of a breakpoint or logpoint passed to the setBreakpoints request.
 */
export interface SourceBreakpoint {
    /**
     * An optional source column of the breakpoint.
     */
    column?: number;
    /**
     * An optional expression for conditional breakpoints.
     */
    condition?: string;
    /**
     * An optional expression that controls how many hits of the breakpoint are ignored. The
     * backend is expected to interpret the expression as needed.
     */
    hitCondition?: string;
    /**
     * The source line of the breakpoint or logpoint.
     */
    line: number;
    /**
     * If this attribute exists and is non-empty, the backend must not 'break' (stop) but log
     * the message instead. Expressions within {} are interpolated.
     */
    logMessage?: string;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog11 {
    SetBreakpoints = "setBreakpoints",
}

/**
 * Arguments for 'setBreakpoints' request.
 */
export interface SetBreakpointsArguments {
    /**
     * The code locations of the breakpoints.
     */
    breakpoints?: SourceBreakpoint[];
    /**
     * Deprecated: The code locations of the breakpoints.
     */
    lines?: number[];
    /**
     * The source location of the breakpoints; either 'source.path' or 'source.reference' must
     * be specified.
     */
    source: Source;
    /**
     * A value of true indicates that the underlying source has been modified which results in
     * new breakpoint locations.
     */
    sourceModified?: boolean;
}

/**
 * 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.
 */
export interface SetBreakpointsResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: SetBreakpointsResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface SetBreakpointsResponseBody {
    /**
     * Information about the breakpoints. The array elements are in the same order as the
     * elements of the 'breakpoints' (or the deprecated 'lines') array in the arguments.
     */
    breakpoints: Breakpoint[];
}

/**
 * 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.
 */
export interface SetFunctionBreakpointsRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: SetFunctionBreakpointsRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog12;
}

/**
 * Arguments for 'setFunctionBreakpoints' request.
 */
export interface SetFunctionBreakpointsRequestArguments {
    /**
     * The function names of the breakpoints.
     */
    breakpoints: FunctionBreakpoint[];
}

/**
 * Properties of a breakpoint passed to the setFunctionBreakpoints request.
 */
export interface FunctionBreakpoint {
    /**
     * An optional expression for conditional breakpoints.
     */
    condition?: string;
    /**
     * An optional expression that controls how many hits of the breakpoint are ignored. The
     * backend is expected to interpret the expression as needed.
     */
    hitCondition?: string;
    /**
     * The name of the function.
     */
    name: string;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog12 {
    SetFunctionBreakpoints = "setFunctionBreakpoints",
}

/**
 * Arguments for 'setFunctionBreakpoints' request.
 */
export interface SetFunctionBreakpointsArguments {
    /**
     * The function names of the breakpoints.
     */
    breakpoints: FunctionBreakpoint[];
}

/**
 * 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.
 */
export interface SetFunctionBreakpointsResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: SetFunctionBreakpointsResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface SetFunctionBreakpointsResponseBody {
    /**
     * Information about the breakpoints. The array elements correspond to the elements of the
     * 'breakpoints' array.
     */
    breakpoints: Breakpoint[];
}

/**
 * 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').
 */
export interface SetExceptionBreakpointsRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: SetExceptionBreakpointsRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog13;
}

/**
 * Arguments for 'setExceptionBreakpoints' request.
 */
export interface SetExceptionBreakpointsRequestArguments {
    /**
     * Configuration options for selected exceptions.
     */
    exceptionOptions?: ExceptionOptions[];
    /**
     * IDs of checked exception options. The set of IDs is returned via the
     * 'exceptionBreakpointFilters' capability.
     */
    filters: string[];
}

/**
 * An ExceptionOptions assigns configuration options to a set of exceptions.
 */
export interface ExceptionOptions {
    /**
     * Condition when a thrown exception should result in a break.
     */
    breakMode: ExceptionBreakMode;
    /**
     * A path that selects a single or multiple exceptions in a tree. If 'path' is missing, the
     * whole tree is selected. By convention the first segment of the path is a category that is
     * used to group exceptions in the UI.
     */
    path?: ExceptionPathSegment[];
}

/**
 * Condition when a thrown exception should result in a break.
 *
 * This enumeration defines all possible conditions when a thrown exception should result in
 * a break.
 * never: never breaks,
 * always: always breaks,
 * unhandled: breaks when excpetion unhandled,
 * userUnhandled: breaks if the exception is not handled by user code.
 *
 * Mode that caused the exception notification to be raised.
 */
export enum ExceptionBreakMode {
    Always = "always",
    Never = "never",
    Unhandled = "unhandled",
    UserUnhandled = "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.
 */
export interface ExceptionPathSegment {
    /**
     * Depending on the value of 'negate' the names that should match or not match.
     */
    names: string[];
    /**
     * If false or missing this segment matches the names provided, otherwise it matches
     * anything except the names provided.
     */
    negate?: boolean;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog13 {
    SetExceptionBreakpoints = "setExceptionBreakpoints",
}

/**
 * Arguments for 'setExceptionBreakpoints' request.
 */
export interface SetExceptionBreakpointsArguments {
    /**
     * Configuration options for selected exceptions.
     */
    exceptionOptions?: ExceptionOptions[];
    /**
     * IDs of checked exception options. The set of IDs is returned via the
     * 'exceptionBreakpointFilters' capability.
     */
    filters: string[];
}

/**
 * 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.
 */
export interface SetExceptionBreakpointsResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * Base class of requests, responses, and events.
 *
 * A client or debug adapter initiated request.
 *
 * The request starts the debuggee to run again.
 */
export interface ContinueRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: ContinueRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog14;
}

/**
 * Arguments for 'continue' request.
 */
export interface ContinueRequestArguments {
    /**
     * Continue execution for the specified thread (if possible). If the backend cannot continue
     * on a single thread but will continue on all threads, it should set the
     * 'allThreadsContinued' attribute in the response to true.
     */
    threadId: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog14 {
    Continue = "continue",
}

/**
 * Arguments for 'continue' request.
 */
export interface ContinueArguments {
    /**
     * Continue execution for the specified thread (if possible). If the backend cannot continue
     * on a single thread but will continue on all threads, it should set the
     * 'allThreadsContinued' attribute in the response to true.
     */
    threadId: number;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'continue' request.
 */
export interface ContinueResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: ContinueResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface ContinueResponseBody {
    /**
     * If true, the 'continue' request has ignored the specified thread and continued all
     * threads instead. If this attribute is missing a value of 'true' is assumed for backward
     * compatibility.
     */
    allThreadsContinued?: boolean;
}

/**
 * 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.
 */
export interface NextRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: NextRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog15;
}

/**
 * Arguments for 'next' request.
 */
export interface NextRequestArguments {
    /**
     * Execute 'next' for this thread.
     */
    threadId: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog15 {
    Next = "next",
}

/**
 * Arguments for 'next' request.
 */
export interface NextArguments {
    /**
     * Execute 'next' for this thread.
     */
    threadId: number;
}

/**
 * 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.
 */
export interface NextResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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.
 */
export interface StepInRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: StepInRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog16;
}

/**
 * Arguments for 'stepIn' request.
 */
export interface StepInRequestArguments {
    /**
     * Optional id of the target to step into.
     */
    targetId?: number;
    /**
     * Execute 'stepIn' for this thread.
     */
    threadId: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog16 {
    StepIn = "stepIn",
}

/**
 * Arguments for 'stepIn' request.
 */
export interface StepInArguments {
    /**
     * Optional id of the target to step into.
     */
    targetId?: number;
    /**
     * Execute 'stepIn' for this thread.
     */
    threadId: number;
}

/**
 * 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.
 */
export interface StepInResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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.
 */
export interface StepOutRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: StepOutRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog17;
}

/**
 * Arguments for 'stepOut' request.
 */
export interface StepOutRequestArguments {
    /**
     * Execute 'stepOut' for this thread.
     */
    threadId: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog17 {
    StepOut = "stepOut",
}

/**
 * Arguments for 'stepOut' request.
 */
export interface StepOutArguments {
    /**
     * Execute 'stepOut' for this thread.
     */
    threadId: number;
}

/**
 * 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.
 */
export interface StepOutResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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.
 */
export interface StepBackRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: StepBackRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog18;
}

/**
 * Arguments for 'stepBack' request.
 */
export interface StepBackRequestArguments {
    /**
     * Execute 'stepBack' for this thread.
     */
    threadId: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog18 {
    StepBack = "stepBack",
}

/**
 * Arguments for 'stepBack' request.
 */
export interface StepBackArguments {
    /**
     * Execute 'stepBack' for this thread.
     */
    threadId: number;
}

/**
 * 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.
 */
export interface StepBackResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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.
 */
export interface ReverseContinueRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: ReverseContinueRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog19;
}

/**
 * Arguments for 'reverseContinue' request.
 */
export interface ReverseContinueRequestArguments {
    /**
     * Execute 'reverseContinue' for this thread.
     */
    threadId: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog19 {
    ReverseContinue = "reverseContinue",
}

/**
 * Arguments for 'reverseContinue' request.
 */
export interface ReverseContinueArguments {
    /**
     * Execute 'reverseContinue' for this thread.
     */
    threadId: number;
}

/**
 * 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.
 */
export interface ReverseContinueResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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.
 */
export interface RestartFrameRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: RestartFrameRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog20;
}

/**
 * Arguments for 'restartFrame' request.
 */
export interface RestartFrameRequestArguments {
    /**
     * Restart this stackframe.
     */
    frameId: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog20 {
    RestartFrame = "restartFrame",
}

/**
 * Arguments for 'restartFrame' request.
 */
export interface RestartFrameArguments {
    /**
     * Restart this stackframe.
     */
    frameId: number;
}

/**
 * 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.
 */
export interface RestartFrameResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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'.
 */
export interface GotoRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: GotoRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog21;
}

/**
 * Arguments for 'goto' request.
 */
export interface GotoRequestArguments {
    /**
     * The location where the debuggee will continue to run.
     */
    targetId: number;
    /**
     * Set the goto target for this thread.
     */
    threadId: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog21 {
    Goto = "goto",
}

/**
 * Arguments for 'goto' request.
 */
export interface GotoArguments {
    /**
     * The location where the debuggee will continue to run.
     */
    targetId: number;
    /**
     * Set the goto target for this thread.
     */
    threadId: number;
}

/**
 * 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.
 */
export interface GotoResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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.
 */
export interface PauseRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: PauseRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog22;
}

/**
 * Arguments for 'pause' request.
 */
export interface PauseRequestArguments {
    /**
     * Pause execution for this thread.
     */
    threadId: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog22 {
    Pause = "pause",
}

/**
 * Arguments for 'pause' request.
 */
export interface PauseArguments {
    /**
     * Pause execution for this thread.
     */
    threadId: number;
}

/**
 * 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.
 */
export interface PauseResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * Base class of requests, responses, and events.
 *
 * A client or debug adapter initiated request.
 *
 * The request returns a stacktrace from the current execution state.
 */
export interface StackTraceRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: StackTraceRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog23;
}

/**
 * Arguments for 'stackTrace' request.
 */
export interface StackTraceRequestArguments {
    /**
     * Specifies details on how to format the stack frames.
     */
    format?: StackFrameFormat;
    /**
     * The maximum number of frames to return. If levels is not specified or 0, all frames are
     * returned.
     */
    levels?: number;
    /**
     * The index of the first frame to return; if omitted frames start at 0.
     */
    startFrame?: number;
    /**
     * Retrieve the stacktrace for this thread.
     */
    threadId: number;
}

/**
 * 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.
 */
export interface StackFrameFormat {
    /**
     * Display the value in hex.
     */
    hex?: boolean;
    /**
     * Includes all stack frames, including those the debug adapter might otherwise hide.
     */
    includeAll?: boolean;
    /**
     * Displays the line number of the stack frame.
     */
    line?: boolean;
    /**
     * Displays the module of the stack frame.
     */
    module?: boolean;
    /**
     * Displays the names of parameters for the stack frame.
     */
    parameterNames?: boolean;
    /**
     * Displays parameters for the stack frame.
     */
    parameters?: boolean;
    /**
     * Displays the types of parameters for the stack frame.
     */
    parameterTypes?: boolean;
    /**
     * Displays the values of parameters for the stack frame.
     */
    parameterValues?: boolean;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog23 {
    StackTrace = "stackTrace",
}

/**
 * Arguments for 'stackTrace' request.
 */
export interface StackTraceArguments {
    /**
     * Specifies details on how to format the stack frames.
     */
    format?: StackFrameFormat;
    /**
     * The maximum number of frames to return. If levels is not specified or 0, all frames are
     * returned.
     */
    levels?: number;
    /**
     * The index of the first frame to return; if omitted frames start at 0.
     */
    startFrame?: number;
    /**
     * Retrieve the stacktrace for this thread.
     */
    threadId: number;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'stackTrace' request.
 */
export interface StackTraceResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: StackTraceResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface StackTraceResponseBody {
    /**
     * The frames of the stackframe. If the array has length zero, there are no stackframes
     * available.
     * This means that there is no location information available.
     */
    stackFrames: StackFrame[];
    /**
     * The total number of frames available.
     */
    totalFrames?: number;
}

/**
 * A Stackframe contains the source location.
 */
export interface StackFrame {
    /**
     * The column within the line. If source is null or doesn't exist, column is 0 and must be
     * ignored.
     */
    column: number;
    /**
     * An optional end column of the range covered by the stack frame.
     */
    endColumn?: number;
    /**
     * An optional end line of the range covered by the stack frame.
     */
    endLine?: number;
    /**
     * An identifier for the stack frame. It must be unique across all threads. This id can be
     * used to retrieve the scopes of the frame with the 'scopesRequest' or to restart the
     * execution of a stackframe.
     */
    id: number;
    /**
     * The line within the file of the frame. If source is null or doesn't exist, line is 0 and
     * must be ignored.
     */
    line: number;
    /**
     * The module associated with this frame, if any.
     */
    moduleId?: number | string;
    /**
     * The name of the stack frame, typically a method name.
     */
    name: string;
    /**
     * An optional hint for how to present this frame in the UI. A value of 'label' can be used
     * to indicate that the frame is an artificial frame that is used as a visual label or
     * separator. A value of 'subtle' can be used to change the appearance of a frame in a
     * 'subtle' way.
     */
    presentationHint?: StackFramePresentationHint;
    /**
     * The optional source of the frame.
     */
    source?: Source;
}

/**
 * An optional hint for how to present this frame in the UI. A value of 'label' can be used
 * to indicate that the frame is an artificial frame that is used as a visual label or
 * separator. A value of 'subtle' can be used to change the appearance of a frame in a
 * 'subtle' way.
 */
export enum StackFramePresentationHint {
    Label = "label",
    Normal = "normal",
    Subtle = "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.
 */
export interface ScopesRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: ScopesRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog24;
}

/**
 * Arguments for 'scopes' request.
 */
export interface ScopesRequestArguments {
    /**
     * Retrieve the scopes for this stackframe.
     */
    frameId: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog24 {
    Scopes = "scopes",
}

/**
 * Arguments for 'scopes' request.
 */
export interface ScopesArguments {
    /**
     * Retrieve the scopes for this stackframe.
     */
    frameId: number;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'scopes' request.
 */
export interface ScopesResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: ScopesResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface ScopesResponseBody {
    /**
     * The scopes of the stackframe. If the array has length zero, there are no scopes available.
     */
    scopes: Scope[];
}

/**
 * A Scope is a named container for variables. Optionally a scope can map to a source or a
 * range within a source.
 */
export interface Scope {
    /**
     * Optional start column of the range covered by this scope.
     */
    column?: number;
    /**
     * Optional end column of the range covered by this scope.
     */
    endColumn?: number;
    /**
     * Optional end line of the range covered by this scope.
     */
    endLine?: number;
    /**
     * If true, the number of variables in this scope is large or expensive to retrieve.
     */
    expensive: boolean;
    /**
     * The number of indexed variables in this scope.
     * The client can use this optional information to present the variables in a paged UI and
     * fetch them in chunks.
     */
    indexedVariables?: number;
    /**
     * Optional start line of the range covered by this scope.
     */
    line?: number;
    /**
     * Name of the scope such as 'Arguments', 'Locals'.
     */
    name: string;
    /**
     * The number of named variables in this scope.
     * The client can use this optional information to present the variables in a paged UI and
     * fetch them in chunks.
     */
    namedVariables?: number;
    /**
     * Optional source for this scope.
     */
    source?: Source;
    /**
     * The variables of this scope can be retrieved by passing the value of variablesReference
     * to the VariablesRequest.
     */
    variablesReference: number;
}

/**
 * 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.
 */
export interface VariablesRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: VariablesRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog25;
}

/**
 * Arguments for 'variables' request.
 */
export interface VariablesRequestArguments {
    /**
     * The number of variables to return. If count is missing or 0, all variables are returned.
     */
    count?: number;
    /**
     * Optional filter to limit the child variables to either named or indexed. If ommited, both
     * types are fetched.
     */
    filter?: Filter;
    /**
     * Specifies details on how to format the Variable values.
     */
    format?: ValueFormat;
    /**
     * The index of the first variable to return; if omitted children start at 0.
     */
    start?: number;
    /**
     * The Variable reference.
     */
    variablesReference: number;
}

/**
 * Optional filter to limit the child variables to either named or indexed. If ommited, both
 * types are fetched.
 */
export enum Filter {
    Indexed = "indexed",
    Named = "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.
 */
export interface ValueFormat {
    /**
     * Display the value in hex.
     */
    hex?: boolean;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog25 {
    Variables = "variables",
}

/**
 * Arguments for 'variables' request.
 */
export interface VariablesArguments {
    /**
     * The number of variables to return. If count is missing or 0, all variables are returned.
     */
    count?: number;
    /**
     * Optional filter to limit the child variables to either named or indexed. If ommited, both
     * types are fetched.
     */
    filter?: Filter;
    /**
     * Specifies details on how to format the Variable values.
     */
    format?: ValueFormat;
    /**
     * The index of the first variable to return; if omitted children start at 0.
     */
    start?: number;
    /**
     * The Variable reference.
     */
    variablesReference: number;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'variables' request.
 */
export interface VariablesResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: VariablesResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface VariablesResponseBody {
    /**
     * All (or a range) of variables for the given variable reference.
     */
    variables: Variable[];
}

/**
 * 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.
 */
export interface Variable {
    /**
     * Optional evaluatable name of this variable which can be passed to the 'EvaluateRequest'
     * to fetch the variable's value.
     */
    evaluateName?: string;
    /**
     * The number of indexed child variables.
     * The client can use this optional information to present the children in a paged UI and
     * fetch them in chunks.
     */
    indexedVariables?: number;
    /**
     * The variable's name.
     */
    name: string;
    /**
     * The number of named child variables.
     * The client can use this optional information to present the children in a paged UI and
     * fetch them in chunks.
     */
    namedVariables?: number;
    /**
     * Properties of a variable that can be used to determine how to render the variable in the
     * UI.
     */
    presentationHint?: VariablePresentationHint;
    /**
     * The type of the variable's value. Typically shown in the UI when hovering over the value.
     */
    type?: string;
    /**
     * The variable's value. This can be a multi-line text, e.g. for a function the body of a
     * function.
     */
    value: string;
    /**
     * If variablesReference is > 0, the variable is structured and its children can be
     * retrieved by passing variablesReference to the VariablesRequest.
     */
    variablesReference: number;
}

/**
 * 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.
 */
export interface VariablePresentationHint {
    /**
     * Set of attributes represented as an array of strings. Before introducing additional
     * values, try to use the listed values.
     */
    attributes?: string[];
    /**
     * The kind of variable. Before introducing additional values, try to use the listed values.
     */
    kind?: string;
    /**
     * Visibility of variable. Before introducing additional values, try to use the listed
     * values.
     */
    visibility?: string;
}

/**
 * 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.
 */
export interface SetVariableRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: SetVariableRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog26;
}

/**
 * Arguments for 'setVariable' request.
 */
export interface SetVariableRequestArguments {
    /**
     * Specifies details on how to format the response value.
     */
    format?: ValueFormat;
    /**
     * The name of the variable.
     */
    name: string;
    /**
     * The value of the variable.
     */
    value: string;
    /**
     * The reference of the variable container.
     */
    variablesReference: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog26 {
    SetVariable = "setVariable",
}

/**
 * Arguments for 'setVariable' request.
 */
export interface SetVariableArguments {
    /**
     * Specifies details on how to format the response value.
     */
    format?: ValueFormat;
    /**
     * The name of the variable.
     */
    name: string;
    /**
     * The value of the variable.
     */
    value: string;
    /**
     * The reference of the variable container.
     */
    variablesReference: number;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'setVariable' request.
 */
export interface SetVariableResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: SetVariableResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface SetVariableResponseBody {
    /**
     * The number of indexed child variables.
     * The client can use this optional information to present the variables in a paged UI and
     * fetch them in chunks.
     */
    indexedVariables?: number;
    /**
     * The number of named child variables.
     * The client can use this optional information to present the variables in a paged UI and
     * fetch them in chunks.
     */
    namedVariables?: number;
    /**
     * The type of the new value. Typically shown in the UI when hovering over the value.
     */
    type?: string;
    /**
     * The new value of the variable.
     */
    value: string;
    /**
     * If variablesReference is > 0, the new value is structured and its children can be
     * retrieved by passing variablesReference to the VariablesRequest.
     */
    variablesReference?: number;
}

/**
 * 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.
 */
export interface SourceRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: SourceRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog27;
}

/**
 * Arguments for 'source' request.
 */
export interface SourceRequestArguments {
    /**
     * Specifies the source content to load. Either source.path or source.sourceReference must
     * be specified.
     */
    source?: Source;
    /**
     * The reference to the source. This is the same as source.sourceReference. This is provided
     * for backward compatibility since old backends do not understand the 'source' attribute.
     */
    sourceReference: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog27 {
    Source = "source",
}

/**
 * Arguments for 'source' request.
 */
export interface SourceArguments {
    /**
     * Specifies the source content to load. Either source.path or source.sourceReference must
     * be specified.
     */
    source?: Source;
    /**
     * The reference to the source. This is the same as source.sourceReference. This is provided
     * for backward compatibility since old backends do not understand the 'source' attribute.
     */
    sourceReference: number;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'source' request.
 */
export interface SourceResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: SourceResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface SourceResponseBody {
    /**
     * Content of the source reference.
     */
    content: string;
    /**
     * Optional content type (mime type) of the source.
     */
    mimeType?: string;
}

/**
 * Base class of requests, responses, and events.
 *
 * A client or debug adapter initiated request.
 *
 * The request retrieves a list of all threads.
 */
export interface ThreadsRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command to execute.
     */
    command: ArakGroundhog28;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog28 {
    Threads = "threads",
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'threads' request.
 */
export interface ThreadsResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: ThreadsResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface ThreadsResponseBody {
    /**
     * All threads.
     */
    threads: Thread[];
}

/**
 * A Thread
 */
export interface Thread {
    /**
     * Unique identifier for the thread.
     */
    id: number;
    /**
     * A name of the thread.
     */
    name: string;
}

/**
 * Base class of requests, responses, and events.
 *
 * A client or debug adapter initiated request.
 *
 * The request terminates the threads with the given ids.
 */
export interface TerminateThreadsRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: TerminateThreadsRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog29;
}

/**
 * Arguments for 'terminateThreads' request.
 */
export interface TerminateThreadsRequestArguments {
    /**
     * Ids of threads to be terminated.
     */
    threadIds?: number[];
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog29 {
    TerminateThreads = "terminateThreads",
}

/**
 * Arguments for 'terminateThreads' request.
 */
export interface TerminateThreadsArguments {
    /**
     * Ids of threads to be terminated.
     */
    threadIds?: number[];
}

/**
 * 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.
 */
export interface TerminateThreadsResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body?: any[] | boolean | number | number | { [key: string]: any } | null | string;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

/**
 * 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.
 */
export interface ModulesRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: ModulesRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog30;
}

/**
 * Arguments for 'modules' request.
 */
export interface ModulesRequestArguments {
    /**
     * The number of modules to return. If moduleCount is not specified or 0, all modules are
     * returned.
     */
    moduleCount?: number;
    /**
     * The index of the first module to return; if omitted modules start at 0.
     */
    startModule?: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog30 {
    Modules = "modules",
}

/**
 * Arguments for 'modules' request.
 */
export interface ModulesArguments {
    /**
     * The number of modules to return. If moduleCount is not specified or 0, all modules are
     * returned.
     */
    moduleCount?: number;
    /**
     * The index of the first module to return; if omitted modules start at 0.
     */
    startModule?: number;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'modules' request.
 */
export interface ModulesResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: ModulesResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface ModulesResponseBody {
    /**
     * All modules or range of modules.
     */
    modules: Module[];
    /**
     * The total number of modules available.
     */
    totalModules?: number;
}

/**
 * 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.
 */
export interface LoadedSourcesRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments?: { [key: string]: any };
    /**
     * The command to execute.
     */
    command: ArakGroundhog31;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog31 {
    LoadedSources = "loadedSources",
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'loadedSources' request.
 */
export interface LoadedSourcesResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: LoadedSourcesResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface LoadedSourcesResponseBody {
    /**
     * Set of loaded sources.
     */
    sources: Source[];
}

/**
 * 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.
 */
export interface EvaluateRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: EvaluateRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog32;
}

/**
 * Arguments for 'evaluate' request.
 */
export interface EvaluateRequestArguments {
    /**
     * The context in which the evaluate request is run.
     */
    context?: string;
    /**
     * The expression to evaluate.
     */
    expression: string;
    /**
     * Specifies details on how to format the Evaluate result.
     */
    format?: ValueFormat;
    /**
     * Evaluate the expression in the scope of this stack frame. If not specified, the
     * expression is evaluated in the global scope.
     */
    frameId?: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog32 {
    Evaluate = "evaluate",
}

/**
 * Arguments for 'evaluate' request.
 */
export interface EvaluateArguments {
    /**
     * The context in which the evaluate request is run.
     */
    context?: string;
    /**
     * The expression to evaluate.
     */
    expression: string;
    /**
     * Specifies details on how to format the Evaluate result.
     */
    format?: ValueFormat;
    /**
     * Evaluate the expression in the scope of this stack frame. If not specified, the
     * expression is evaluated in the global scope.
     */
    frameId?: number;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'evaluate' request.
 */
export interface EvaluateResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: EvaluateResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface EvaluateResponseBody {
    /**
     * The number of indexed child variables.
     * The client can use this optional information to present the variables in a paged UI and
     * fetch them in chunks.
     */
    indexedVariables?: number;
    /**
     * The number of named child variables.
     * The client can use this optional information to present the variables in a paged UI and
     * fetch them in chunks.
     */
    namedVariables?: number;
    /**
     * Properties of a evaluate result that can be used to determine how to render the result in
     * the UI.
     */
    presentationHint?: VariablePresentationHint;
    /**
     * The result of the evaluate request.
     */
    result: string;
    /**
     * The optional type of the evaluate result.
     */
    type?: string;
    /**
     * If variablesReference is > 0, the evaluate result is structured and its children can be
     * retrieved by passing variablesReference to the VariablesRequest.
     */
    variablesReference: number;
}

/**
 * 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.
 */
export interface SetExpressionRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: SetExpressionRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog33;
}

/**
 * Arguments for 'setExpression' request.
 */
export interface SetExpressionRequestArguments {
    /**
     * The l-value expression to assign to.
     */
    expression: string;
    /**
     * Specifies how the resulting value should be formatted.
     */
    format?: ValueFormat;
    /**
     * Evaluate the expressions in the scope of this stack frame. If not specified, the
     * expressions are evaluated in the global scope.
     */
    frameId?: number;
    /**
     * The value expression to assign to the l-value expression.
     */
    value: string;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog33 {
    SetExpression = "setExpression",
}

/**
 * Arguments for 'setExpression' request.
 */
export interface SetExpressionArguments {
    /**
     * The l-value expression to assign to.
     */
    expression: string;
    /**
     * Specifies how the resulting value should be formatted.
     */
    format?: ValueFormat;
    /**
     * Evaluate the expressions in the scope of this stack frame. If not specified, the
     * expressions are evaluated in the global scope.
     */
    frameId?: number;
    /**
     * The value expression to assign to the l-value expression.
     */
    value: string;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'setExpression' request.
 */
export interface SetExpressionResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: SetExpressionResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface SetExpressionResponseBody {
    /**
     * The number of indexed child variables.
     * The client can use this optional information to present the variables in a paged UI and
     * fetch them in chunks.
     */
    indexedVariables?: number;
    /**
     * The number of named child variables.
     * The client can use this optional information to present the variables in a paged UI and
     * fetch them in chunks.
     */
    namedVariables?: number;
    /**
     * Properties of a value that can be used to determine how to render the result in the UI.
     */
    presentationHint?: VariablePresentationHint;
    /**
     * The optional type of the value.
     */
    type?: string;
    /**
     * The new value of the expression.
     */
    value: string;
    /**
     * If variablesReference is > 0, the value is structured and its children can be retrieved
     * by passing variablesReference to the VariablesRequest.
     */
    variablesReference?: number;
}

/**
 * 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.
 */
export interface StepInTargetsRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: StepInTargetsRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog34;
}

/**
 * Arguments for 'stepInTargets' request.
 */
export interface StepInTargetsRequestArguments {
    /**
     * The stack frame for which to retrieve the possible stepIn targets.
     */
    frameId: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog34 {
    StepInTargets = "stepInTargets",
}

/**
 * Arguments for 'stepInTargets' request.
 */
export interface StepInTargetsArguments {
    /**
     * The stack frame for which to retrieve the possible stepIn targets.
     */
    frameId: number;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'stepInTargets' request.
 */
export interface StepInTargetsResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: StepInTargetsResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface StepInTargetsResponseBody {
    /**
     * The possible stepIn targets of the specified source location.
     */
    targets: StepInTarget[];
}

/**
 * A StepInTarget can be used in the 'stepIn' request and determines into which single
 * target the stepIn request should step.
 */
export interface StepInTarget {
    /**
     * Unique identifier for a stepIn target.
     */
    id: number;
    /**
     * The name of the stepIn target (shown in the UI).
     */
    label: string;
}

/**
 * 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.
 */
export interface GotoTargetsRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: GotoTargetsRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog35;
}

/**
 * Arguments for 'gotoTargets' request.
 */
export interface GotoTargetsRequestArguments {
    /**
     * An optional column location for which the goto targets are determined.
     */
    column?: number;
    /**
     * The line location for which the goto targets are determined.
     */
    line: number;
    /**
     * The source location for which the goto targets are determined.
     */
    source: Source;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog35 {
    GotoTargets = "gotoTargets",
}

/**
 * Arguments for 'gotoTargets' request.
 */
export interface GotoTargetsArguments {
    /**
     * An optional column location for which the goto targets are determined.
     */
    column?: number;
    /**
     * The line location for which the goto targets are determined.
     */
    line: number;
    /**
     * The source location for which the goto targets are determined.
     */
    source: Source;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'gotoTargets' request.
 */
export interface GotoTargetsResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: GotoTargetsResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface GotoTargetsResponseBody {
    /**
     * The possible goto targets of the specified location.
     */
    targets: GotoTarget[];
}

/**
 * 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.
 */
export interface GotoTarget {
    /**
     * An optional column of the goto target.
     */
    column?: number;
    /**
     * An optional end column of the range covered by the goto target.
     */
    endColumn?: number;
    /**
     * An optional end line of the range covered by the goto target.
     */
    endLine?: number;
    /**
     * Unique identifier for a goto target. This is used in the goto request.
     */
    id: number;
    /**
     * The name of the goto target (shown in the UI).
     */
    label: string;
    /**
     * The line of the goto target.
     */
    line: number;
}

/**
 * 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.
 */
export interface CompletionsRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: CompletionsRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog36;
}

/**
 * Arguments for 'completions' request.
 */
export interface CompletionsRequestArguments {
    /**
     * The character position for which to determine the completion proposals.
     */
    column: number;
    /**
     * Returns completions in the scope of this stack frame. If not specified, the completions
     * are returned for the global scope.
     */
    frameId?: number;
    /**
     * An optional line for which to determine the completion proposals. If missing the first
     * line of the text is assumed.
     */
    line?: number;
    /**
     * One or more source lines. Typically this is the text a user has typed into the debug
     * console before he asked for completion.
     */
    text: string;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog36 {
    Completions = "completions",
}

/**
 * Arguments for 'completions' request.
 */
export interface CompletionsArguments {
    /**
     * The character position for which to determine the completion proposals.
     */
    column: number;
    /**
     * Returns completions in the scope of this stack frame. If not specified, the completions
     * are returned for the global scope.
     */
    frameId?: number;
    /**
     * An optional line for which to determine the completion proposals. If missing the first
     * line of the text is assumed.
     */
    line?: number;
    /**
     * One or more source lines. Typically this is the text a user has typed into the debug
     * console before he asked for completion.
     */
    text: string;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'completions' request.
 */
export interface CompletionsResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: CompletionsResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface CompletionsResponseBody {
    /**
     * The possible completions for .
     */
    targets: CompletionItem[];
}

/**
 * CompletionItems are the suggestions returned from the CompletionsRequest.
 */
export interface CompletionItem {
    /**
     * The label of this completion item. By default this is also the text that is inserted when
     * selecting this completion.
     */
    label: string;
    /**
     * This value determines how many characters are overwritten by the completion text.
     * If missing the value 0 is assumed which results in the completion text being inserted.
     */
    length?: number;
    /**
     * This value determines the location (in the CompletionsRequest's 'text' attribute) where
     * the completion text is added.
     * If missing the text is added at the location specified by the CompletionsRequest's
     * 'column' attribute.
     */
    start?: number;
    /**
     * If text is not falsy then it is inserted instead of the label.
     */
    text?: string;
    /**
     * The item's type. Typically the client uses this information to render the item in the UI
     * with an icon.
     */
    type?: CompletionItemType;
}

/**
 * The item's type. Typically the client uses this information to render the item in the UI
 * with an icon.
 *
 * Some predefined types for the CompletionItem. Please note that not all clients have
 * specific icons for all of them.
 */
export enum CompletionItemType {
    Class = "class",
    Color = "color",
    Constructor = "constructor",
    Customcolor = "customcolor",
    Enum = "enum",
    Field = "field",
    File = "file",
    Function = "function",
    Interface = "interface",
    Keyword = "keyword",
    Method = "method",
    Module = "module",
    Property = "property",
    Reference = "reference",
    Snippet = "snippet",
    Text = "text",
    Unit = "unit",
    Value = "value",
    Variable = "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.
 */
export interface ExceptionInfoRequest {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: PurpleArakGroundhog;
    /**
     * Object containing arguments for the command.
     */
    arguments: ExceptionInfoRequestArguments;
    /**
     * The command to execute.
     */
    command: ArakGroundhog37;
}

/**
 * Arguments for 'exceptionInfo' request.
 */
export interface ExceptionInfoRequestArguments {
    /**
     * Thread for which exception information should be retrieved.
     */
    threadId: number;
}

/**
 * Values must be strings.
 */
export enum ArakGroundhog37 {
    ExceptionInfo = "exceptionInfo",
}

/**
 * Arguments for 'exceptionInfo' request.
 */
export interface ExceptionInfoArguments {
    /**
     * Thread for which exception information should be retrieved.
     */
    threadId: number;
}

/**
 * Base class of requests, responses, and events.
 *
 * Response for a request.
 *
 * Response to 'exceptionInfo' request.
 */
export interface ExceptionInfoResponse {
    /**
     * Sequence number.
     */
    seq: number;
    /**
     * Message type.
     */
    type: TentacledArakGroundhog;
    /**
     * Contains request result if success is true and optional error details if success is false.
     */
    body: ExceptionInfoResponseBody;
    /**
     * The command requested.
     */
    command: string;
    /**
     * Contains error message if success == false.
     */
    message?: string;
    /**
     * Sequence number of the corresponding request.
     */
    request_seq: number;
    /**
     * Outcome of the request.
     */
    success: boolean;
}

export interface ExceptionInfoResponseBody {
    /**
     * Mode that caused the exception notification to be raised.
     */
    breakMode: ExceptionBreakMode;
    /**
     * Descriptive text for the exception provided by the debug adapter.
     */
    description?: string;
    /**
     * Detailed information about the exception.
     */
    details?: ExceptionDetails;
    /**
     * ID of the exception that was thrown.
     */
    exceptionId: string;
}

/**
 * Detailed information about the exception.
 *
 * Detailed information about an exception that has occurred.
 */
export interface ExceptionDetails {
    /**
     * Optional expression that can be evaluated in the current scope to obtain the exception
     * object.
     */
    evaluateName?: string;
    /**
     * Fully-qualified type name of the exception object.
     */
    fullTypeName?: string;
    /**
     * Details of the exception contained by this exception, if any.
     */
    innerException?: ExceptionDetails[];
    /**
     * Message contained in the exception.
     */
    message?: string;
    /**
     * Stack trace at the time the exception was thrown.
     */
    stackTrace?: string;
    /**
     * Short type name of the exception object.
     */
    typeName?: string;
}

/**
 * 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.
 */
export interface ModulesViewDescriptor {
    columns: ColumnDescriptor[];
}

// Converts JSON strings to/from your types
// and asserts the results of JSON.parse at runtime
export namespace Convert {
    export function toProtocolMessage(json: string): ProtocolMessage {
        return cast(JSON.parse(json), r("ProtocolMessage"));
    }

    export function protocolMessageToJson(value: ProtocolMessage): string {
        return JSON.stringify(uncast(value, r("ProtocolMessage")), null, 2);
    }

    export function toRequest(json: string): Request {
        return cast(JSON.parse(json), r("Request"));
    }

    export function requestToJson(value: Request): string {
        return JSON.stringify(uncast(value, r("Request")), null, 2);
    }

    export function toEvent(json: string): Event {
        return cast(JSON.parse(json), r("Event"));
    }

    export function eventToJson(value: Event): string {
        return JSON.stringify(uncast(value, r("Event")), null, 2);
    }

    export function toResponse(json: string): Response {
        return cast(JSON.parse(json), r("Response"));
    }

    export function responseToJson(value: Response): string {
        return JSON.stringify(uncast(value, r("Response")), null, 2);
    }

    export function toErrorResponse(json: string): ErrorResponse {
        return cast(JSON.parse(json), r("ErrorResponse"));
    }

    export function errorResponseToJson(value: ErrorResponse): string {
        return JSON.stringify(uncast(value, r("ErrorResponse")), null, 2);
    }

    export function toInitializedEvent(json: string): InitializedEvent {
        return cast(JSON.parse(json), r("InitializedEvent"));
    }

    export function initializedEventToJson(value: InitializedEvent): string {
        return JSON.stringify(uncast(value, r("InitializedEvent")), null, 2);
    }

    export function toStoppedEvent(json: string): StoppedEvent {
        return cast(JSON.parse(json), r("StoppedEvent"));
    }

    export function stoppedEventToJson(value: StoppedEvent): string {
        return JSON.stringify(uncast(value, r("StoppedEvent")), null, 2);
    }

    export function toContinuedEvent(json: string): ContinuedEvent {
        return cast(JSON.parse(json), r("ContinuedEvent"));
    }

    export function continuedEventToJson(value: ContinuedEvent): string {
        return JSON.stringify(uncast(value, r("ContinuedEvent")), null, 2);
    }

    export function toExitedEvent(json: string): ExitedEvent {
        return cast(JSON.parse(json), r("ExitedEvent"));
    }

    export function exitedEventToJson(value: ExitedEvent): string {
        return JSON.stringify(uncast(value, r("ExitedEvent")), null, 2);
    }

    export function toTerminatedEvent(json: string): TerminatedEvent {
        return cast(JSON.parse(json), r("TerminatedEvent"));
    }

    export function terminatedEventToJson(value: TerminatedEvent): string {
        return JSON.stringify(uncast(value, r("TerminatedEvent")), null, 2);
    }

    export function toThreadEvent(json: string): ThreadEvent {
        return cast(JSON.parse(json), r("ThreadEvent"));
    }

    export function threadEventToJson(value: ThreadEvent): string {
        return JSON.stringify(uncast(value, r("ThreadEvent")), null, 2);
    }

    export function toOutputEvent(json: string): OutputEvent {
        return cast(JSON.parse(json), r("OutputEvent"));
    }

    export function outputEventToJson(value: OutputEvent): string {
        return JSON.stringify(uncast(value, r("OutputEvent")), null, 2);
    }

    export function toBreakpointEvent(json: string): BreakpointEvent {
        return cast(JSON.parse(json), r("BreakpointEvent"));
    }

    export function breakpointEventToJson(value: BreakpointEvent): string {
        return JSON.stringify(uncast(value, r("BreakpointEvent")), null, 2);
    }

    export function toModuleEvent(json: string): ModuleEvent {
        return cast(JSON.parse(json), r("ModuleEvent"));
    }

    export function moduleEventToJson(value: ModuleEvent): string {
        return JSON.stringify(uncast(value, r("ModuleEvent")), null, 2);
    }

    export function toLoadedSourceEvent(json: string): LoadedSourceEvent {
        return cast(JSON.parse(json), r("LoadedSourceEvent"));
    }

    export function loadedSourceEventToJson(value: LoadedSourceEvent): string {
        return JSON.stringify(uncast(value, r("LoadedSourceEvent")), null, 2);
    }

    export function toProcessEvent(json: string): ProcessEvent {
        return cast(JSON.parse(json), r("ProcessEvent"));
    }

    export function processEventToJson(value: ProcessEvent): string {
        return JSON.stringify(uncast(value, r("ProcessEvent")), null, 2);
    }

    export function toCapabilitiesEvent(json: string): CapabilitiesEvent {
        return cast(JSON.parse(json), r("CapabilitiesEvent"));
    }

    export function capabilitiesEventToJson(value: CapabilitiesEvent): string {
        return JSON.stringify(uncast(value, r("CapabilitiesEvent")), null, 2);
    }

    export function toRunInTerminalRequest(json: string): RunInTerminalRequest {
        return cast(JSON.parse(json), r("RunInTerminalRequest"));
    }

    export function runInTerminalRequestToJson(value: RunInTerminalRequest): string {
        return JSON.stringify(uncast(value, r("RunInTerminalRequest")), null, 2);
    }

    export function toRunInTerminalRequestArguments(json: string): RunInTerminalRequestArguments {
        return cast(JSON.parse(json), r("RunInTerminalRequestArguments"));
    }

    export function runInTerminalRequestArgumentsToJson(value: RunInTerminalRequestArguments): string {
        return JSON.stringify(uncast(value, r("RunInTerminalRequestArguments")), null, 2);
    }

    export function toRunInTerminalResponse(json: string): RunInTerminalResponse {
        return cast(JSON.parse(json), r("RunInTerminalResponse"));
    }

    export function runInTerminalResponseToJson(value: RunInTerminalResponse): string {
        return JSON.stringify(uncast(value, r("RunInTerminalResponse")), null, 2);
    }

    export function toInitializeRequest(json: string): InitializeRequest {
        return cast(JSON.parse(json), r("InitializeRequest"));
    }

    export function initializeRequestToJson(value: InitializeRequest): string {
        return JSON.stringify(uncast(value, r("InitializeRequest")), null, 2);
    }

    export function toInitializeRequestArguments(json: string): InitializeRequestArguments {
        return cast(JSON.parse(json), r("InitializeRequestArguments"));
    }

    export function initializeRequestArgumentsToJson(value: InitializeRequestArguments): string {
        return JSON.stringify(uncast(value, r("InitializeRequestArguments")), null, 2);
    }

    export function toInitializeResponse(json: string): InitializeResponse {
        return cast(JSON.parse(json), r("InitializeResponse"));
    }

    export function initializeResponseToJson(value: InitializeResponse): string {
        return JSON.stringify(uncast(value, r("InitializeResponse")), null, 2);
    }

    export function toConfigurationDoneRequest(json: string): ConfigurationDoneRequest {
        return cast(JSON.parse(json), r("ConfigurationDoneRequest"));
    }

    export function configurationDoneRequestToJson(value: ConfigurationDoneRequest): string {
        return JSON.stringify(uncast(value, r("ConfigurationDoneRequest")), null, 2);
    }

    export function toConfigurationDoneArguments(json: string): { [key: string]: any } {
        return cast(JSON.parse(json), m("any"));
    }

    export function configurationDoneArgumentsToJson(value: { [key: string]: any }): string {
        return JSON.stringify(uncast(value, m("any")), null, 2);
    }

    export function toConfigurationDoneResponse(json: string): ConfigurationDoneResponse {
        return cast(JSON.parse(json), r("ConfigurationDoneResponse"));
    }

    export function configurationDoneResponseToJson(value: ConfigurationDoneResponse): string {
        return JSON.stringify(uncast(value, r("ConfigurationDoneResponse")), null, 2);
    }

    export function toLaunchRequest(json: string): LaunchRequest {
        return cast(JSON.parse(json), r("LaunchRequest"));
    }

    export function launchRequestToJson(value: LaunchRequest): string {
        return JSON.stringify(uncast(value, r("LaunchRequest")), null, 2);
    }

    export function toLaunchRequestArguments(json: string): LaunchRequestArguments {
        return cast(JSON.parse(json), r("LaunchRequestArguments"));
    }

    export function launchRequestArgumentsToJson(value: LaunchRequestArguments): string {
        return JSON.stringify(uncast(value, r("LaunchRequestArguments")), null, 2);
    }

    export function toLaunchResponse(json: string): LaunchResponse {
        return cast(JSON.parse(json), r("LaunchResponse"));
    }

    export function launchResponseToJson(value: LaunchResponse): string {
        return JSON.stringify(uncast(value, r("LaunchResponse")), null, 2);
    }

    export function toAttachRequest(json: string): AttachRequest {
        return cast(JSON.parse(json), r("AttachRequest"));
    }

    export function attachRequestToJson(value: AttachRequest): string {
        return JSON.stringify(uncast(value, r("AttachRequest")), null, 2);
    }

    export function toAttachRequestArguments(json: string): AttachRequestArguments {
        return cast(JSON.parse(json), r("AttachRequestArguments"));
    }

    export function attachRequestArgumentsToJson(value: AttachRequestArguments): string {
        return JSON.stringify(uncast(value, r("AttachRequestArguments")), null, 2);
    }

    export function toAttachResponse(json: string): AttachResponse {
        return cast(JSON.parse(json), r("AttachResponse"));
    }

    export function attachResponseToJson(value: AttachResponse): string {
        return JSON.stringify(uncast(value, r("AttachResponse")), null, 2);
    }

    export function toRestartRequest(json: string): RestartRequest {
        return cast(JSON.parse(json), r("RestartRequest"));
    }

    export function restartRequestToJson(value: RestartRequest): string {
        return JSON.stringify(uncast(value, r("RestartRequest")), null, 2);
    }

    export function toRestartArguments(json: string): { [key: string]: any } {
        return cast(JSON.parse(json), m("any"));
    }

    export function restartArgumentsToJson(value: { [key: string]: any }): string {
        return JSON.stringify(uncast(value, m("any")), null, 2);
    }

    export function toRestartResponse(json: string): RestartResponse {
        return cast(JSON.parse(json), r("RestartResponse"));
    }

    export function restartResponseToJson(value: RestartResponse): string {
        return JSON.stringify(uncast(value, r("RestartResponse")), null, 2);
    }

    export function toDisconnectRequest(json: string): DisconnectRequest {
        return cast(JSON.parse(json), r("DisconnectRequest"));
    }

    export function disconnectRequestToJson(value: DisconnectRequest): string {
        return JSON.stringify(uncast(value, r("DisconnectRequest")), null, 2);
    }

    export function toDisconnectArguments(json: string): DisconnectArguments {
        return cast(JSON.parse(json), r("DisconnectArguments"));
    }

    export function disconnectArgumentsToJson(value: DisconnectArguments): string {
        return JSON.stringify(uncast(value, r("DisconnectArguments")), null, 2);
    }

    export function toDisconnectResponse(json: string): DisconnectResponse {
        return cast(JSON.parse(json), r("DisconnectResponse"));
    }

    export function disconnectResponseToJson(value: DisconnectResponse): string {
        return JSON.stringify(uncast(value, r("DisconnectResponse")), null, 2);
    }

    export function toTerminateRequest(json: string): TerminateRequest {
        return cast(JSON.parse(json), r("TerminateRequest"));
    }

    export function terminateRequestToJson(value: TerminateRequest): string {
        return JSON.stringify(uncast(value, r("TerminateRequest")), null, 2);
    }

    export function toTerminateArguments(json: string): TerminateArguments {
        return cast(JSON.parse(json), r("TerminateArguments"));
    }

    export function terminateArgumentsToJson(value: TerminateArguments): string {
        return JSON.stringify(uncast(value, r("TerminateArguments")), null, 2);
    }

    export function toTerminateResponse(json: string): TerminateResponse {
        return cast(JSON.parse(json), r("TerminateResponse"));
    }

    export function terminateResponseToJson(value: TerminateResponse): string {
        return JSON.stringify(uncast(value, r("TerminateResponse")), null, 2);
    }

    export function toSetBreakpointsRequest(json: string): SetBreakpointsRequest {
        return cast(JSON.parse(json), r("SetBreakpointsRequest"));
    }

    export function setBreakpointsRequestToJson(value: SetBreakpointsRequest): string {
        return JSON.stringify(uncast(value, r("SetBreakpointsRequest")), null, 2);
    }

    export function toSetBreakpointsArguments(json: string): SetBreakpointsArguments {
        return cast(JSON.parse(json), r("SetBreakpointsArguments"));
    }

    export function setBreakpointsArgumentsToJson(value: SetBreakpointsArguments): string {
        return JSON.stringify(uncast(value, r("SetBreakpointsArguments")), null, 2);
    }

    export function toSetBreakpointsResponse(json: string): SetBreakpointsResponse {
        return cast(JSON.parse(json), r("SetBreakpointsResponse"));
    }

    export function setBreakpointsResponseToJson(value: SetBreakpointsResponse): string {
        return JSON.stringify(uncast(value, r("SetBreakpointsResponse")), null, 2);
    }

    export function toSetFunctionBreakpointsRequest(json: string): SetFunctionBreakpointsRequest {
        return cast(JSON.parse(json), r("SetFunctionBreakpointsRequest"));
    }

    export function setFunctionBreakpointsRequestToJson(value: SetFunctionBreakpointsRequest): string {
        return JSON.stringify(uncast(value, r("SetFunctionBreakpointsRequest")), null, 2);
    }

    export function toSetFunctionBreakpointsArguments(json: string): SetFunctionBreakpointsArguments {
        return cast(JSON.parse(json), r("SetFunctionBreakpointsArguments"));
    }

    export function setFunctionBreakpointsArgumentsToJson(value: SetFunctionBreakpointsArguments): string {
        return JSON.stringify(uncast(value, r("SetFunctionBreakpointsArguments")), null, 2);
    }

    export function toSetFunctionBreakpointsResponse(json: string): SetFunctionBreakpointsResponse {
        return cast(JSON.parse(json), r("SetFunctionBreakpointsResponse"));
    }

    export function setFunctionBreakpointsResponseToJson(value: SetFunctionBreakpointsResponse): string {
        return JSON.stringify(uncast(value, r("SetFunctionBreakpointsResponse")), null, 2);
    }

    export function toSetExceptionBreakpointsRequest(json: string): SetExceptionBreakpointsRequest {
        return cast(JSON.parse(json), r("SetExceptionBreakpointsRequest"));
    }

    export function setExceptionBreakpointsRequestToJson(value: SetExceptionBreakpointsRequest): string {
        return JSON.stringify(uncast(value, r("SetExceptionBreakpointsRequest")), null, 2);
    }

    export function toSetExceptionBreakpointsArguments(json: string): SetExceptionBreakpointsArguments {
        return cast(JSON.parse(json), r("SetExceptionBreakpointsArguments"));
    }

    export function setExceptionBreakpointsArgumentsToJson(value: SetExceptionBreakpointsArguments): string {
        return JSON.stringify(uncast(value, r("SetExceptionBreakpointsArguments")), null, 2);
    }

    export function toSetExceptionBreakpointsResponse(json: string): SetExceptionBreakpointsResponse {
        return cast(JSON.parse(json), r("SetExceptionBreakpointsResponse"));
    }

    export function setExceptionBreakpointsResponseToJson(value: SetExceptionBreakpointsResponse): string {
        return JSON.stringify(uncast(value, r("SetExceptionBreakpointsResponse")), null, 2);
    }

    export function toContinueRequest(json: string): ContinueRequest {
        return cast(JSON.parse(json), r("ContinueRequest"));
    }

    export function continueRequestToJson(value: ContinueRequest): string {
        return JSON.stringify(uncast(value, r("ContinueRequest")), null, 2);
    }

    export function toContinueArguments(json: string): ContinueArguments {
        return cast(JSON.parse(json), r("ContinueArguments"));
    }

    export function continueArgumentsToJson(value: ContinueArguments): string {
        return JSON.stringify(uncast(value, r("ContinueArguments")), null, 2);
    }

    export function toContinueResponse(json: string): ContinueResponse {
        return cast(JSON.parse(json), r("ContinueResponse"));
    }

    export function continueResponseToJson(value: ContinueResponse): string {
        return JSON.stringify(uncast(value, r("ContinueResponse")), null, 2);
    }

    export function toNextRequest(json: string): NextRequest {
        return cast(JSON.parse(json), r("NextRequest"));
    }

    export function nextRequestToJson(value: NextRequest): string {
        return JSON.stringify(uncast(value, r("NextRequest")), null, 2);
    }

    export function toNextArguments(json: string): NextArguments {
        return cast(JSON.parse(json), r("NextArguments"));
    }

    export function nextArgumentsToJson(value: NextArguments): string {
        return JSON.stringify(uncast(value, r("NextArguments")), null, 2);
    }

    export function toNextResponse(json: string): NextResponse {
        return cast(JSON.parse(json), r("NextResponse"));
    }

    export function nextResponseToJson(value: NextResponse): string {
        return JSON.stringify(uncast(value, r("NextResponse")), null, 2);
    }

    export function toStepInRequest(json: string): StepInRequest {
        return cast(JSON.parse(json), r("StepInRequest"));
    }

    export function stepInRequestToJson(value: StepInRequest): string {
        return JSON.stringify(uncast(value, r("StepInRequest")), null, 2);
    }

    export function toStepInArguments(json: string): StepInArguments {
        return cast(JSON.parse(json), r("StepInArguments"));
    }

    export function stepInArgumentsToJson(value: StepInArguments): string {
        return JSON.stringify(uncast(value, r("StepInArguments")), null, 2);
    }

    export function toStepInResponse(json: string): StepInResponse {
        return cast(JSON.parse(json), r("StepInResponse"));
    }

    export function stepInResponseToJson(value: StepInResponse): string {
        return JSON.stringify(uncast(value, r("StepInResponse")), null, 2);
    }

    export function toStepOutRequest(json: string): StepOutRequest {
        return cast(JSON.parse(json), r("StepOutRequest"));
    }

    export function stepOutRequestToJson(value: StepOutRequest): string {
        return JSON.stringify(uncast(value, r("StepOutRequest")), null, 2);
    }

    export function toStepOutArguments(json: string): StepOutArguments {
        return cast(JSON.parse(json), r("StepOutArguments"));
    }

    export function stepOutArgumentsToJson(value: StepOutArguments): string {
        return JSON.stringify(uncast(value, r("StepOutArguments")), null, 2);
    }

    export function toStepOutResponse(json: string): StepOutResponse {
        return cast(JSON.parse(json), r("StepOutResponse"));
    }

    export function stepOutResponseToJson(value: StepOutResponse): string {
        return JSON.stringify(uncast(value, r("StepOutResponse")), null, 2);
    }

    export function toStepBackRequest(json: string): StepBackRequest {
        return cast(JSON.parse(json), r("StepBackRequest"));
    }

    export function stepBackRequestToJson(value: StepBackRequest): string {
        return JSON.stringify(uncast(value, r("StepBackRequest")), null, 2);
    }

    export function toStepBackArguments(json: string): StepBackArguments {
        return cast(JSON.parse(json), r("StepBackArguments"));
    }

    export function stepBackArgumentsToJson(value: StepBackArguments): string {
        return JSON.stringify(uncast(value, r("StepBackArguments")), null, 2);
    }

    export function toStepBackResponse(json: string): StepBackResponse {
        return cast(JSON.parse(json), r("StepBackResponse"));
    }

    export function stepBackResponseToJson(value: StepBackResponse): string {
        return JSON.stringify(uncast(value, r("StepBackResponse")), null, 2);
    }

    export function toReverseContinueRequest(json: string): ReverseContinueRequest {
        return cast(JSON.parse(json), r("ReverseContinueRequest"));
    }

    export function reverseContinueRequestToJson(value: ReverseContinueRequest): string {
        return JSON.stringify(uncast(value, r("ReverseContinueRequest")), null, 2);
    }

    export function toReverseContinueArguments(json: string): ReverseContinueArguments {
        return cast(JSON.parse(json), r("ReverseContinueArguments"));
    }

    export function reverseContinueArgumentsToJson(value: ReverseContinueArguments): string {
        return JSON.stringify(uncast(value, r("ReverseContinueArguments")), null, 2);
    }

    export function toReverseContinueResponse(json: string): ReverseContinueResponse {
        return cast(JSON.parse(json), r("ReverseContinueResponse"));
    }

    export function reverseContinueResponseToJson(value: ReverseContinueResponse): string {
        return JSON.stringify(uncast(value, r("ReverseContinueResponse")), null, 2);
    }

    export function toRestartFrameRequest(json: string): RestartFrameRequest {
        return cast(JSON.parse(json), r("RestartFrameRequest"));
    }

    export function restartFrameRequestToJson(value: RestartFrameRequest): string {
        return JSON.stringify(uncast(value, r("RestartFrameRequest")), null, 2);
    }

    export function toRestartFrameArguments(json: string): RestartFrameArguments {
        return cast(JSON.parse(json), r("RestartFrameArguments"));
    }

    export function restartFrameArgumentsToJson(value: RestartFrameArguments): string {
        return JSON.stringify(uncast(value, r("RestartFrameArguments")), null, 2);
    }

    export function toRestartFrameResponse(json: string): RestartFrameResponse {
        return cast(JSON.parse(json), r("RestartFrameResponse"));
    }

    export function restartFrameResponseToJson(value: RestartFrameResponse): string {
        return JSON.stringify(uncast(value, r("RestartFrameResponse")), null, 2);
    }

    export function toGotoRequest(json: string): GotoRequest {
        return cast(JSON.parse(json), r("GotoRequest"));
    }

    export function gotoRequestToJson(value: GotoRequest): string {
        return JSON.stringify(uncast(value, r("GotoRequest")), null, 2);
    }

    export function toGotoArguments(json: string): GotoArguments {
        return cast(JSON.parse(json), r("GotoArguments"));
    }

    export function gotoArgumentsToJson(value: GotoArguments): string {
        return JSON.stringify(uncast(value, r("GotoArguments")), null, 2);
    }

    export function toGotoResponse(json: string): GotoResponse {
        return cast(JSON.parse(json), r("GotoResponse"));
    }

    export function gotoResponseToJson(value: GotoResponse): string {
        return JSON.stringify(uncast(value, r("GotoResponse")), null, 2);
    }

    export function toPauseRequest(json: string): PauseRequest {
        return cast(JSON.parse(json), r("PauseRequest"));
    }

    export function pauseRequestToJson(value: PauseRequest): string {
        return JSON.stringify(uncast(value, r("PauseRequest")), null, 2);
    }

    export function toPauseArguments(json: string): PauseArguments {
        return cast(JSON.parse(json), r("PauseArguments"));
    }

    export function pauseArgumentsToJson(value: PauseArguments): string {
        return JSON.stringify(uncast(value, r("PauseArguments")), null, 2);
    }

    export function toPauseResponse(json: string): PauseResponse {
        return cast(JSON.parse(json), r("PauseResponse"));
    }

    export function pauseResponseToJson(value: PauseResponse): string {
        return JSON.stringify(uncast(value, r("PauseResponse")), null, 2);
    }

    export function toStackTraceRequest(json: string): StackTraceRequest {
        return cast(JSON.parse(json), r("StackTraceRequest"));
    }

    export function stackTraceRequestToJson(value: StackTraceRequest): string {
        return JSON.stringify(uncast(value, r("StackTraceRequest")), null, 2);
    }

    export function toStackTraceArguments(json: string): StackTraceArguments {
        return cast(JSON.parse(json), r("StackTraceArguments"));
    }

    export function stackTraceArgumentsToJson(value: StackTraceArguments): string {
        return JSON.stringify(uncast(value, r("StackTraceArguments")), null, 2);
    }

    export function toStackTraceResponse(json: string): StackTraceResponse {
        return cast(JSON.parse(json), r("StackTraceResponse"));
    }

    export function stackTraceResponseToJson(value: StackTraceResponse): string {
        return JSON.stringify(uncast(value, r("StackTraceResponse")), null, 2);
    }

    export function toScopesRequest(json: string): ScopesRequest {
        return cast(JSON.parse(json), r("ScopesRequest"));
    }

    export function scopesRequestToJson(value: ScopesRequest): string {
        return JSON.stringify(uncast(value, r("ScopesRequest")), null, 2);
    }

    export function toScopesArguments(json: string): ScopesArguments {
        return cast(JSON.parse(json), r("ScopesArguments"));
    }

    export function scopesArgumentsToJson(value: ScopesArguments): string {
        return JSON.stringify(uncast(value, r("ScopesArguments")), null, 2);
    }

    export function toScopesResponse(json: string): ScopesResponse {
        return cast(JSON.parse(json), r("ScopesResponse"));
    }

    export function scopesResponseToJson(value: ScopesResponse): string {
        return JSON.stringify(uncast(value, r("ScopesResponse")), null, 2);
    }

    export function toVariablesRequest(json: string): VariablesRequest {
        return cast(JSON.parse(json), r("VariablesRequest"));
    }

    export function variablesRequestToJson(value: VariablesRequest): string {
        return JSON.stringify(uncast(value, r("VariablesRequest")), null, 2);
    }

    export function toVariablesArguments(json: string): VariablesArguments {
        return cast(JSON.parse(json), r("VariablesArguments"));
    }

    export function variablesArgumentsToJson(value: VariablesArguments): string {
        return JSON.stringify(uncast(value, r("VariablesArguments")), null, 2);
    }

    export function toVariablesResponse(json: string): VariablesResponse {
        return cast(JSON.parse(json), r("VariablesResponse"));
    }

    export function variablesResponseToJson(value: VariablesResponse): string {
        return JSON.stringify(uncast(value, r("VariablesResponse")), null, 2);
    }

    export function toSetVariableRequest(json: string): SetVariableRequest {
        return cast(JSON.parse(json), r("SetVariableRequest"));
    }

    export function setVariableRequestToJson(value: SetVariableRequest): string {
        return JSON.stringify(uncast(value, r("SetVariableRequest")), null, 2);
    }

    export function toSetVariableArguments(json: string): SetVariableArguments {
        return cast(JSON.parse(json), r("SetVariableArguments"));
    }

    export function setVariableArgumentsToJson(value: SetVariableArguments): string {
        return JSON.stringify(uncast(value, r("SetVariableArguments")), null, 2);
    }

    export function toSetVariableResponse(json: string): SetVariableResponse {
        return cast(JSON.parse(json), r("SetVariableResponse"));
    }

    export function setVariableResponseToJson(value: SetVariableResponse): string {
        return JSON.stringify(uncast(value, r("SetVariableResponse")), null, 2);
    }

    export function toSourceRequest(json: string): SourceRequest {
        return cast(JSON.parse(json), r("SourceRequest"));
    }

    export function sourceRequestToJson(value: SourceRequest): string {
        return JSON.stringify(uncast(value, r("SourceRequest")), null, 2);
    }

    export function toSourceArguments(json: string): SourceArguments {
        return cast(JSON.parse(json), r("SourceArguments"));
    }

    export function sourceArgumentsToJson(value: SourceArguments): string {
        return JSON.stringify(uncast(value, r("SourceArguments")), null, 2);
    }

    export function toSourceResponse(json: string): SourceResponse {
        return cast(JSON.parse(json), r("SourceResponse"));
    }

    export function sourceResponseToJson(value: SourceResponse): string {
        return JSON.stringify(uncast(value, r("SourceResponse")), null, 2);
    }

    export function toThreadsRequest(json: string): ThreadsRequest {
        return cast(JSON.parse(json), r("ThreadsRequest"));
    }

    export function threadsRequestToJson(value: ThreadsRequest): string {
        return JSON.stringify(uncast(value, r("ThreadsRequest")), null, 2);
    }

    export function toThreadsResponse(json: string): ThreadsResponse {
        return cast(JSON.parse(json), r("ThreadsResponse"));
    }

    export function threadsResponseToJson(value: ThreadsResponse): string {
        return JSON.stringify(uncast(value, r("ThreadsResponse")), null, 2);
    }

    export function toTerminateThreadsRequest(json: string): TerminateThreadsRequest {
        return cast(JSON.parse(json), r("TerminateThreadsRequest"));
    }

    export function terminateThreadsRequestToJson(value: TerminateThreadsRequest): string {
        return JSON.stringify(uncast(value, r("TerminateThreadsRequest")), null, 2);
    }

    export function toTerminateThreadsArguments(json: string): TerminateThreadsArguments {
        return cast(JSON.parse(json), r("TerminateThreadsArguments"));
    }

    export function terminateThreadsArgumentsToJson(value: TerminateThreadsArguments): string {
        return JSON.stringify(uncast(value, r("TerminateThreadsArguments")), null, 2);
    }

    export function toTerminateThreadsResponse(json: string): TerminateThreadsResponse {
        return cast(JSON.parse(json), r("TerminateThreadsResponse"));
    }

    export function terminateThreadsResponseToJson(value: TerminateThreadsResponse): string {
        return JSON.stringify(uncast(value, r("TerminateThreadsResponse")), null, 2);
    }

    export function toModulesRequest(json: string): ModulesRequest {
        return cast(JSON.parse(json), r("ModulesRequest"));
    }

    export function modulesRequestToJson(value: ModulesRequest): string {
        return JSON.stringify(uncast(value, r("ModulesRequest")), null, 2);
    }

    export function toModulesArguments(json: string): ModulesArguments {
        return cast(JSON.parse(json), r("ModulesArguments"));
    }

    export function modulesArgumentsToJson(value: ModulesArguments): string {
        return JSON.stringify(uncast(value, r("ModulesArguments")), null, 2);
    }

    export function toModulesResponse(json: string): ModulesResponse {
        return cast(JSON.parse(json), r("ModulesResponse"));
    }

    export function modulesResponseToJson(value: ModulesResponse): string {
        return JSON.stringify(uncast(value, r("ModulesResponse")), null, 2);
    }

    export function toLoadedSourcesRequest(json: string): LoadedSourcesRequest {
        return cast(JSON.parse(json), r("LoadedSourcesRequest"));
    }

    export function loadedSourcesRequestToJson(value: LoadedSourcesRequest): string {
        return JSON.stringify(uncast(value, r("LoadedSourcesRequest")), null, 2);
    }

    export function toLoadedSourcesArguments(json: string): { [key: string]: any } {
        return cast(JSON.parse(json), m("any"));
    }

    export function loadedSourcesArgumentsToJson(value: { [key: string]: any }): string {
        return JSON.stringify(uncast(value, m("any")), null, 2);
    }

    export function toLoadedSourcesResponse(json: string): LoadedSourcesResponse {
        return cast(JSON.parse(json), r("LoadedSourcesResponse"));
    }

    export function loadedSourcesResponseToJson(value: LoadedSourcesResponse): string {
        return JSON.stringify(uncast(value, r("LoadedSourcesResponse")), null, 2);
    }

    export function toEvaluateRequest(json: string): EvaluateRequest {
        return cast(JSON.parse(json), r("EvaluateRequest"));
    }

    export function evaluateRequestToJson(value: EvaluateRequest): string {
        return JSON.stringify(uncast(value, r("EvaluateRequest")), null, 2);
    }

    export function toEvaluateArguments(json: string): EvaluateArguments {
        return cast(JSON.parse(json), r("EvaluateArguments"));
    }

    export function evaluateArgumentsToJson(value: EvaluateArguments): string {
        return JSON.stringify(uncast(value, r("EvaluateArguments")), null, 2);
    }

    export function toEvaluateResponse(json: string): EvaluateResponse {
        return cast(JSON.parse(json), r("EvaluateResponse"));
    }

    export function evaluateResponseToJson(value: EvaluateResponse): string {
        return JSON.stringify(uncast(value, r("EvaluateResponse")), null, 2);
    }

    export function toSetExpressionRequest(json: string): SetExpressionRequest {
        return cast(JSON.parse(json), r("SetExpressionRequest"));
    }

    export function setExpressionRequestToJson(value: SetExpressionRequest): string {
        return JSON.stringify(uncast(value, r("SetExpressionRequest")), null, 2);
    }

    export function toSetExpressionArguments(json: string): SetExpressionArguments {
        return cast(JSON.parse(json), r("SetExpressionArguments"));
    }

    export function setExpressionArgumentsToJson(value: SetExpressionArguments): string {
        return JSON.stringify(uncast(value, r("SetExpressionArguments")), null, 2);
    }

    export function toSetExpressionResponse(json: string): SetExpressionResponse {
        return cast(JSON.parse(json), r("SetExpressionResponse"));
    }

    export function setExpressionResponseToJson(value: SetExpressionResponse): string {
        return JSON.stringify(uncast(value, r("SetExpressionResponse")), null, 2);
    }

    export function toStepInTargetsRequest(json: string): StepInTargetsRequest {
        return cast(JSON.parse(json), r("StepInTargetsRequest"));
    }

    export function stepInTargetsRequestToJson(value: StepInTargetsRequest): string {
        return JSON.stringify(uncast(value, r("StepInTargetsRequest")), null, 2);
    }

    export function toStepInTargetsArguments(json: string): StepInTargetsArguments {
        return cast(JSON.parse(json), r("StepInTargetsArguments"));
    }

    export function stepInTargetsArgumentsToJson(value: StepInTargetsArguments): string {
        return JSON.stringify(uncast(value, r("StepInTargetsArguments")), null, 2);
    }

    export function toStepInTargetsResponse(json: string): StepInTargetsResponse {
        return cast(JSON.parse(json), r("StepInTargetsResponse"));
    }

    export function stepInTargetsResponseToJson(value: StepInTargetsResponse): string {
        return JSON.stringify(uncast(value, r("StepInTargetsResponse")), null, 2);
    }

    export function toGotoTargetsRequest(json: string): GotoTargetsRequest {
        return cast(JSON.parse(json), r("GotoTargetsRequest"));
    }

    export function gotoTargetsRequestToJson(value: GotoTargetsRequest): string {
        return JSON.stringify(uncast(value, r("GotoTargetsRequest")), null, 2);
    }

    export function toGotoTargetsArguments(json: string): GotoTargetsArguments {
        return cast(JSON.parse(json), r("GotoTargetsArguments"));
    }

    export function gotoTargetsArgumentsToJson(value: GotoTargetsArguments): string {
        return JSON.stringify(uncast(value, r("GotoTargetsArguments")), null, 2);
    }

    export function toGotoTargetsResponse(json: string): GotoTargetsResponse {
        return cast(JSON.parse(json), r("GotoTargetsResponse"));
    }

    export function gotoTargetsResponseToJson(value: GotoTargetsResponse): string {
        return JSON.stringify(uncast(value, r("GotoTargetsResponse")), null, 2);
    }

    export function toCompletionsRequest(json: string): CompletionsRequest {
        return cast(JSON.parse(json), r("CompletionsRequest"));
    }

    export function completionsRequestToJson(value: CompletionsRequest): string {
        return JSON.stringify(uncast(value, r("CompletionsRequest")), null, 2);
    }

    export function toCompletionsArguments(json: string): CompletionsArguments {
        return cast(JSON.parse(json), r("CompletionsArguments"));
    }

    export function completionsArgumentsToJson(value: CompletionsArguments): string {
        return JSON.stringify(uncast(value, r("CompletionsArguments")), null, 2);
    }

    export function toCompletionsResponse(json: string): CompletionsResponse {
        return cast(JSON.parse(json), r("CompletionsResponse"));
    }

    export function completionsResponseToJson(value: CompletionsResponse): string {
        return JSON.stringify(uncast(value, r("CompletionsResponse")), null, 2);
    }

    export function toExceptionInfoRequest(json: string): ExceptionInfoRequest {
        return cast(JSON.parse(json), r("ExceptionInfoRequest"));
    }

    export function exceptionInfoRequestToJson(value: ExceptionInfoRequest): string {
        return JSON.stringify(uncast(value, r("ExceptionInfoRequest")), null, 2);
    }

    export function toExceptionInfoArguments(json: string): ExceptionInfoArguments {
        return cast(JSON.parse(json), r("ExceptionInfoArguments"));
    }

    export function exceptionInfoArgumentsToJson(value: ExceptionInfoArguments): string {
        return JSON.stringify(uncast(value, r("ExceptionInfoArguments")), null, 2);
    }

    export function toExceptionInfoResponse(json: string): ExceptionInfoResponse {
        return cast(JSON.parse(json), r("ExceptionInfoResponse"));
    }

    export function exceptionInfoResponseToJson(value: ExceptionInfoResponse): string {
        return JSON.stringify(uncast(value, r("ExceptionInfoResponse")), null, 2);
    }

    export function toCapabilities(json: string): Capabilities {
        return cast(JSON.parse(json), r("Capabilities"));
    }

    export function capabilitiesToJson(value: Capabilities): string {
        return JSON.stringify(uncast(value, r("Capabilities")), null, 2);
    }

    export function toExceptionBreakpointsFilter(json: string): ExceptionBreakpointsFilter {
        return cast(JSON.parse(json), r("ExceptionBreakpointsFilter"));
    }

    export function exceptionBreakpointsFilterToJson(value: ExceptionBreakpointsFilter): string {
        return JSON.stringify(uncast(value, r("ExceptionBreakpointsFilter")), null, 2);
    }

    export function toMessage(json: string): Message {
        return cast(JSON.parse(json), r("Message"));
    }

    export function messageToJson(value: Message): string {
        return JSON.stringify(uncast(value, r("Message")), null, 2);
    }

    export function toModule(json: string): Module {
        return cast(JSON.parse(json), r("Module"));
    }

    export function moduleToJson(value: Module): string {
        return JSON.stringify(uncast(value, r("Module")), null, 2);
    }

    export function toColumnDescriptor(json: string): ColumnDescriptor {
        return cast(JSON.parse(json), r("ColumnDescriptor"));
    }

    export function columnDescriptorToJson(value: ColumnDescriptor): string {
        return JSON.stringify(uncast(value, r("ColumnDescriptor")), null, 2);
    }

    export function toModulesViewDescriptor(json: string): ModulesViewDescriptor {
        return cast(JSON.parse(json), r("ModulesViewDescriptor"));
    }

    export function modulesViewDescriptorToJson(value: ModulesViewDescriptor): string {
        return JSON.stringify(uncast(value, r("ModulesViewDescriptor")), null, 2);
    }

    export function toThread(json: string): Thread {
        return cast(JSON.parse(json), r("Thread"));
    }

    export function threadToJson(value: Thread): string {
        return JSON.stringify(uncast(value, r("Thread")), null, 2);
    }

    export function toSource(json: string): Source {
        return cast(JSON.parse(json), r("Source"));
    }

    export function sourceToJson(value: Source): string {
        return JSON.stringify(uncast(value, r("Source")), null, 2);
    }

    export function toStackFrame(json: string): StackFrame {
        return cast(JSON.parse(json), r("StackFrame"));
    }

    export function stackFrameToJson(value: StackFrame): string {
        return JSON.stringify(uncast(value, r("StackFrame")), null, 2);
    }

    export function toScope(json: string): Scope {
        return cast(JSON.parse(json), r("Scope"));
    }

    export function scopeToJson(value: Scope): string {
        return JSON.stringify(uncast(value, r("Scope")), null, 2);
    }

    export function toVariable(json: string): Variable {
        return cast(JSON.parse(json), r("Variable"));
    }

    export function variableToJson(value: Variable): string {
        return JSON.stringify(uncast(value, r("Variable")), null, 2);
    }

    export function toVariablePresentationHint(json: string): VariablePresentationHint {
        return cast(JSON.parse(json), r("VariablePresentationHint"));
    }

    export function variablePresentationHintToJson(value: VariablePresentationHint): string {
        return JSON.stringify(uncast(value, r("VariablePresentationHint")), null, 2);
    }

    export function toSourceBreakpoint(json: string): SourceBreakpoint {
        return cast(JSON.parse(json), r("SourceBreakpoint"));
    }

    export function sourceBreakpointToJson(value: SourceBreakpoint): string {
        return JSON.stringify(uncast(value, r("SourceBreakpoint")), null, 2);
    }

    export function toFunctionBreakpoint(json: string): FunctionBreakpoint {
        return cast(JSON.parse(json), r("FunctionBreakpoint"));
    }

    export function functionBreakpointToJson(value: FunctionBreakpoint): string {
        return JSON.stringify(uncast(value, r("FunctionBreakpoint")), null, 2);
    }

    export function toBreakpoint(json: string): Breakpoint {
        return cast(JSON.parse(json), r("Breakpoint"));
    }

    export function breakpointToJson(value: Breakpoint): string {
        return JSON.stringify(uncast(value, r("Breakpoint")), null, 2);
    }

    export function toStepInTarget(json: string): StepInTarget {
        return cast(JSON.parse(json), r("StepInTarget"));
    }

    export function stepInTargetToJson(value: StepInTarget): string {
        return JSON.stringify(uncast(value, r("StepInTarget")), null, 2);
    }

    export function toGotoTarget(json: string): GotoTarget {
        return cast(JSON.parse(json), r("GotoTarget"));
    }

    export function gotoTargetToJson(value: GotoTarget): string {
        return JSON.stringify(uncast(value, r("GotoTarget")), null, 2);
    }

    export function toCompletionItem(json: string): CompletionItem {
        return cast(JSON.parse(json), r("CompletionItem"));
    }

    export function completionItemToJson(value: CompletionItem): string {
        return JSON.stringify(uncast(value, r("CompletionItem")), null, 2);
    }

    export function toCompletionItemType(json: string): CompletionItemType {
        return cast(JSON.parse(json), r("CompletionItemType"));
    }

    export function completionItemTypeToJson(value: CompletionItemType): string {
        return JSON.stringify(uncast(value, r("CompletionItemType")), null, 2);
    }

    export function toChecksumAlgorithm(json: string): ChecksumAlgorithm {
        return cast(JSON.parse(json), r("ChecksumAlgorithm"));
    }

    export function checksumAlgorithmToJson(value: ChecksumAlgorithm): string {
        return JSON.stringify(uncast(value, r("ChecksumAlgorithm")), null, 2);
    }

    export function toChecksum(json: string): Checksum {
        return cast(JSON.parse(json), r("Checksum"));
    }

    export function checksumToJson(value: Checksum): string {
        return JSON.stringify(uncast(value, r("Checksum")), null, 2);
    }

    export function toValueFormat(json: string): ValueFormat {
        return cast(JSON.parse(json), r("ValueFormat"));
    }

    export function valueFormatToJson(value: ValueFormat): string {
        return JSON.stringify(uncast(value, r("ValueFormat")), null, 2);
    }

    export function toStackFrameFormat(json: string): StackFrameFormat {
        return cast(JSON.parse(json), r("StackFrameFormat"));
    }

    export function stackFrameFormatToJson(value: StackFrameFormat): string {
        return JSON.stringify(uncast(value, r("StackFrameFormat")), null, 2);
    }

    export function toExceptionOptions(json: string): ExceptionOptions {
        return cast(JSON.parse(json), r("ExceptionOptions"));
    }

    export function exceptionOptionsToJson(value: ExceptionOptions): string {
        return JSON.stringify(uncast(value, r("ExceptionOptions")), null, 2);
    }

    export function toExceptionBreakMode(json: string): ExceptionBreakMode {
        return cast(JSON.parse(json), r("ExceptionBreakMode"));
    }

    export function exceptionBreakModeToJson(value: ExceptionBreakMode): string {
        return JSON.stringify(uncast(value, r("ExceptionBreakMode")), null, 2);
    }

    export function toExceptionPathSegment(json: string): ExceptionPathSegment {
        return cast(JSON.parse(json), r("ExceptionPathSegment"));
    }

    export function exceptionPathSegmentToJson(value: ExceptionPathSegment): string {
        return JSON.stringify(uncast(value, r("ExceptionPathSegment")), null, 2);
    }

    export function toExceptionDetails(json: string): ExceptionDetails {
        return cast(JSON.parse(json), r("ExceptionDetails"));
    }

    export function exceptionDetailsToJson(value: ExceptionDetails): string {
        return JSON.stringify(uncast(value, r("ExceptionDetails")), null, 2);
    }

    function invalidValue(typ: any, val: any): never {
        throw Error(`Invalid value ${JSON.stringify(val)} for type ${JSON.stringify(typ)}`);
    }

    function jsonToJSProps(typ: any): any {
        if (typ.jsonToJS === undefined) {
            var map: any = {};
            typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ });
            typ.jsonToJS = map;
        }
        return typ.jsonToJS;
    }

    function jsToJSONProps(typ: any): any {
        if (typ.jsToJSON === undefined) {
            var map: any = {};
            typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ });
            typ.jsToJSON = map;
        }
        return typ.jsToJSON;
    }

    function transform(val: any, typ: any, getProps: any): any {
        function transformPrimitive(typ: string, val: any): any {
            if (typeof typ === typeof val) return val;
            return invalidValue(typ, val);
        }

        function transformUnion(typs: any[], val: any): any {
            // val must validate against one typ in typs
            var l = typs.length;
            for (var i = 0; i < l; i++) {
                var typ = typs[i];
                try {
                    return transform(val, typ, getProps);
                } catch (_) {}
            }
            return invalidValue(typs, val);
        }

        function transformEnum(cases: string[], val: any): any {
            if (cases.indexOf(val) !== -1) return val;
            return invalidValue(cases, val);
        }

        function transformArray(typ: any, val: any): any {
            // val must be an array with no invalid elements
            if (!Array.isArray(val)) return invalidValue("array", val);
            return val.map(el => transform(el, typ, getProps));
        }

        function transformObject(props: { [k: string]: any }, additional: any, val: any): any {
            if (val === null || typeof val !== "object" || Array.isArray(val)) {
                return invalidValue("object", val);
            }
            var result: any = {};
            Object.getOwnPropertyNames(props).forEach(key => {
                const prop = props[key];
                const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
                result[prop.key] = transform(v, prop.typ, getProps);
            });
            Object.getOwnPropertyNames(val).forEach(key => {
                if (!Object.prototype.hasOwnProperty.call(props, key)) {
                    result[key] = transform(val[key], additional, getProps);
                }
            });
            return result;
        }

        if (typ === "any") return val;
        if (typ === null) {
            if (val === null) return val;
            return invalidValue(typ, val);
        }
        if (typ === false) return invalidValue(typ, val);
        while (typeof typ === "object" && typ.ref !== undefined) {
            typ = typeMap[typ.ref];
        }
        if (Array.isArray(typ)) return transformEnum(typ, val);
        if (typeof typ === "object") {
            return typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
                : typ.hasOwnProperty("arrayItems")    ? transformArray(typ.arrayItems, val)
                : typ.hasOwnProperty("props")         ? transformObject(getProps(typ), typ.additional, val)
                : invalidValue(typ, val);
        }
        return transformPrimitive(typ, val);
    }

    function cast<T>(val: any, typ: any): T {
        return transform(val, typ, jsonToJSProps);
    }

    function uncast<T>(val: T, typ: any): any {
        return transform(val, typ, jsToJSONProps);
    }

    function a(typ: any) {
        return { arrayItems: typ };
    }

    function u(...typs: any[]) {
        return { unionMembers: typs };
    }

    function o(props: any[], additional: any) {
        return { props, additional };
    }

    function m(additional: any) {
        return { props: [], additional };
    }

    function r(name: string) {
        return { ref: name };
    }

    const typeMap: any = {
        "ProtocolMessage": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: "" },
        ], "any"),
        "Request": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
        ], "any"),
        "Event": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("FluffyArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "event", js: "event", typ: "" },
        ], "any"),
        "Response": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "ErrorResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("ErrorResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "ErrorResponseBody": o([
            { json: "error", js: "error", typ: u(undefined, r("Message")) },
        ], "any"),
        "Message": o([
            { json: "format", js: "format", typ: "" },
            { json: "id", js: "id", typ: 0 },
            { json: "sendTelemetry", js: "sendTelemetry", typ: u(undefined, true) },
            { json: "showUser", js: "showUser", typ: u(undefined, true) },
            { json: "url", js: "url", typ: u(undefined, "") },
            { json: "urlLabel", js: "urlLabel", typ: u(undefined, "") },
            { json: "variables", js: "variables", typ: u(undefined, m("")) },
        ], "any"),
        "InitializedEvent": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("FluffyArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "event", js: "event", typ: r("StickyArakGroundhog") },
        ], "any"),
        "StoppedEvent": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("FluffyArakGroundhog") },
            { json: "body", js: "body", typ: r("StoppedEventBody") },
            { json: "event", js: "event", typ: r("IndigoArakGroundhog") },
        ], "any"),
        "StoppedEventBody": o([
            { json: "allThreadsStopped", js: "allThreadsStopped", typ: u(undefined, true) },
            { json: "description", js: "description", typ: u(undefined, "") },
            { json: "preserveFocusHint", js: "preserveFocusHint", typ: u(undefined, true) },
            { json: "reason", js: "reason", typ: "" },
            { json: "text", js: "text", typ: u(undefined, "") },
            { json: "threadId", js: "threadId", typ: u(undefined, 0) },
        ], "any"),
        "ContinuedEvent": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("FluffyArakGroundhog") },
            { json: "body", js: "body", typ: r("ContinuedEventBody") },
            { json: "event", js: "event", typ: r("IndecentArakGroundhog") },
        ], "any"),
        "ContinuedEventBody": o([
            { json: "allThreadsContinued", js: "allThreadsContinued", typ: u(undefined, true) },
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "ExitedEvent": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("FluffyArakGroundhog") },
            { json: "body", js: "body", typ: r("ExitedEventBody") },
            { json: "event", js: "event", typ: r("HilariousArakGroundhog") },
        ], "any"),
        "ExitedEventBody": o([
            { json: "exitCode", js: "exitCode", typ: 0 },
        ], "any"),
        "TerminatedEvent": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("FluffyArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, r("TerminatedEventBody")) },
            { json: "event", js: "event", typ: r("AmbitiousArakGroundhog") },
        ], "any"),
        "TerminatedEventBody": o([
            { json: "restart", js: "restart", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
        ], "any"),
        "ThreadEvent": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("FluffyArakGroundhog") },
            { json: "body", js: "body", typ: r("ThreadEventBody") },
            { json: "event", js: "event", typ: r("CunningArakGroundhog") },
        ], "any"),
        "ThreadEventBody": o([
            { json: "reason", js: "reason", typ: "" },
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "OutputEvent": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("FluffyArakGroundhog") },
            { json: "body", js: "body", typ: r("OutputEventBody") },
            { json: "event", js: "event", typ: r("MagentaArakGroundhog") },
        ], "any"),
        "OutputEventBody": o([
            { json: "category", js: "category", typ: u(undefined, "") },
            { json: "column", js: "column", typ: u(undefined, 0) },
            { json: "data", js: "data", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "line", js: "line", typ: u(undefined, 0) },
            { json: "output", js: "output", typ: "" },
            { json: "source", js: "source", typ: u(undefined, r("Source")) },
            { json: "variablesReference", js: "variablesReference", typ: u(undefined, 3.14) },
        ], "any"),
        "Source": o([
            { json: "adapterData", js: "adapterData", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "checksums", js: "checksums", typ: u(undefined, a(r("Checksum"))) },
            { json: "name", js: "name", typ: u(undefined, "") },
            { json: "origin", js: "origin", typ: u(undefined, "") },
            { json: "path", js: "path", typ: u(undefined, "") },
            { json: "presentationHint", js: "presentationHint", typ: u(undefined, r("SourcePresentationHint")) },
            { json: "sourceReference", js: "sourceReference", typ: u(undefined, 3.14) },
            { json: "sources", js: "sources", typ: u(undefined, a(r("Source"))) },
        ], "any"),
        "Checksum": o([
            { json: "algorithm", js: "algorithm", typ: r("ChecksumAlgorithm") },
            { json: "checksum", js: "checksum", typ: "" },
        ], "any"),
        "BreakpointEvent": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("FluffyArakGroundhog") },
            { json: "body", js: "body", typ: r("BreakpointEventBody") },
            { json: "event", js: "event", typ: r("FriskyArakGroundhog") },
        ], "any"),
        "BreakpointEventBody": o([
            { json: "breakpoint", js: "breakpoint", typ: r("Breakpoint") },
            { json: "reason", js: "reason", typ: "" },
        ], "any"),
        "Breakpoint": o([
            { json: "column", js: "column", typ: u(undefined, 0) },
            { json: "endColumn", js: "endColumn", typ: u(undefined, 0) },
            { json: "endLine", js: "endLine", typ: u(undefined, 0) },
            { json: "id", js: "id", typ: u(undefined, 0) },
            { json: "line", js: "line", typ: u(undefined, 0) },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "source", js: "source", typ: u(undefined, r("Source")) },
            { json: "verified", js: "verified", typ: true },
        ], "any"),
        "ModuleEvent": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("FluffyArakGroundhog") },
            { json: "body", js: "body", typ: r("ModuleEventBody") },
            { json: "event", js: "event", typ: r("MischievousArakGroundhog") },
        ], "any"),
        "ModuleEventBody": o([
            { json: "module", js: "module", typ: r("Module") },
            { json: "reason", js: "reason", typ: r("Reason") },
        ], "any"),
        "Module": o([
            { json: "addressRange", js: "addressRange", typ: u(undefined, "") },
            { json: "dateTimeStamp", js: "dateTimeStamp", typ: u(undefined, "") },
            { json: "id", js: "id", typ: u(0, "") },
            { json: "isOptimized", js: "isOptimized", typ: u(undefined, true) },
            { json: "isUserCode", js: "isUserCode", typ: u(undefined, true) },
            { json: "name", js: "name", typ: "" },
            { json: "path", js: "path", typ: u(undefined, "") },
            { json: "symbolFilePath", js: "symbolFilePath", typ: u(undefined, "") },
            { json: "symbolStatus", js: "symbolStatus", typ: u(undefined, "") },
            { json: "version", js: "version", typ: u(undefined, "") },
        ], "any"),
        "LoadedSourceEvent": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("FluffyArakGroundhog") },
            { json: "body", js: "body", typ: r("LoadedSourceEventBody") },
            { json: "event", js: "event", typ: r("BraggadociousArakGroundhog") },
        ], "any"),
        "LoadedSourceEventBody": o([
            { json: "reason", js: "reason", typ: r("Reason") },
            { json: "source", js: "source", typ: r("Source") },
        ], "any"),
        "ProcessEvent": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("FluffyArakGroundhog") },
            { json: "body", js: "body", typ: r("ProcessEventBody") },
            { json: "event", js: "event", typ: r("ArakGroundhog1") },
        ], "any"),
        "ProcessEventBody": o([
            { json: "isLocalProcess", js: "isLocalProcess", typ: u(undefined, true) },
            { json: "name", js: "name", typ: "" },
            { json: "startMethod", js: "startMethod", typ: u(undefined, r("StartMethod")) },
            { json: "systemProcessId", js: "systemProcessId", typ: u(undefined, 0) },
        ], "any"),
        "CapabilitiesEvent": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("FluffyArakGroundhog") },
            { json: "body", js: "body", typ: r("CapabilitiesEventBody") },
            { json: "event", js: "event", typ: r("ArakGroundhog2") },
        ], "any"),
        "CapabilitiesEventBody": o([
            { json: "capabilities", js: "capabilities", typ: r("Capabilities") },
        ], "any"),
        "Capabilities": o([
            { json: "additionalModuleColumns", js: "additionalModuleColumns", typ: u(undefined, a(r("ColumnDescriptor"))) },
            { json: "exceptionBreakpointFilters", js: "exceptionBreakpointFilters", typ: u(undefined, a(r("ExceptionBreakpointsFilter"))) },
            { json: "supportedChecksumAlgorithms", js: "supportedChecksumAlgorithms", typ: u(undefined, a(r("ChecksumAlgorithm"))) },
            { json: "supportsCompletionsRequest", js: "supportsCompletionsRequest", typ: u(undefined, true) },
            { json: "supportsConditionalBreakpoints", js: "supportsConditionalBreakpoints", typ: u(undefined, true) },
            { json: "supportsConfigurationDoneRequest", js: "supportsConfigurationDoneRequest", typ: u(undefined, true) },
            { json: "supportsDelayedStackTraceLoading", js: "supportsDelayedStackTraceLoading", typ: u(undefined, true) },
            { json: "supportsEvaluateForHovers", js: "supportsEvaluateForHovers", typ: u(undefined, true) },
            { json: "supportsExceptionInfoRequest", js: "supportsExceptionInfoRequest", typ: u(undefined, true) },
            { json: "supportsExceptionOptions", js: "supportsExceptionOptions", typ: u(undefined, true) },
            { json: "supportsFunctionBreakpoints", js: "supportsFunctionBreakpoints", typ: u(undefined, true) },
            { json: "supportsGotoTargetsRequest", js: "supportsGotoTargetsRequest", typ: u(undefined, true) },
            { json: "supportsHitConditionalBreakpoints", js: "supportsHitConditionalBreakpoints", typ: u(undefined, true) },
            { json: "supportsLoadedSourcesRequest", js: "supportsLoadedSourcesRequest", typ: u(undefined, true) },
            { json: "supportsLogPoints", js: "supportsLogPoints", typ: u(undefined, true) },
            { json: "supportsModulesRequest", js: "supportsModulesRequest", typ: u(undefined, true) },
            { json: "supportsRestartFrame", js: "supportsRestartFrame", typ: u(undefined, true) },
            { json: "supportsRestartRequest", js: "supportsRestartRequest", typ: u(undefined, true) },
            { json: "supportsSetExpression", js: "supportsSetExpression", typ: u(undefined, true) },
            { json: "supportsSetVariable", js: "supportsSetVariable", typ: u(undefined, true) },
            { json: "supportsStepBack", js: "supportsStepBack", typ: u(undefined, true) },
            { json: "supportsStepInTargetsRequest", js: "supportsStepInTargetsRequest", typ: u(undefined, true) },
            { json: "supportsTerminateRequest", js: "supportsTerminateRequest", typ: u(undefined, true) },
            { json: "supportsTerminateThreadsRequest", js: "supportsTerminateThreadsRequest", typ: u(undefined, true) },
            { json: "supportsValueFormattingOptions", js: "supportsValueFormattingOptions", typ: u(undefined, true) },
            { json: "supportTerminateDebuggee", js: "supportTerminateDebuggee", typ: u(undefined, true) },
        ], "any"),
        "ColumnDescriptor": o([
            { json: "attributeName", js: "attributeName", typ: "" },
            { json: "format", js: "format", typ: u(undefined, "") },
            { json: "label", js: "label", typ: "" },
            { json: "type", js: "type", typ: u(undefined, r("Type")) },
            { json: "width", js: "width", typ: u(undefined, 0) },
        ], "any"),
        "ExceptionBreakpointsFilter": o([
            { json: "default", js: "default", typ: u(undefined, true) },
            { json: "filter", js: "filter", typ: "" },
            { json: "label", js: "label", typ: "" },
        ], "any"),
        "RunInTerminalRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("ArgumentsObject") },
            { json: "command", js: "command", typ: r("ArakGroundhog3") },
        ], "any"),
        "ArgumentsObject": o([
            { json: "args", js: "args", typ: a("") },
            { json: "cwd", js: "cwd", typ: "" },
            { json: "env", js: "env", typ: u(undefined, m(u(null, ""))) },
            { json: "kind", js: "kind", typ: u(undefined, r("Kind")) },
            { json: "title", js: "title", typ: u(undefined, "") },
        ], "any"),
        "RunInTerminalRequestArguments": o([
            { json: "args", js: "args", typ: a("") },
            { json: "cwd", js: "cwd", typ: "" },
            { json: "env", js: "env", typ: u(undefined, m(u(null, ""))) },
            { json: "kind", js: "kind", typ: u(undefined, r("Kind")) },
            { json: "title", js: "title", typ: u(undefined, "") },
        ], "any"),
        "RunInTerminalResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("RunInTerminalResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "RunInTerminalResponseBody": o([
            { json: "processId", js: "processId", typ: u(undefined, 3.14) },
            { json: "shellProcessId", js: "shellProcessId", typ: u(undefined, 3.14) },
        ], "any"),
        "InitializeRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("RequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog4") },
        ], "any"),
        "RequestArguments": o([
            { json: "adapterID", js: "adapterID", typ: "" },
            { json: "clientID", js: "clientID", typ: u(undefined, "") },
            { json: "clientName", js: "clientName", typ: u(undefined, "") },
            { json: "columnsStartAt1", js: "columnsStartAt1", typ: u(undefined, true) },
            { json: "linesStartAt1", js: "linesStartAt1", typ: u(undefined, true) },
            { json: "locale", js: "locale", typ: u(undefined, "") },
            { json: "pathFormat", js: "pathFormat", typ: u(undefined, "") },
            { json: "supportsRunInTerminalRequest", js: "supportsRunInTerminalRequest", typ: u(undefined, true) },
            { json: "supportsVariablePaging", js: "supportsVariablePaging", typ: u(undefined, true) },
            { json: "supportsVariableType", js: "supportsVariableType", typ: u(undefined, true) },
        ], "any"),
        "InitializeRequestArguments": o([
            { json: "adapterID", js: "adapterID", typ: "" },
            { json: "clientID", js: "clientID", typ: u(undefined, "") },
            { json: "clientName", js: "clientName", typ: u(undefined, "") },
            { json: "columnsStartAt1", js: "columnsStartAt1", typ: u(undefined, true) },
            { json: "linesStartAt1", js: "linesStartAt1", typ: u(undefined, true) },
            { json: "locale", js: "locale", typ: u(undefined, "") },
            { json: "pathFormat", js: "pathFormat", typ: u(undefined, "") },
            { json: "supportsRunInTerminalRequest", js: "supportsRunInTerminalRequest", typ: u(undefined, true) },
            { json: "supportsVariablePaging", js: "supportsVariablePaging", typ: u(undefined, true) },
            { json: "supportsVariableType", js: "supportsVariableType", typ: u(undefined, true) },
        ], "any"),
        "InitializeResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, r("Types")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "Types": o([
            { json: "additionalModuleColumns", js: "additionalModuleColumns", typ: u(undefined, a(r("ColumnDescriptor"))) },
            { json: "exceptionBreakpointFilters", js: "exceptionBreakpointFilters", typ: u(undefined, a(r("ExceptionBreakpointsFilter"))) },
            { json: "supportedChecksumAlgorithms", js: "supportedChecksumAlgorithms", typ: u(undefined, a(r("ChecksumAlgorithm"))) },
            { json: "supportsCompletionsRequest", js: "supportsCompletionsRequest", typ: u(undefined, true) },
            { json: "supportsConditionalBreakpoints", js: "supportsConditionalBreakpoints", typ: u(undefined, true) },
            { json: "supportsConfigurationDoneRequest", js: "supportsConfigurationDoneRequest", typ: u(undefined, true) },
            { json: "supportsDelayedStackTraceLoading", js: "supportsDelayedStackTraceLoading", typ: u(undefined, true) },
            { json: "supportsEvaluateForHovers", js: "supportsEvaluateForHovers", typ: u(undefined, true) },
            { json: "supportsExceptionInfoRequest", js: "supportsExceptionInfoRequest", typ: u(undefined, true) },
            { json: "supportsExceptionOptions", js: "supportsExceptionOptions", typ: u(undefined, true) },
            { json: "supportsFunctionBreakpoints", js: "supportsFunctionBreakpoints", typ: u(undefined, true) },
            { json: "supportsGotoTargetsRequest", js: "supportsGotoTargetsRequest", typ: u(undefined, true) },
            { json: "supportsHitConditionalBreakpoints", js: "supportsHitConditionalBreakpoints", typ: u(undefined, true) },
            { json: "supportsLoadedSourcesRequest", js: "supportsLoadedSourcesRequest", typ: u(undefined, true) },
            { json: "supportsLogPoints", js: "supportsLogPoints", typ: u(undefined, true) },
            { json: "supportsModulesRequest", js: "supportsModulesRequest", typ: u(undefined, true) },
            { json: "supportsRestartFrame", js: "supportsRestartFrame", typ: u(undefined, true) },
            { json: "supportsRestartRequest", js: "supportsRestartRequest", typ: u(undefined, true) },
            { json: "supportsSetExpression", js: "supportsSetExpression", typ: u(undefined, true) },
            { json: "supportsSetVariable", js: "supportsSetVariable", typ: u(undefined, true) },
            { json: "supportsStepBack", js: "supportsStepBack", typ: u(undefined, true) },
            { json: "supportsStepInTargetsRequest", js: "supportsStepInTargetsRequest", typ: u(undefined, true) },
            { json: "supportsTerminateRequest", js: "supportsTerminateRequest", typ: u(undefined, true) },
            { json: "supportsTerminateThreadsRequest", js: "supportsTerminateThreadsRequest", typ: u(undefined, true) },
            { json: "supportsValueFormattingOptions", js: "supportsValueFormattingOptions", typ: u(undefined, true) },
            { json: "supportTerminateDebuggee", js: "supportTerminateDebuggee", typ: u(undefined, true) },
        ], "any"),
        "ConfigurationDoneRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: u(undefined, m("any")) },
            { json: "command", js: "command", typ: r("ArakGroundhog5") },
        ], "any"),
        "ConfigurationDoneResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "LaunchRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("LaunchRequestArgumentsObject") },
            { json: "command", js: "command", typ: r("ArakGroundhog6") },
        ], "any"),
        "LaunchRequestArgumentsObject": o([
            { json: "__restart", js: "__restart", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "noDebug", js: "noDebug", typ: u(undefined, true) },
        ], "any"),
        "LaunchRequestArguments": o([
            { json: "__restart", js: "__restart", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "noDebug", js: "noDebug", typ: u(undefined, true) },
        ], "any"),
        "LaunchResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "AttachRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("AttachRequestArgumentsObject") },
            { json: "command", js: "command", typ: r("ArakGroundhog7") },
        ], "any"),
        "AttachRequestArgumentsObject": o([
            { json: "__restart", js: "__restart", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
        ], "any"),
        "AttachRequestArguments": o([
            { json: "__restart", js: "__restart", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
        ], "any"),
        "AttachResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "RestartRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: u(undefined, m("any")) },
            { json: "command", js: "command", typ: r("ArakGroundhog8") },
        ], "any"),
        "RestartResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "DisconnectRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: u(undefined, r("DisconnectRequestArguments")) },
            { json: "command", js: "command", typ: r("ArakGroundhog9") },
        ], "any"),
        "DisconnectRequestArguments": o([
            { json: "restart", js: "restart", typ: u(undefined, true) },
            { json: "terminateDebuggee", js: "terminateDebuggee", typ: u(undefined, true) },
        ], "any"),
        "DisconnectArguments": o([
            { json: "restart", js: "restart", typ: u(undefined, true) },
            { json: "terminateDebuggee", js: "terminateDebuggee", typ: u(undefined, true) },
        ], "any"),
        "DisconnectResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "TerminateRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: u(undefined, r("TerminateRequestArguments")) },
            { json: "command", js: "command", typ: r("ArakGroundhog10") },
        ], "any"),
        "TerminateRequestArguments": o([
            { json: "restart", js: "restart", typ: u(undefined, true) },
        ], "any"),
        "TerminateArguments": o([
            { json: "restart", js: "restart", typ: u(undefined, true) },
        ], "any"),
        "TerminateResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "SetBreakpointsRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("SetBreakpointsRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog11") },
        ], "any"),
        "SetBreakpointsRequestArguments": o([
            { json: "breakpoints", js: "breakpoints", typ: u(undefined, a(r("SourceBreakpoint"))) },
            { json: "lines", js: "lines", typ: u(undefined, a(0)) },
            { json: "source", js: "source", typ: r("Source") },
            { json: "sourceModified", js: "sourceModified", typ: u(undefined, true) },
        ], "any"),
        "SourceBreakpoint": o([
            { json: "column", js: "column", typ: u(undefined, 0) },
            { json: "condition", js: "condition", typ: u(undefined, "") },
            { json: "hitCondition", js: "hitCondition", typ: u(undefined, "") },
            { json: "line", js: "line", typ: 0 },
            { json: "logMessage", js: "logMessage", typ: u(undefined, "") },
        ], "any"),
        "SetBreakpointsArguments": o([
            { json: "breakpoints", js: "breakpoints", typ: u(undefined, a(r("SourceBreakpoint"))) },
            { json: "lines", js: "lines", typ: u(undefined, a(0)) },
            { json: "source", js: "source", typ: r("Source") },
            { json: "sourceModified", js: "sourceModified", typ: u(undefined, true) },
        ], "any"),
        "SetBreakpointsResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("SetBreakpointsResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "SetBreakpointsResponseBody": o([
            { json: "breakpoints", js: "breakpoints", typ: a(r("Breakpoint")) },
        ], "any"),
        "SetFunctionBreakpointsRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("SetFunctionBreakpointsRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog12") },
        ], "any"),
        "SetFunctionBreakpointsRequestArguments": o([
            { json: "breakpoints", js: "breakpoints", typ: a(r("FunctionBreakpoint")) },
        ], "any"),
        "FunctionBreakpoint": o([
            { json: "condition", js: "condition", typ: u(undefined, "") },
            { json: "hitCondition", js: "hitCondition", typ: u(undefined, "") },
            { json: "name", js: "name", typ: "" },
        ], "any"),
        "SetFunctionBreakpointsArguments": o([
            { json: "breakpoints", js: "breakpoints", typ: a(r("FunctionBreakpoint")) },
        ], "any"),
        "SetFunctionBreakpointsResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("SetFunctionBreakpointsResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "SetFunctionBreakpointsResponseBody": o([
            { json: "breakpoints", js: "breakpoints", typ: a(r("Breakpoint")) },
        ], "any"),
        "SetExceptionBreakpointsRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("SetExceptionBreakpointsRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog13") },
        ], "any"),
        "SetExceptionBreakpointsRequestArguments": o([
            { json: "exceptionOptions", js: "exceptionOptions", typ: u(undefined, a(r("ExceptionOptions"))) },
            { json: "filters", js: "filters", typ: a("") },
        ], "any"),
        "ExceptionOptions": o([
            { json: "breakMode", js: "breakMode", typ: r("ExceptionBreakMode") },
            { json: "path", js: "path", typ: u(undefined, a(r("ExceptionPathSegment"))) },
        ], "any"),
        "ExceptionPathSegment": o([
            { json: "names", js: "names", typ: a("") },
            { json: "negate", js: "negate", typ: u(undefined, true) },
        ], "any"),
        "SetExceptionBreakpointsArguments": o([
            { json: "exceptionOptions", js: "exceptionOptions", typ: u(undefined, a(r("ExceptionOptions"))) },
            { json: "filters", js: "filters", typ: a("") },
        ], "any"),
        "SetExceptionBreakpointsResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "ContinueRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("ContinueRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog14") },
        ], "any"),
        "ContinueRequestArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "ContinueArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "ContinueResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("ContinueResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "ContinueResponseBody": o([
            { json: "allThreadsContinued", js: "allThreadsContinued", typ: u(undefined, true) },
        ], "any"),
        "NextRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("NextRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog15") },
        ], "any"),
        "NextRequestArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "NextArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "NextResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "StepInRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("StepInRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog16") },
        ], "any"),
        "StepInRequestArguments": o([
            { json: "targetId", js: "targetId", typ: u(undefined, 0) },
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "StepInArguments": o([
            { json: "targetId", js: "targetId", typ: u(undefined, 0) },
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "StepInResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "StepOutRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("StepOutRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog17") },
        ], "any"),
        "StepOutRequestArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "StepOutArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "StepOutResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "StepBackRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("StepBackRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog18") },
        ], "any"),
        "StepBackRequestArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "StepBackArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "StepBackResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "ReverseContinueRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("ReverseContinueRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog19") },
        ], "any"),
        "ReverseContinueRequestArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "ReverseContinueArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "ReverseContinueResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "RestartFrameRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("RestartFrameRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog20") },
        ], "any"),
        "RestartFrameRequestArguments": o([
            { json: "frameId", js: "frameId", typ: 0 },
        ], "any"),
        "RestartFrameArguments": o([
            { json: "frameId", js: "frameId", typ: 0 },
        ], "any"),
        "RestartFrameResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "GotoRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("GotoRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog21") },
        ], "any"),
        "GotoRequestArguments": o([
            { json: "targetId", js: "targetId", typ: 0 },
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "GotoArguments": o([
            { json: "targetId", js: "targetId", typ: 0 },
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "GotoResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "PauseRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("PauseRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog22") },
        ], "any"),
        "PauseRequestArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "PauseArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "PauseResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "StackTraceRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("StackTraceRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog23") },
        ], "any"),
        "StackTraceRequestArguments": o([
            { json: "format", js: "format", typ: u(undefined, r("StackFrameFormat")) },
            { json: "levels", js: "levels", typ: u(undefined, 0) },
            { json: "startFrame", js: "startFrame", typ: u(undefined, 0) },
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "StackFrameFormat": o([
            { json: "hex", js: "hex", typ: u(undefined, true) },
            { json: "includeAll", js: "includeAll", typ: u(undefined, true) },
            { json: "line", js: "line", typ: u(undefined, true) },
            { json: "module", js: "module", typ: u(undefined, true) },
            { json: "parameterNames", js: "parameterNames", typ: u(undefined, true) },
            { json: "parameters", js: "parameters", typ: u(undefined, true) },
            { json: "parameterTypes", js: "parameterTypes", typ: u(undefined, true) },
            { json: "parameterValues", js: "parameterValues", typ: u(undefined, true) },
        ], "any"),
        "StackTraceArguments": o([
            { json: "format", js: "format", typ: u(undefined, r("StackFrameFormat")) },
            { json: "levels", js: "levels", typ: u(undefined, 0) },
            { json: "startFrame", js: "startFrame", typ: u(undefined, 0) },
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "StackTraceResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("StackTraceResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "StackTraceResponseBody": o([
            { json: "stackFrames", js: "stackFrames", typ: a(r("StackFrame")) },
            { json: "totalFrames", js: "totalFrames", typ: u(undefined, 0) },
        ], "any"),
        "StackFrame": o([
            { json: "column", js: "column", typ: 0 },
            { json: "endColumn", js: "endColumn", typ: u(undefined, 0) },
            { json: "endLine", js: "endLine", typ: u(undefined, 0) },
            { json: "id", js: "id", typ: 0 },
            { json: "line", js: "line", typ: 0 },
            { json: "moduleId", js: "moduleId", typ: u(undefined, u(0, "")) },
            { json: "name", js: "name", typ: "" },
            { json: "presentationHint", js: "presentationHint", typ: u(undefined, r("StackFramePresentationHint")) },
            { json: "source", js: "source", typ: u(undefined, r("Source")) },
        ], "any"),
        "ScopesRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("ScopesRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog24") },
        ], "any"),
        "ScopesRequestArguments": o([
            { json: "frameId", js: "frameId", typ: 0 },
        ], "any"),
        "ScopesArguments": o([
            { json: "frameId", js: "frameId", typ: 0 },
        ], "any"),
        "ScopesResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("ScopesResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "ScopesResponseBody": o([
            { json: "scopes", js: "scopes", typ: a(r("Scope")) },
        ], "any"),
        "Scope": o([
            { json: "column", js: "column", typ: u(undefined, 0) },
            { json: "endColumn", js: "endColumn", typ: u(undefined, 0) },
            { json: "endLine", js: "endLine", typ: u(undefined, 0) },
            { json: "expensive", js: "expensive", typ: true },
            { json: "indexedVariables", js: "indexedVariables", typ: u(undefined, 0) },
            { json: "line", js: "line", typ: u(undefined, 0) },
            { json: "name", js: "name", typ: "" },
            { json: "namedVariables", js: "namedVariables", typ: u(undefined, 0) },
            { json: "source", js: "source", typ: u(undefined, r("Source")) },
            { json: "variablesReference", js: "variablesReference", typ: 0 },
        ], "any"),
        "VariablesRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("VariablesRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog25") },
        ], "any"),
        "VariablesRequestArguments": o([
            { json: "count", js: "count", typ: u(undefined, 0) },
            { json: "filter", js: "filter", typ: u(undefined, r("Filter")) },
            { json: "format", js: "format", typ: u(undefined, r("ValueFormat")) },
            { json: "start", js: "start", typ: u(undefined, 0) },
            { json: "variablesReference", js: "variablesReference", typ: 0 },
        ], "any"),
        "ValueFormat": o([
            { json: "hex", js: "hex", typ: u(undefined, true) },
        ], "any"),
        "VariablesArguments": o([
            { json: "count", js: "count", typ: u(undefined, 0) },
            { json: "filter", js: "filter", typ: u(undefined, r("Filter")) },
            { json: "format", js: "format", typ: u(undefined, r("ValueFormat")) },
            { json: "start", js: "start", typ: u(undefined, 0) },
            { json: "variablesReference", js: "variablesReference", typ: 0 },
        ], "any"),
        "VariablesResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("VariablesResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "VariablesResponseBody": o([
            { json: "variables", js: "variables", typ: a(r("Variable")) },
        ], "any"),
        "Variable": o([
            { json: "evaluateName", js: "evaluateName", typ: u(undefined, "") },
            { json: "indexedVariables", js: "indexedVariables", typ: u(undefined, 0) },
            { json: "name", js: "name", typ: "" },
            { json: "namedVariables", js: "namedVariables", typ: u(undefined, 0) },
            { json: "presentationHint", js: "presentationHint", typ: u(undefined, r("VariablePresentationHint")) },
            { json: "type", js: "type", typ: u(undefined, "") },
            { json: "value", js: "value", typ: "" },
            { json: "variablesReference", js: "variablesReference", typ: 0 },
        ], "any"),
        "VariablePresentationHint": o([
            { json: "attributes", js: "attributes", typ: u(undefined, a("")) },
            { json: "kind", js: "kind", typ: u(undefined, "") },
            { json: "visibility", js: "visibility", typ: u(undefined, "") },
        ], "any"),
        "SetVariableRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("SetVariableRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog26") },
        ], "any"),
        "SetVariableRequestArguments": o([
            { json: "format", js: "format", typ: u(undefined, r("ValueFormat")) },
            { json: "name", js: "name", typ: "" },
            { json: "value", js: "value", typ: "" },
            { json: "variablesReference", js: "variablesReference", typ: 0 },
        ], "any"),
        "SetVariableArguments": o([
            { json: "format", js: "format", typ: u(undefined, r("ValueFormat")) },
            { json: "name", js: "name", typ: "" },
            { json: "value", js: "value", typ: "" },
            { json: "variablesReference", js: "variablesReference", typ: 0 },
        ], "any"),
        "SetVariableResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("SetVariableResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "SetVariableResponseBody": o([
            { json: "indexedVariables", js: "indexedVariables", typ: u(undefined, 3.14) },
            { json: "namedVariables", js: "namedVariables", typ: u(undefined, 3.14) },
            { json: "type", js: "type", typ: u(undefined, "") },
            { json: "value", js: "value", typ: "" },
            { json: "variablesReference", js: "variablesReference", typ: u(undefined, 3.14) },
        ], "any"),
        "SourceRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("SourceRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog27") },
        ], "any"),
        "SourceRequestArguments": o([
            { json: "source", js: "source", typ: u(undefined, r("Source")) },
            { json: "sourceReference", js: "sourceReference", typ: 0 },
        ], "any"),
        "SourceArguments": o([
            { json: "source", js: "source", typ: u(undefined, r("Source")) },
            { json: "sourceReference", js: "sourceReference", typ: 0 },
        ], "any"),
        "SourceResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("SourceResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "SourceResponseBody": o([
            { json: "content", js: "content", typ: "" },
            { json: "mimeType", js: "mimeType", typ: u(undefined, "") },
        ], "any"),
        "ThreadsRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: r("ArakGroundhog28") },
        ], "any"),
        "ThreadsResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("ThreadsResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "ThreadsResponseBody": o([
            { json: "threads", js: "threads", typ: a(r("Thread")) },
        ], "any"),
        "Thread": o([
            { json: "id", js: "id", typ: 0 },
            { json: "name", js: "name", typ: "" },
        ], "any"),
        "TerminateThreadsRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("TerminateThreadsRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog29") },
        ], "any"),
        "TerminateThreadsRequestArguments": o([
            { json: "threadIds", js: "threadIds", typ: u(undefined, a(0)) },
        ], "any"),
        "TerminateThreadsArguments": o([
            { json: "threadIds", js: "threadIds", typ: u(undefined, a(0)) },
        ], "any"),
        "TerminateThreadsResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: u(undefined, u(a("any"), true, 3.14, 0, m("any"), null, "")) },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "ModulesRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("ModulesRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog30") },
        ], "any"),
        "ModulesRequestArguments": o([
            { json: "moduleCount", js: "moduleCount", typ: u(undefined, 0) },
            { json: "startModule", js: "startModule", typ: u(undefined, 0) },
        ], "any"),
        "ModulesArguments": o([
            { json: "moduleCount", js: "moduleCount", typ: u(undefined, 0) },
            { json: "startModule", js: "startModule", typ: u(undefined, 0) },
        ], "any"),
        "ModulesResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("ModulesResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "ModulesResponseBody": o([
            { json: "modules", js: "modules", typ: a(r("Module")) },
            { json: "totalModules", js: "totalModules", typ: u(undefined, 0) },
        ], "any"),
        "LoadedSourcesRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: u(undefined, m("any")) },
            { json: "command", js: "command", typ: r("ArakGroundhog31") },
        ], "any"),
        "LoadedSourcesResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("LoadedSourcesResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "LoadedSourcesResponseBody": o([
            { json: "sources", js: "sources", typ: a(r("Source")) },
        ], "any"),
        "EvaluateRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("EvaluateRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog32") },
        ], "any"),
        "EvaluateRequestArguments": o([
            { json: "context", js: "context", typ: u(undefined, "") },
            { json: "expression", js: "expression", typ: "" },
            { json: "format", js: "format", typ: u(undefined, r("ValueFormat")) },
            { json: "frameId", js: "frameId", typ: u(undefined, 0) },
        ], "any"),
        "EvaluateArguments": o([
            { json: "context", js: "context", typ: u(undefined, "") },
            { json: "expression", js: "expression", typ: "" },
            { json: "format", js: "format", typ: u(undefined, r("ValueFormat")) },
            { json: "frameId", js: "frameId", typ: u(undefined, 0) },
        ], "any"),
        "EvaluateResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("EvaluateResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "EvaluateResponseBody": o([
            { json: "indexedVariables", js: "indexedVariables", typ: u(undefined, 3.14) },
            { json: "namedVariables", js: "namedVariables", typ: u(undefined, 3.14) },
            { json: "presentationHint", js: "presentationHint", typ: u(undefined, r("VariablePresentationHint")) },
            { json: "result", js: "result", typ: "" },
            { json: "type", js: "type", typ: u(undefined, "") },
            { json: "variablesReference", js: "variablesReference", typ: 3.14 },
        ], "any"),
        "SetExpressionRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("SetExpressionRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog33") },
        ], "any"),
        "SetExpressionRequestArguments": o([
            { json: "expression", js: "expression", typ: "" },
            { json: "format", js: "format", typ: u(undefined, r("ValueFormat")) },
            { json: "frameId", js: "frameId", typ: u(undefined, 0) },
            { json: "value", js: "value", typ: "" },
        ], "any"),
        "SetExpressionArguments": o([
            { json: "expression", js: "expression", typ: "" },
            { json: "format", js: "format", typ: u(undefined, r("ValueFormat")) },
            { json: "frameId", js: "frameId", typ: u(undefined, 0) },
            { json: "value", js: "value", typ: "" },
        ], "any"),
        "SetExpressionResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("SetExpressionResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "SetExpressionResponseBody": o([
            { json: "indexedVariables", js: "indexedVariables", typ: u(undefined, 3.14) },
            { json: "namedVariables", js: "namedVariables", typ: u(undefined, 3.14) },
            { json: "presentationHint", js: "presentationHint", typ: u(undefined, r("VariablePresentationHint")) },
            { json: "type", js: "type", typ: u(undefined, "") },
            { json: "value", js: "value", typ: "" },
            { json: "variablesReference", js: "variablesReference", typ: u(undefined, 3.14) },
        ], "any"),
        "StepInTargetsRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("StepInTargetsRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog34") },
        ], "any"),
        "StepInTargetsRequestArguments": o([
            { json: "frameId", js: "frameId", typ: 0 },
        ], "any"),
        "StepInTargetsArguments": o([
            { json: "frameId", js: "frameId", typ: 0 },
        ], "any"),
        "StepInTargetsResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("StepInTargetsResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "StepInTargetsResponseBody": o([
            { json: "targets", js: "targets", typ: a(r("StepInTarget")) },
        ], "any"),
        "StepInTarget": o([
            { json: "id", js: "id", typ: 0 },
            { json: "label", js: "label", typ: "" },
        ], "any"),
        "GotoTargetsRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("GotoTargetsRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog35") },
        ], "any"),
        "GotoTargetsRequestArguments": o([
            { json: "column", js: "column", typ: u(undefined, 0) },
            { json: "line", js: "line", typ: 0 },
            { json: "source", js: "source", typ: r("Source") },
        ], "any"),
        "GotoTargetsArguments": o([
            { json: "column", js: "column", typ: u(undefined, 0) },
            { json: "line", js: "line", typ: 0 },
            { json: "source", js: "source", typ: r("Source") },
        ], "any"),
        "GotoTargetsResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("GotoTargetsResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "GotoTargetsResponseBody": o([
            { json: "targets", js: "targets", typ: a(r("GotoTarget")) },
        ], "any"),
        "GotoTarget": o([
            { json: "column", js: "column", typ: u(undefined, 0) },
            { json: "endColumn", js: "endColumn", typ: u(undefined, 0) },
            { json: "endLine", js: "endLine", typ: u(undefined, 0) },
            { json: "id", js: "id", typ: 0 },
            { json: "label", js: "label", typ: "" },
            { json: "line", js: "line", typ: 0 },
        ], "any"),
        "CompletionsRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("CompletionsRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog36") },
        ], "any"),
        "CompletionsRequestArguments": o([
            { json: "column", js: "column", typ: 0 },
            { json: "frameId", js: "frameId", typ: u(undefined, 0) },
            { json: "line", js: "line", typ: u(undefined, 0) },
            { json: "text", js: "text", typ: "" },
        ], "any"),
        "CompletionsArguments": o([
            { json: "column", js: "column", typ: 0 },
            { json: "frameId", js: "frameId", typ: u(undefined, 0) },
            { json: "line", js: "line", typ: u(undefined, 0) },
            { json: "text", js: "text", typ: "" },
        ], "any"),
        "CompletionsResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("CompletionsResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "CompletionsResponseBody": o([
            { json: "targets", js: "targets", typ: a(r("CompletionItem")) },
        ], "any"),
        "CompletionItem": o([
            { json: "label", js: "label", typ: "" },
            { json: "length", js: "length", typ: u(undefined, 0) },
            { json: "start", js: "start", typ: u(undefined, 0) },
            { json: "text", js: "text", typ: u(undefined, "") },
            { json: "type", js: "type", typ: u(undefined, r("CompletionItemType")) },
        ], "any"),
        "ExceptionInfoRequest": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("PurpleArakGroundhog") },
            { json: "arguments", js: "arguments", typ: r("ExceptionInfoRequestArguments") },
            { json: "command", js: "command", typ: r("ArakGroundhog37") },
        ], "any"),
        "ExceptionInfoRequestArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "ExceptionInfoArguments": o([
            { json: "threadId", js: "threadId", typ: 0 },
        ], "any"),
        "ExceptionInfoResponse": o([
            { json: "seq", js: "seq", typ: 0 },
            { json: "type", js: "type", typ: r("TentacledArakGroundhog") },
            { json: "body", js: "body", typ: r("ExceptionInfoResponseBody") },
            { json: "command", js: "command", typ: "" },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "request_seq", js: "request_seq", typ: 0 },
            { json: "success", js: "success", typ: true },
        ], "any"),
        "ExceptionInfoResponseBody": o([
            { json: "breakMode", js: "breakMode", typ: r("ExceptionBreakMode") },
            { json: "description", js: "description", typ: u(undefined, "") },
            { json: "details", js: "details", typ: u(undefined, r("ExceptionDetails")) },
            { json: "exceptionId", js: "exceptionId", typ: "" },
        ], "any"),
        "ExceptionDetails": o([
            { json: "evaluateName", js: "evaluateName", typ: u(undefined, "") },
            { json: "fullTypeName", js: "fullTypeName", typ: u(undefined, "") },
            { json: "innerException", js: "innerException", typ: u(undefined, a(r("ExceptionDetails"))) },
            { json: "message", js: "message", typ: u(undefined, "") },
            { json: "stackTrace", js: "stackTrace", typ: u(undefined, "") },
            { json: "typeName", js: "typeName", typ: u(undefined, "") },
        ], "any"),
        "ModulesViewDescriptor": o([
            { json: "columns", js: "columns", typ: a(r("ColumnDescriptor")) },
        ], "any"),
        "PurpleArakGroundhog": [
            "request",
        ],
        "FluffyArakGroundhog": [
            "event",
        ],
        "TentacledArakGroundhog": [
            "response",
        ],
        "StickyArakGroundhog": [
            "initialized",
        ],
        "IndigoArakGroundhog": [
            "stopped",
        ],
        "IndecentArakGroundhog": [
            "continued",
        ],
        "HilariousArakGroundhog": [
            "exited",
        ],
        "AmbitiousArakGroundhog": [
            "terminated",
        ],
        "CunningArakGroundhog": [
            "thread",
        ],
        "ChecksumAlgorithm": [
            "MD5",
            "SHA1",
            "SHA256",
            "timestamp",
        ],
        "SourcePresentationHint": [
            "deemphasize",
            "emphasize",
            "normal",
        ],
        "MagentaArakGroundhog": [
            "output",
        ],
        "FriskyArakGroundhog": [
            "breakpoint",
        ],
        "Reason": [
            "changed",
            "new",
            "removed",
        ],
        "MischievousArakGroundhog": [
            "module",
        ],
        "BraggadociousArakGroundhog": [
            "loadedSource",
        ],
        "StartMethod": [
            "attach",
            "attachForSuspendedLaunch",
            "launch",
        ],
        "ArakGroundhog1": [
            "process",
        ],
        "Type": [
            "boolean",
            "number",
            "string",
            "unixTimestampUTC",
        ],
        "ArakGroundhog2": [
            "capabilities",
        ],
        "Kind": [
            "external",
            "integrated",
        ],
        "ArakGroundhog3": [
            "runInTerminal",
        ],
        "ArakGroundhog4": [
            "initialize",
        ],
        "ArakGroundhog5": [
            "configurationDone",
        ],
        "ArakGroundhog6": [
            "launch",
        ],
        "ArakGroundhog7": [
            "attach",
        ],
        "ArakGroundhog8": [
            "restart",
        ],
        "ArakGroundhog9": [
            "disconnect",
        ],
        "ArakGroundhog10": [
            "terminate",
        ],
        "ArakGroundhog11": [
            "setBreakpoints",
        ],
        "ArakGroundhog12": [
            "setFunctionBreakpoints",
        ],
        "ExceptionBreakMode": [
            "always",
            "never",
            "unhandled",
            "userUnhandled",
        ],
        "ArakGroundhog13": [
            "setExceptionBreakpoints",
        ],
        "ArakGroundhog14": [
            "continue",
        ],
        "ArakGroundhog15": [
            "next",
        ],
        "ArakGroundhog16": [
            "stepIn",
        ],
        "ArakGroundhog17": [
            "stepOut",
        ],
        "ArakGroundhog18": [
            "stepBack",
        ],
        "ArakGroundhog19": [
            "reverseContinue",
        ],
        "ArakGroundhog20": [
            "restartFrame",
        ],
        "ArakGroundhog21": [
            "goto",
        ],
        "ArakGroundhog22": [
            "pause",
        ],
        "ArakGroundhog23": [
            "stackTrace",
        ],
        "StackFramePresentationHint": [
            "label",
            "normal",
            "subtle",
        ],
        "ArakGroundhog24": [
            "scopes",
        ],
        "Filter": [
            "indexed",
            "named",
        ],
        "ArakGroundhog25": [
            "variables",
        ],
        "ArakGroundhog26": [
            "setVariable",
        ],
        "ArakGroundhog27": [
            "source",
        ],
        "ArakGroundhog28": [
            "threads",
        ],
        "ArakGroundhog29": [
            "terminateThreads",
        ],
        "ArakGroundhog30": [
            "modules",
        ],
        "ArakGroundhog31": [
            "loadedSources",
        ],
        "ArakGroundhog32": [
            "evaluate",
        ],
        "ArakGroundhog33": [
            "setExpression",
        ],
        "ArakGroundhog34": [
            "stepInTargets",
        ],
        "ArakGroundhog35": [
            "gotoTargets",
        ],
        "ArakGroundhog36": [
            "completions",
        ],
        "CompletionItemType": [
            "class",
            "color",
            "constructor",
            "customcolor",
            "enum",
            "field",
            "file",
            "function",
            "interface",
            "keyword",
            "method",
            "module",
            "property",
            "reference",
            "snippet",
            "text",
            "unit",
            "value",
            "variable",
        ],
        "ArakGroundhog37": [
            "exceptionInfo",
        ],
    };
}