// File has been generated automatically by Eclipse Che TypeScript DTO generator


export namespace che.git {

  export interface CheckoutRequest {
    noTrack?: boolean;
    name?: string;
    startPoint?: string;
    files?: string[];
    trackBranch?: string;
    createNew?: boolean;
  }

  export interface DiffCommitFile {
    changeType?: string;
    oldPath?: string;
    newPath?: string;
  }

  export interface LogResponse {
    commits?: Revision[];
    textLog?: string;
  }

  export interface RevertResult {
    newHead?: string;
    conflicts?:  { [key: string]: string; };
    revertedCommits?: string[];
  }

  export interface ConfigRequest {
    configEntries?:  { [key: string]: string; };
  }

  export interface PushResponse {
    commandOutput?: string;
    updates?: Map<string,string>[];
  }

  export interface RmRequest {
    cached?: boolean;
    recursively?: boolean;
    items?: string[];
  }

  export interface Branch {
    displayName?: string;
    name?: string;
    active?: boolean;
    remote?: boolean;
  }

  export interface StatusChangedEvent {
    modifiedFiles?:  { [key: string]: EditedRegion[]; };
    projectName?: string;
    status?: Status;
  }

  export interface ShowFileContentResponse {
    commits?: Revision[];
    content?: string;
  }

  export interface FileChangedEvent {
    path?: string;
    editedRegions?: EditedRegion[];
    status?: string;
  }

  export interface CloneRequest {
    password?: string;
    branchesToFetch?: string[];
    remoteUri?: string;
    workingDir?: string;
    recursive?: boolean;
    timeout?: number;
    username?: string;
    remoteName?: string;
  }

  export interface MoveRequest {
    source?: string;
    target?: string;
  }

  export interface BranchCreateRequest {
    name?: string;
    startPoint?: string;
  }

  export interface ConflictExceptionError {
    conflictingPaths?: string[];
    message?: string;
  }

  export interface GitUser {
    name?: string;
    email?: string;
  }

  export interface ResetRequest {
    filePattern?: string[];
    commit?: string;
    type?: string;
  }

  export interface PushRequest {
    password?: string;
    force?: boolean;
    refSpec?: string[];
    remote?: string;
    timeout?: number;
    username?: string;
  }

  export interface RepoInfo {
    remoteUri?: string;
  }

  export interface IndexFile {
    path?: string;
    indexed?: boolean;
  }

  export interface Commiters {
    commiters?: GitUser[];
  }

  export interface RemoteReference {
    commitId?: string;
    referenceName?: string;
  }

  export interface RevertRequest {
    commit?: string;
  }

  export interface Remote {
    name?: string;
    url?: string;
  }

  export interface PullResponse {
    commandOutput?: string;
  }

  export interface CommitRequest {
    all?: boolean;
    amend?: boolean;
    files?: string[];
    message?: string;
  }

  export interface MergeRequest {
    commit?: string;
  }

  export interface EditedRegion {
    endLine?: number;
    beginLine?: number;
    type?: string;
  }

  export interface RemoteUpdateRequest {
    removeUrl?: string[];
    removePushUrl?: string[];
    addPushUrl?: string[];
    addBranches?: boolean;
    addUrl?: string[];
    name?: string;
    branches?: string[];
  }

  export interface RebaseRequest {
    branch?: string;
    operation?: string;
  }

  export interface AddRequest {
    filePattern?: string[];
    update?: boolean;
  }

  export interface GitUrlVendorInfo {
    vendorBaseHost?: string;
    givenUrlSSH?: boolean;
    oAuthScopes?: string[];
    vendorName?: string;
  }

  export interface FetchRequest {
    password?: string;
    removeDeletedRefs?: boolean;
    refSpec?: string[];
    remote?: string;
    timeout?: number;
    username?: string;
  }

  export interface Revision {
    commitParent?: string[];
    committer?: GitUser;
    commitTime?: number;
    author?: GitUser;
    fake?: boolean;
    id?: string;
    message?: string;
    branches?: Branch[];
    diffCommitFile?: DiffCommitFile[];
    branch?: string;
  }

