auto-traffic-control/src/atc/v1/event_pb.d.ts

A video game for programmers about air traffic control

// package: atc.v1
// file: atc/v1/event.proto

/* tslint:disable */
/* eslint-disable */

import * as jspb from "google-protobuf";
import * as atc_v1_airplane_pb from "../../atc/v1/airplane_pb";
import * as atc_v1_map_pb from "../../atc/v1/map_pb";

export class AirplaneCollided extends jspb.Message { 
    getId1(): string;
    setId1(value: string): AirplaneCollided;
    getId2(): string;
    setId2(value: string): AirplaneCollided;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AirplaneCollided.AsObject;
    static toObject(includeInstance: boolean, msg: AirplaneCollided): AirplaneCollided.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AirplaneCollided, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AirplaneCollided;
    static deserializeBinaryFromReader(message: AirplaneCollided, reader: jspb.BinaryReader): AirplaneCollided;
}

export namespace AirplaneCollided {
    export type AsObject = {
        id1: string,
        id2: string,
    }
}

export class AirplaneDetected extends jspb.Message { 

    hasAirplane(): boolean;
    clearAirplane(): void;
    getAirplane(): atc_v1_airplane_pb.Airplane | undefined;
    setAirplane(value?: atc_v1_airplane_pb.Airplane): AirplaneDetected;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AirplaneDetected.AsObject;
    static toObject(includeInstance: boolean, msg: AirplaneDetected): AirplaneDetected.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AirplaneDetected, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AirplaneDetected;
    static deserializeBinaryFromReader(message: AirplaneDetected, reader: jspb.BinaryReader): AirplaneDetected;
}

export namespace AirplaneDetected {
    export type AsObject = {
        airplane?: atc_v1_airplane_pb.Airplane.AsObject,
    }
}

export class AirplaneLanded extends jspb.Message { 
    getId(): string;
    setId(value: string): AirplaneLanded;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AirplaneLanded.AsObject;
    static toObject(includeInstance: boolean, msg: AirplaneLanded): AirplaneLanded.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AirplaneLanded, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AirplaneLanded;
    static deserializeBinaryFromReader(message: AirplaneLanded, reader: jspb.BinaryReader): AirplaneLanded;
}

export namespace AirplaneLanded {
    export type AsObject = {
        id: string,
    }
}

export class AirplaneMoved extends jspb.Message { 
    getId(): string;
    setId(value: string): AirplaneMoved;

    hasPoint(): boolean;
    clearPoint(): void;
    getPoint(): atc_v1_map_pb.Point | undefined;
    setPoint(value?: atc_v1_map_pb.Point): AirplaneMoved;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AirplaneMoved.AsObject;
    static toObject(includeInstance: boolean, msg: AirplaneMoved): AirplaneMoved.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AirplaneMoved, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AirplaneMoved;
    static deserializeBinaryFromReader(message: AirplaneMoved, reader: jspb.BinaryReader): AirplaneMoved;
}

export namespace AirplaneMoved {
    export type AsObject = {
        id: string,
        point?: atc_v1_map_pb.Point.AsObject,
    }
}

export class FlightPlanUpdated extends jspb.Message { 
    getId(): string;
    setId(value: string): FlightPlanUpdated;
    clearFlightPlanList(): void;
    getFlightPlanList(): Array<atc_v1_map_pb.Node>;
    setFlightPlanList(value: Array<atc_v1_map_pb.Node>): FlightPlanUpdated;
    addFlightPlan(value?: atc_v1_map_pb.Node, index?: number): atc_v1_map_pb.Node;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): FlightPlanUpdated.AsObject;
    static toObject(includeInstance: boolean, msg: FlightPlanUpdated): FlightPlanUpdated.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: FlightPlanUpdated, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): FlightPlanUpdated;
    static deserializeBinaryFromReader(message: FlightPlanUpdated, reader: jspb.BinaryReader): FlightPlanUpdated;
}

export namespace FlightPlanUpdated {
    export type AsObject = {
        id: string,
        flightPlanList: Array<atc_v1_map_pb.Node.AsObject>,
    }
}

export class LandingAborted extends jspb.Message { 
    getId(): string;
    setId(value: string): LandingAborted;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): LandingAborted.AsObject;
    static toObject(includeInstance: boolean, msg: LandingAborted): LandingAborted.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: LandingAborted, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): LandingAborted;
    static deserializeBinaryFromReader(message: LandingAborted, reader: jspb.BinaryReader): LandingAborted;
}

export namespace LandingAborted {
    export type AsObject = {
        id: string,
    }
}

