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

A video game for programmers about air traffic control

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

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

import * as jspb from "google-protobuf";
import * as atc_v1_tag_pb from "../../atc/v1/tag_pb";

export class Airport extends jspb.Message { 

    hasNode(): boolean;
    clearNode(): void;
    getNode(): Node | undefined;
    setNode(value?: Node): Airport;
    getTag(): atc_v1_tag_pb.Tag;
    setTag(value: atc_v1_tag_pb.Tag): Airport;

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

export namespace Airport {
    export type AsObject = {
        node?: Node.AsObject,
        tag: atc_v1_tag_pb.Tag,
    }
}

export class Map extends jspb.Message { 
    clearAirportsList(): void;
    getAirportsList(): Array<Airport>;
    setAirportsList(value: Array<Airport>): Map;
    addAirports(value?: Airport, index?: number): Airport;
    clearRoutingGridList(): void;
    getRoutingGridList(): Array<Node>;
    setRoutingGridList(value: Array<Node>): Map;
    addRoutingGrid(value?: Node, index?: number): Node;
    getWidth(): number;
    setWidth(value: number): Map;
    getHeight(): number;
    setHeight(value: number): Map;

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

export namespace Map {
    export type AsObject = {
        airportsList: Array<Airport.AsObject>,
        routingGridList: Array<Node.AsObject>,
        width: number,
        height: number,
    }
}

export class Node extends jspb.Message { 
    getLongitude(): number;
    setLongitude(value: number): Node;
    getLatitude(): number;
    setLatitude(value: number): Node;
    getRestricted(): boolean;
    setRestricted(value: boolean): Node;

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

export namespace Node {
    export type AsObject = {
        longitude: number,
        latitude: number,
        restricted: boolean,
    }
}

export class Point extends jspb.Message { 
    getX(): number;
    setX(value: number): Point;
    getY(): number;
    setY(value: number): Point;

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

export namespace Point {
    export type AsObject = {
        x: number,
        y: number,
    }
}

export class GetMapRequest extends jspb.Message { 

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

export namespace GetMapRequest {
    export type AsObject = {
    }
}

export class GetMapResponse extends jspb.Message { 

    hasMap(): boolean;
    clearMap(): void;
    getMap(): Map | undefined;
    setMap(value?: Map): GetMapResponse;

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

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

export class NodeToPointRequest extends jspb.Message { 

    hasNode(): boolean;
    clearNode(): void;
    getNode(): Node | undefined;
    setNode(value?: Node): NodeToPointRequest;

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

export namespace NodeToPointRequest {
    export type AsObject = {
        node?: Node.AsObject,
    }
}

export class NodeToPointResponse extends jspb.Message { 

    hasPoint(): boolean;
    clearPoint(): void;
    getPoint(): Point | undefined;
    setPoint(value?: Point): NodeToPointResponse;

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

export namespace NodeToPointResponse {
    export type AsObject = {
        point?: Point.AsObject,
    }
}