  export interface Tag {
    name?: string;
  }

  export interface TagCreateRequest {
    commit?: string;
    name?: string;
    force?: boolean;
    message?: string;
  }

  export interface RemoteAddRequest {
    name?: string;
    branches?: string[];
    url?: string;
  }

  export interface RepositoryInitializedEvent {
    projectName?: string;
  }

  export interface RebaseResponse {
    conflicts?: string[];
    failed?: string[];
    status?: string;
  }

  export interface RepositoryDeletedEvent {
    projectName?: string;
  }

  export interface MergeResult {
    newHead?: string;
    mergedCommits?: string[];
    conflicts?: string[];
    failed?: string[];
    mergeStatus?: string;
  }

  export interface PullRequest {
    rebase?: boolean;
    password?: string;
    refSpec?: string;
    remote?: string;
    timeout?: number;
    username?: string;
  }

  export interface Status {
    conflicting?: string[];
    removed?: string[];
    added?: string[];
    untrackedFolders?: string[];
    missing?: string[];
    branchName?: string;
    modified?: string[];
    untracked?: string[];
    refName?: string;
    clean?: boolean;
    changed?: string[];
    repositoryState?: string;
  }

  export interface Log {
    commits?: Revision[];
  }

}

export namespace che.workspace.stack {

  export interface StackComponent {
    name?: string;
    version?: string;
  }

  export interface Stack {
    components?: StackComponent[];
    creator?: string;
    scope?: string;
    name?: string;
    description?: string;
    links?: che.core.rest.Link[];
    id?: string;
    workspaceConfig?: che.workspace.WorkspaceConfig;
    tags?: string[];
  }

}

export namespace che.installer {

  export interface Installer {
    servers?:  { [key: string]: che.workspace.ServerConfig; };
    name?: string;
    description?: string;
    id?: string;
    version?: string;
    properties?:  { [key: string]: string; };
    script?: string;
    dependencies?: string[];
  }

}

export namespace che.project {

  export interface Attribute {
    name?: string;
    variable?: boolean;
    projectType?: string;
    description?: string;
    id?: string;
    value?: Value;
    required?: boolean;
  }

  export interface CopyOptions {
    name?: string;
    overWrite?: boolean;
  }

  export interface TreeElement {
    node?: ItemReference;
    children?: TreeElement[];
  }

  export interface ProjectType {
    primaryable?: boolean;
    displayName?: string;
    attributes?: Attribute[];
    mixable?: boolean;
    id?: string;
    persisted?: boolean;
    ancestors?: string[];
    parents?: string[];
  }

  export interface ServerError {
    code?: number;
    message?: string;
  }

  export interface ProjectSearchRequest {
    path?: string;
    maxItems?: number;
    name?: string;
    text?: string;
    skipCount?: number;
  }

  export interface AttributeDescriptor {
    values?: string[];
    variable?: boolean;
    name?: string;
    description?: string;
    required?: boolean;
  }

  export interface SourceEstimation {
    matched?: boolean;
    attributes?:  { [key: string]: string[]; };
    type?: string;
    resolution?: string;
  }

  export interface EditorChanges {
    offset?: number;
    removedCharCount?: number;
    projectPath?: string;
    length?: number;
    text?: string;
    fileLocation?: string;
    type?: string;
  }

  export interface SearchOccurrence {
    score?: number;
    endOffset?: number;
    startOffset?: number;
    phrase?: string;
    lineNumber?: number;
    lineContent?: string;
  }

  export interface SearchResult {
    itemReference?: ItemReference;
    searchOccurrences?: SearchOccurrence[];
  }

  export interface ProjectUpdate {
    mixins?: string[];
    visibility?: string;
    contentRoot?: string;
    recipe?: string;
    description?: string;
    attributes?:  { [key: string]: string[]; };
    type?: string;
  }