export class GameStarted extends jspb.Message { 

    hasMap(): boolean;
    clearMap(): void;
    getMap(): atc_v1_map_pb.Map | undefined;
    setMap(value?: atc_v1_map_pb.Map): GameStarted;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): GameStarted.AsObject;
    static toObject(includeInstance: boolean, msg: GameStarted): GameStarted.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: GameStarted, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): GameStarted;
    static deserializeBinaryFromReader(message: GameStarted, reader: jspb.BinaryReader): GameStarted;
}

export namespace GameStarted {
    export type AsObject = {
        map?: atc_v1_map_pb.Map.AsObject,
    }
}

export class GameStopped extends jspb.Message { 
    getScore(): number;
    setScore(value: number): GameStopped;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): GameStopped.AsObject;
    static toObject(includeInstance: boolean, msg: GameStopped): GameStopped.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: GameStopped, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): GameStopped;
    static deserializeBinaryFromReader(message: GameStopped, reader: jspb.BinaryReader): GameStopped;
}

export namespace GameStopped {
    export type AsObject = {
        score: number,
    }
}

export class StreamRequest extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): StreamRequest.AsObject;
    static toObject(includeInstance: boolean, msg: StreamRequest): StreamRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: StreamRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): StreamRequest;
    static deserializeBinaryFromReader(message: StreamRequest, reader: jspb.BinaryReader): StreamRequest;
}

export namespace StreamRequest {
    export type AsObject = {
    }
}

export class StreamResponse extends jspb.Message { 

    hasAirplaneCollided(): boolean;
    clearAirplaneCollided(): void;
    getAirplaneCollided(): AirplaneCollided | undefined;
    setAirplaneCollided(value?: AirplaneCollided): StreamResponse;

    hasAirplaneDetected(): boolean;
    clearAirplaneDetected(): void;
    getAirplaneDetected(): AirplaneDetected | undefined;
    setAirplaneDetected(value?: AirplaneDetected): StreamResponse;

    hasAirplaneLanded(): boolean;
    clearAirplaneLanded(): void;
    getAirplaneLanded(): AirplaneLanded | undefined;
    setAirplaneLanded(value?: AirplaneLanded): StreamResponse;

    hasAirplaneMoved(): boolean;
    clearAirplaneMoved(): void;
    getAirplaneMoved(): AirplaneMoved | undefined;
    setAirplaneMoved(value?: AirplaneMoved): StreamResponse;

    hasFlightPlanUpdated(): boolean;
    clearFlightPlanUpdated(): void;
    getFlightPlanUpdated(): FlightPlanUpdated | undefined;
    setFlightPlanUpdated(value?: FlightPlanUpdated): StreamResponse;

    hasLandingAborted(): boolean;
    clearLandingAborted(): void;
    getLandingAborted(): LandingAborted | undefined;
    setLandingAborted(value?: LandingAborted): StreamResponse;

    hasGameStarted(): boolean;
    clearGameStarted(): void;
    getGameStarted(): GameStarted | undefined;
    setGameStarted(value?: GameStarted): StreamResponse;

    hasGameStopped(): boolean;
    clearGameStopped(): void;
    getGameStopped(): GameStopped | undefined;
    setGameStopped(value?: GameStopped): StreamResponse;

    getEventCase(): StreamResponse.EventCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): StreamResponse.AsObject;
    static toObject(includeInstance: boolean, msg: StreamResponse): StreamResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: StreamResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): StreamResponse;
    static deserializeBinaryFromReader(message: StreamResponse, reader: jspb.BinaryReader): StreamResponse;
}

export namespace StreamResponse {
    export type AsObject = {
        airplaneCollided?: AirplaneCollided.AsObject,
        airplaneDetected?: AirplaneDetected.AsObject,
        airplaneLanded?: AirplaneLanded.AsObject,
        airplaneMoved?: AirplaneMoved.AsObject,
        flightPlanUpdated?: FlightPlanUpdated.AsObject,
        landingAborted?: LandingAborted.AsObject,
        gameStarted?: GameStarted.AsObject,
        gameStopped?: GameStopped.AsObject,
    }

    export enum EventCase {
        EVENT_NOT_SET = 0,
        AIRPLANE_COLLIDED = 1,
        AIRPLANE_DETECTED = 2,
        AIRPLANE_LANDED = 3,
        AIRPLANE_MOVED = 4,
        FLIGHT_PLAN_UPDATED = 5,
        LANDING_ABORTED = 6,
        GAME_STARTED = 7,
        GAME_STOPPED = 8,
    }

}