hackathon/api/v1/gen/ts/codequest/all_pb.d.ts

// package: hhhapz.codequest.v1
// file: github.com/hhhapz/codequest/api/v1/all.proto

import * as jspb from "google-protobuf";
import * as google_api_annotations_pb from "../../../../../google/api/annotations_pb";
import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb";
import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb";

export class Token extends jspb.Message {
  getToken(): string;
  setToken(value: string): void;

  hasExpires(): boolean;
  clearExpires(): void;
  getExpires(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setExpires(value?: google_protobuf_timestamp_pb.Timestamp): void;

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

export namespace Token {
  export type AsObject = {
    token: string,
    expires?: google_protobuf_timestamp_pb.Timestamp.AsObject,
  }
}

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

export namespace OAuthCodeRequest {
  export type AsObject = {
  }
}

export class OAuthCodeResponse extends jspb.Message {
  getRedirecturi(): string;
  setRedirecturi(value: string): void;

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

export namespace OAuthCodeResponse {
  export type AsObject = {
    redirecturi: string,
  }
}

export class TokenRequest extends jspb.Message {
  getCode(): string;
  setCode(value: string): void;

  getState(): string;
  setState(value: string): void;

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

export namespace TokenRequest {
  export type AsObject = {
    code: string,
    state: string,
  }
}

export class DeleteTokenRequest extends jspb.Message {
  getAll(): boolean;
  setAll(value: boolean): void;

  hasToken(): boolean;
  clearToken(): void;
  getToken(): Token | undefined;
  setToken(value?: Token): void;

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

export namespace DeleteTokenRequest {
  export type AsObject = {
    all: boolean,
    token?: Token.AsObject,
  }
}

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

  getName(): string;
  setName(value: string): void;

  getEmail(): string;
  setEmail(value: string): void;

  getPicture(): string;
  setPicture(value: string): void;

  getAdmin(): boolean;
  setAdmin(value: boolean): void;

  hasCreatedat(): boolean;
  clearCreatedat(): void;
  getCreatedat(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setCreatedat(value?: google_protobuf_timestamp_pb.Timestamp): void;

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

export namespace User {
  export type AsObject = {
    id: string,
    name: string,
    email: string,
    picture: string,
    admin: boolean,
    createdat?: google_protobuf_timestamp_pb.Timestamp.AsObject,
  }
}

export class PartData extends jspb.Message {
  getCompleted(): boolean;
  setCompleted(value: boolean): void;

  getPointsworth(): number;
  setPointsworth(value: number): void;

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

export namespace PartData {
  export type AsObject = {
    completed: boolean,
    pointsworth: number,
  }
}

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

  getTitle(): string;
  setTitle(value: string): void;

  getText(): string;
  setText(value: string): void;

  hasPart1(): boolean;
  clearPart1(): void;
  getPart1(): PartData | undefined;
  setPart1(value?: PartData): void;

  hasPart2(): boolean;
  clearPart2(): void;
  getPart2(): PartData | undefined;
  setPart2(value?: PartData): void;

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

export namespace Question {
  export type AsObject = {
    id: string,
    title: string,
    text: string,
    part1?: PartData.AsObject,
    part2?: PartData.AsObject,
  }
}

export class QuestionsResponse extends jspb.Message {
  clearQuestionsList(): void;
  getQuestionsList(): Array<Question>;
  setQuestionsList(value: Array<Question>): void;
  addQuestions(value?: Question, index?: number): Question;

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

export namespace QuestionsResponse {
  export type AsObject = {
    questionsList: Array<Question.AsObject>,
  }
}

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

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

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

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

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

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

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

  getInput(): string;
  setInput(value: string): void;

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

export namespace QuestionInput {
  export type AsObject = {
    id: string,
    input: string,
  }
}

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

  getAnswer(): string;
  setAnswer(value: string): void;

  getPart(): boolean;
  setPart(value: boolean): void;

  getCode(): string;
  setCode(value: string): void;

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

export namespace SubmitRequest {
  export type AsObject = {
    id: string,
    answer: string,
    part: boolean,
    code: string,
  }
}

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

  getPart(): number;
  setPart(value: number): void;

  getCorrect(): boolean;
  setCorrect(value: boolean): void;

  getRanking(): number;
  setRanking(value: number): void;

  getPoints(): number;
  setPoints(value: number): void;

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

export namespace SubmitResponse {
  export type AsObject = {
    id: string,
    part: number,
    correct: boolean,
    ranking: number,
    points: number,
  }
}

export class UpdateFields extends jspb.Message {
  getName(): string;
  setName(value: string): void;

  getGradelevel(): number;
  setGradelevel(value: number): void;

  getAdmin(): boolean;
  setAdmin(value: boolean): void;

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

export namespace UpdateFields {
  export type AsObject = {
    name: string,
    gradelevel: number,
    admin: boolean,
  }
}

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

export namespace UserRequest {
  export type AsObject = {
  }
}

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

export namespace AllUsersRequest {
  export type AsObject = {
  }
}

export class UpdateUserRequest extends jspb.Message {
  getEmail(): string;
  setEmail(value: string): void;

  hasBody(): boolean;
  clearBody(): void;
  getBody(): UpdateFields | undefined;
  setBody(value?: UpdateFields): void;

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

export namespace UpdateUserRequest {
  export type AsObject = {
    email: string,
    body?: UpdateFields.AsObject,
  }
}

export class UserByEmailRequest extends jspb.Message {
  getEmail(): string;
  setEmail(value: string): void;

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

export namespace UserByEmailRequest {
  export type AsObject = {
    email: string,
  }
}

export class DeleteUserRequest extends jspb.Message {
  getEmail(): string;
  setEmail(value: string): void;

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

export namespace DeleteUserRequest {
  export type AsObject = {
    email: string,
  }
}

export class AllUsersResponse extends jspb.Message {
  clearUsersList(): void;
  getUsersList(): Array<User>;
  setUsersList(value: Array<User>): void;
  addUsers(value?: User, index?: number): User;

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

export namespace AllUsersResponse {
  export type AsObject = {
    usersList: Array<User.AsObject>,
  }
}