  export interface NewProjectConfig {
    path?: string;
    mixins?: string[];
    options?:  { [key: string]: string; };
    name?: string;
    description?: string;
    attributes?:  { [key: string]: string[]; };
    links?: che.core.rest.Link[];
    source?: che.workspace.SourceStorage;
    type?: string;
    problems?: che.workspace.ProjectProblem[];
  }

  export interface ProjectImporterData {
    importers?: ProjectImporterDescriptor[];
    configuration?:  { [key: string]: string; };
  }

  export interface MoveOptions {
    name?: string;
    overWrite?: boolean;
  }

  export interface ProjectSearchResponse {
    itemReferences?: SearchResult[];
    totalHits?: number;
  }

  export interface RegisteredProject {
    synced?: boolean;
    description?: string;
    source?: che.workspace.SourceStorage;
    type?: string;
    persistableAttributes?:  { [key: string]: string[]; };
    path?: string;
    mixins?: string[];
    baseFolder?: string;
    name?: string;
    detected?: boolean;
    attributes?:  { [key: string]: string[]; };
    links?: che.core.rest.Link[];
    problems?: che.workspace.ProjectProblem[];
  }

  export interface Value {
    string?: string;
    list?: string[];
    empty?: boolean;
  }

  export interface ItemReference {
    path?: string;
    projectConfig?: che.workspace.ProjectConfig;
    name?: string;
    project?: string;
    modified?: number;
    contentLength?: number;
    attributes?:  { [key: string]: string; };
    links?: che.core.rest.Link[];
    type?: string;
  }

  export interface ProjectImporterDescriptor {
    internal?: boolean;
    description?: string;
    attributes?:  { [key: string]: string; };
    id?: string;
    category?: string;
  }

  export interface GeneratorDescription {
    options?:  { [key: string]: string; };
  }

  export interface ImportProgressRecord {
    line?: string;
    num?: number;
    projectName?: string;
  }

}

export namespace che.user {

  export interface User {
    password?: string;
    aliases?: string[];
    name?: string;
    links?: che.core.rest.Link[];
    id?: string;
    email?: string;
  }

  export interface Profile {
    attributes?:  { [key: string]: string; };
    links?: che.core.rest.Link[];
    userId?: string;
    email?: string;
  }

}

export namespace che.core.notification {

  export interface EventSubscription {
    method?: string;
    scope?:  { [key: string]: string; };
  }

}

export namespace che.workspace.event {

  export interface BrokerLogEvent {
    text?: string;
    time?: string;
    runtimeId?: che.workspace.RuntimeIdentity;
  }

  export interface WorkspaceStatusEvent {
    prevStatus?: string;
    error?: string;
    status?: string;
    workspaceId?: string;
  }

  export interface InstallerLogEvent {
    installer?: string;
    stream?: string;
    text?: string;
    time?: string;
    machineName?: string;
    runtimeId?: che.workspace.RuntimeIdentity;
  }

  export interface BootstrapperStatusEvent {
    time?: string;
    error?: string;
    machineName?: string;
    runtimeId?: che.workspace.RuntimeIdentity;
    status?: string;
  }

  export interface RuntimeStatusEvent {
    prevStatus?: string;
    identity?: che.workspace.RuntimeIdentity;
    failed?: boolean;
    error?: string;
    status?: string;
  }

  export interface MachineStatusEvent {
    identity?: che.workspace.RuntimeIdentity;
    eventType?: string;
    error?: string;
    machineName?: string;
  }

  export interface ServerStatusEvent {
    identity?: che.workspace.RuntimeIdentity;
    serverUrl?: string;
    serverName?: string;
    machineName?: string;
    status?: string;
  }

  export interface BrokerStatusChangedEvent {
    tooling?: string;
    error?: string;
    runtimeId?: che.workspace.RuntimeIdentity;
    status?: string;
  }

  export interface RuntimeLogEvent {
    stream?: string;
    text?: string;
    time?: string;
    machineName?: string;
    runtimeId?: che.workspace.RuntimeIdentity;
  }

  export interface InstallerStatusEvent {
    installer?: string;
    time?: string;
    error?: string;
    machineName?: string;
    runtimeId?: che.workspace.RuntimeIdentity;
    status?: string;
  }

  export interface MachineLogEvent {
    stream?: string;
    text?: string;
    time?: string;
    machineName?: string;
    runtimeId?: che.workspace.RuntimeIdentity;
  }

}

export namespace che.core.rest {

  export interface ServiceError {
    message?: string;
  }

  export interface ExtendedError {
    errorCode?: number;
    attributes?:  { [key: string]: string; };
    message?: string;
  }

  export interface ServiceDescriptor {
    description?: string;
    links?: Link[];
    href?: string;
    version?: string;
  }

  export interface Link {
    method?: string;
    requestBody?: RequestBodyDescriptor;
    produces?: string;
    rel?: string;
    href?: string;
    parameters?: LinkParameter[];
    consumes?: string;
  }

  export interface ApiInfo {
    specificationVendor?: string;
    ideVersion?: string;
    specificationTitle?: string;
    implementationVersion?: string;
    implementationVendor?: string;
    scmRevision?: string;
    specificationVersion?: string;
  }

  export interface LinkParameter {
    valid?: string[];
    defaultValue?: string;
    name?: string;
    description?: string;
    type?: string;
    required?: boolean;
  }

  export interface RequestBodyDescriptor {
    description?: string;
  }

  export interface Hyperlinks {
    links?: Link[];
  }

}

export namespace che.git.event {

  export interface GitRepositoryDeletedEvent {
    projectPath?: string;
    projectName?: string;
  }

  export interface GitCommitEvent {
    modifiedFiles?:  { [key: string]: che.git.EditedRegion[]; };
    projectName?: string;
    status?: che.git.Status;
  }

  export interface GitCheckoutEvent {
    branchRef?: string;
    projectName?: string;
    checkoutOnly?: boolean;
    workspaceId?: string;
  }

  export interface GitRepositoryInitializedEvent {
    projectName?: string;
  }

}

export namespace che.debug.event {

  export interface DisconnectEvent {
    type?: string;
  }

  export interface DebuggerEvent {
    type?: string;
  }

  export interface BreakpointActivatedEvent {
    type?: string;
    breakpoint?: che.debug.Breakpoint;
  }

  export interface SuspendEvent {
    suspendPolicy?: string;
    location?: che.debug.Location;
    type?: string;
  }

}

export namespace che.project.service {

  export interface UpdateRequest {
    options?:  { [key: string]: string; };
    wsPath?: string;
    config?: che.workspace.ProjectConfig;
  }

  export interface ImportResponse {
    config?: che.workspace.ProjectConfig;
  }

  export interface RecognizeRequest {
    wsPath?: string;
  }

  export interface DeleteRequest {
    wsPath?: string;
  }

  export interface GetResponse {
    config?: che.workspace.ProjectConfig;
  }

  export interface ImportRequest {
    sourceStorage?: che.workspace.SourceStorage;
    wsPath?: string;
  }

  export interface DeleteResponse {
    config?: che.workspace.ProjectConfig;
  }

  export interface CreateRequest {
    options?:  { [key: string]: string; };
    wsPath?: string;
    config?: che.workspace.ProjectConfig;
  }

  export interface CreateResponse {
    config?: che.workspace.ProjectConfig;
  }

  export interface VerifyResponse {
    sourceEstimation?: che.project.SourceEstimation;
  }

  export interface VerifyRequest {
    wsPath?: string;
    type?: string;
  }

  export interface CreateBatchProjectsRequest {
    newProjectConfigs?: che.project.NewProjectConfig[];
    rewrite?: boolean;
  }

  export interface RecognizeResponse {
    sourceEstimations?: che.project.SourceEstimation[];
  }

  export interface UpdateResponse {
    config?: che.workspace.ProjectConfig;
  }

  export interface GetRequest {
    wsPath?: string;
  }

}

export namespace che.debug {

  export interface BreakpointConfiguration {
    condition?: string;
    hitCount?: number;
    suspendPolicy?: string;
    conditionEnabled?: boolean;
    hitCountEnabled?: boolean;
  }

  export interface SimpleValue {
    variables?: Variable[];
    string?: string;
  }

  export interface Method {
    name?: string;
    argumentsObj?: Variable[];
  }

  export interface Location {
    threadId?: number;
    method?: Method;
    externalResourceId?: string;
    externalResource?: boolean;
    resourceProjectPath?: string;
    lineNumber?: number;
    target?: string;
  }

  export interface Variable {
    variablePath?: VariablePath;
    primitive?: boolean;
    name?: string;
    type?: string;
    value?: SimpleValue;
  }

  export interface Field {
    isStatic?: boolean;
    variablePath?: VariablePath;
    primitive?: boolean;
    name?: string;
    isVolatile?: boolean;
    isFinal?: boolean;
    type?: string;
    isTransient?: boolean;
    value?: SimpleValue;
  }

  export interface DebugSession {
    id?: string;
    breakpoints?: Breakpoint[];
    type?: string;
    debuggerInfo?: DebuggerInfo;
  }

  export interface StackFrameDump {
    variables?: Variable[];
    location?: Location;
    fields?: Field[];
  }

  export interface ThreadState {
    groupName?: string;
    frames?: StackFrameDump[];
    name?: string;
    id?: number;
    suspended?: boolean;
    status?: string;
  }

  export interface VariablePath {
    path?: string[];
  }

  export interface DebuggerInfo {
    file?: string;
    port?: number;
    host?: string;
    name?: string;
    pid?: number;
    version?: string;
  }

  export interface Breakpoint {
    breakpointConfiguration?: BreakpointConfiguration;
    location?: Location;
    enabled?: boolean;
  }

}

export namespace che.factory {

  export interface OnAppClosed {
    actions?: IdeAction[];
  }

  export interface OnProjectsLoaded {
    actions?: IdeAction[];
  }

  export interface ButtonAttributes {
    color?: string;
    logo?: string;
    style?: string;
    counter?: boolean;
  }

  export interface IdeAction {
    id?: string;
    properties?:  { [key: string]: string; };
  }

  export interface Author {
    created?: number;
    name?: string;
    userId?: string;
    email?: string;
  }

  export interface Policies {
    referer?: string;
    create?: string;
    until?: number;
    since?: number;
  }

  export interface Ide {
    onAppLoaded?: OnAppLoaded;
    onProjectsLoaded?: OnProjectsLoaded;
    onAppClosed?: OnAppClosed;
  }

  export interface OnAppLoaded {
    actions?: IdeAction[];
  }

  export interface Button {
    attributes?: ButtonAttributes;
    type?: string;
  }

  export interface Factory {
    button?: Button;
    workspace?: che.workspace.WorkspaceConfig;
    creator?: Author;
    v?: string;
    name?: string;
    policies?: Policies;
    links?: che.core.rest.Link[];
    id?: string;
    ide?: Ide;
  }

}

export namespace che.system {

  export interface SystemServiceEvent {
    service?: string;
    type?: string;
  }

  export interface SystemStatusChangedEvent {
    prevStatus?: string;
    type?: string;
    status?: string;
  }

  export interface SystemEvent {
    type?: string;
  }

  export interface SystemServiceItemStoppedEvent {
    total?: number;
    item?: string;
    current?: number;
    service?: string;
    type?: string;
  }

  export interface SystemState {
    links?: che.core.rest.Link[];
    status?: string;
  }

}

export namespace che.workspace {

  export interface ServerConfig {
    path?: string;
    protocol?: string;
    port?: string;
    attributes?:  { [key: string]: string; };
  }

  export interface ProjectConfig {
    path?: string;
    mixins?: string[];
    name?: string;
    description?: string;
    attributes?:  { [key: string]: string[]; };
    links?: che.core.rest.Link[];
    source?: SourceStorage;
    type?: string;
    problems?: ProjectProblem[];
  }

  export interface Command {
    name?: string;
    attributes?:  { [key: string]: string; };
    commandLine?: string;
    type?: string;
  }

  export interface Environment {
    recipe?: Recipe;
    machines?:  { [key: string]: MachineConfig; };
  }

  export interface Workspace {
    temporary?: boolean;
    namespace?: string;
    runtime?: Runtime;
    attributes?:  { [key: string]: string; };
    links?:  { [key: string]: string; };
    id?: string;
    config?: WorkspaceConfig;
    status?: string;
  }

  export interface RuntimeIdentity {
    envName?: string;
    ownerId?: string;
    workspaceId?: string;
  }

  export interface Recipe {
    location?: string;
    type?: string;
    contentType?: string;
    content?: string;
  }

  export interface Server {
    attributes?:  { [key: string]: string; };
    url?: string;
    status?: string;
  }

  export interface Warning {
    code?: number;
    message?: string;
  }

  export interface Machine {
    servers?:  { [key: string]: Server; };
    attributes?:  { [key: string]: string; };
    status?: string;
  }

  export interface Volume {
    path?: string;
  }

  export interface SourceStorage {
    location?: string;
    type?: string;
    parameters?:  { [key: string]: string; };
  }

  export interface MachineConfig {
    installers?: string[];
    servers?:  { [key: string]: ServerConfig; };
    volumes?:  { [key: string]: Volume; };
    attributes?:  { [key: string]: string; };
    env?:  { [key: string]: string; };
  }

  export interface ProjectProblem {
    code?: number;
    message?: string;
  }

  export interface WorkspaceConfig {
    projects?: ProjectConfig[];
    environments?:  { [key: string]: Environment; };
    name?: string;
    description?: string;
    attributes?:  { [key: string]: string; };
    links?: che.core.rest.Link[];
    commands?: Command[];
    defaultEnv?: string;
  }

  export interface Runtime {
    owner?: string;
    warnings?: Warning[];
    machineToken?: string;
    activeEnv?: string;
    links?: che.core.rest.Link[];
    machines?:  { [key: string]: Machine; };
    commands?: Command[];
  }

}

export namespace che.project.templates {

  export interface ProjectTemplateDescriptor {
    projects?: che.workspace.ProjectConfig[];
    displayName?: string;
    projectType?: string;
    description?: string;
    source?: che.workspace.SourceStorage;
    tags?: string[];
    path?: string;
    mixins?: string[];
    options?:  { [key: string]: string; };
    name?: string;
    attributes?:  { [key: string]: string[]; };
    links?: che.core.rest.Link[];
    category?: string;
    commands?: che.workspace.Command[];
    problems?: che.workspace.ProjectProblem[];
  }

}

export namespace che.ssh {

  export interface GenerateSshPairRequest {
    service?: string;
    name?: string;
  }

  export interface SshPair {
    privateKey?: string;
    service?: string;
    name?: string;
    links?: che.core.rest.Link[];
    publicKey?: string;
  }

}

export namespace che.project.event {

  export interface ProjectTreeTrackingOperation {
    path?: string;
    type?: string;
  }

  export interface VfsWatchEvent {
    path?: string;
    file?: boolean;
    type?: string;
  }

  export interface ProjectTreeStateUpdate {
    path?: string;
    file?: boolean;
    type?: string;
  }

  export interface PomModifiedEvent {
    path?: string;
  }

  export interface FileStateUpdate {
    path?: string;
    hashCode?: string;
    type?: string;
  }

  export interface GitCheckoutEvent {
    name?: string;
    type?: string;
    projectName?: string;
  }

  export interface FileTrackingOperation {
    path?: string;
    oldPath?: string;
    type?: string;
  }

}

export namespace che.debug.action {

  export interface Action {
    type?: string;
  }

  export interface SuspendAction {
    type?: string;
  }

  export interface ResumeAction {
    type?: string;
  }

  export interface StepIntoAction {
    suspendPolicy?: string;
    type?: string;
  }

  export interface StepOutAction {
    suspendPolicy?: string;
    type?: string;
  }

  export interface StepOverAction {
    suspendPolicy?: string;
    type?: string;
  }

  export interface StartAction {
    breakpoints?: che.debug.Breakpoint[];
    type?: string;
  }

}