// package: models.proto.cofd
// file: cofd.proto

import * as jspb from "google-protobuf";

export class CoreFields extends jspb.Message {
  getIntegrity(): number;
  setIntegrity(value: number): void;

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

export namespace CoreFields {
  export type AsObject = {
    integrity: number,
  }
}

export class MageFields extends jspb.Message {
  getWidsom(): number;
  setWidsom(value: number): void;

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

export namespace MageFields {
  export type AsObject = {
    widsom: number,
  }
}

export class ChangelingFields extends jspb.Message {
  getClarity(): number;
  setClarity(value: number): void;

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

export namespace ChangelingFields {
  export type AsObject = {
    clarity: number,
  }
}

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

  getPlayer(): string;
  setPlayer(value: string): void;

  getCampaign(): string;
  setCampaign(value: string): void;

  getDescription(): string;
  setDescription(value: string): void;

  getStrength(): number;
  setStrength(value: number): void;

  getDexterity(): number;
  setDexterity(value: number): void;

  getStamina(): number;
  setStamina(value: number): void;

  getIntelligence(): number;
  setIntelligence(value: number): void;

  getWits(): number;
  setWits(value: number): void;

  getResolve(): number;
  setResolve(value: number): void;

  getPresence(): number;
  setPresence(value: number): void;

  getManipulation(): number;
  setManipulation(value: number): void;

  getComposure(): number;
  setComposure(value: number): void;

  getPhysicalSkillsMap(): jspb.Map<string, CofdSheet.Skill>;
  clearPhysicalSkillsMap(): void;
  getMentalSkillsMap(): jspb.Map<string, CofdSheet.Skill>;
  clearMentalSkillsMap(): void;
  getSocialSkillsMap(): jspb.Map<string, CofdSheet.Skill>;
  clearSocialSkillsMap(): void;
  clearMeritsList(): void;
  getMeritsList(): Array<CofdSheet.Merit>;
  setMeritsList(value: Array<CofdSheet.Merit>): void;
  addMerits(value?: CofdSheet.Merit, index?: number): CofdSheet.Merit;

  clearConditionsList(): void;
  getConditionsList(): Array<CofdSheet.Condition>;
  setConditionsList(value: Array<CofdSheet.Condition>): void;
  addConditions(value?: CofdSheet.Condition, index?: number): CofdSheet.Condition;

  getSize(): number;
  setSize(value: number): void;

  getHealth(): number;
  setHealth(value: number): void;

  getWillpower(): number;
  setWillpower(value: number): void;

  getExperiencePoints(): number;
  setExperiencePoints(value: number): void;

  getBeats(): number;
  setBeats(value: number): void;

  clearItemsList(): void;
  getItemsList(): Array<CofdSheet.Item>;
  setItemsList(value: Array<CofdSheet.Item>): void;
  addItems(value?: CofdSheet.Item, index?: number): CofdSheet.Item;

  clearAttacksList(): void;
  getAttacksList(): Array<CofdSheet.Attack>;
  setAttacksList(value: Array<CofdSheet.Attack>): void;
  addAttacks(value?: CofdSheet.Attack, index?: number): CofdSheet.Attack;

  getOtherDataMap(): jspb.Map<string, string>;
  clearOtherDataMap(): void;
  hasCore(): boolean;
  clearCore(): void;
  getCore(): CoreFields | undefined;
  setCore(value?: CoreFields): void;

  hasMage(): boolean;
  clearMage(): void;
  getMage(): MageFields | undefined;
  setMage(value?: MageFields): void;

  hasChangeling(): boolean;
  clearChangeling(): void;
  getChangeling(): ChangelingFields | undefined;
  setChangeling(value?: ChangelingFields): void;

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

export namespace CofdSheet {
  export type AsObject = {
    name: string,
    player: string,
    campaign: string,
    description: string,
    strength: number,
    dexterity: number,
    stamina: number,
    intelligence: number,
    wits: number,
    resolve: number,
    presence: number,
    manipulation: number,
    composure: number,
    physicalSkillsMap: Array<[string, CofdSheet.Skill.AsObject]>,
    mentalSkillsMap: Array<[string, CofdSheet.Skill.AsObject]>,
    socialSkillsMap: Array<[string, CofdSheet.Skill.AsObject]>,
    meritsList: Array<CofdSheet.Merit.AsObject>,
    conditionsList: Array<CofdSheet.Condition.AsObject>,
    size: number,
    health: number,
    willpower: number,
    experiencePoints: number,
    beats: number,
    itemsList: Array<CofdSheet.Item.AsObject>,
    attacksList: Array<CofdSheet.Attack.AsObject>,
    otherDataMap: Array<[string, string]>,
    core?: CoreFields.AsObject,
    mage?: MageFields.AsObject,
    changeling?: ChangelingFields.AsObject,
  }

  export class Merit extends jspb.Message {
    getDots(): number;
    setDots(value: number): void;

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

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

  export namespace Merit {
    export type AsObject = {
      dots: number,
      name: string,
    }
  }

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

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

  export namespace Condition {
    export type AsObject = {
      name: string,
    }
  }

  export class Skill extends jspb.Message {
    getDots(): number;
    setDots(value: number): void;

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

    getUntrainedPenalty(): number;
    setUntrainedPenalty(value: number): void;

    clearSpecializationsList(): void;
    getSpecializationsList(): Array<string>;
    setSpecializationsList(value: Array<string>): void;
    addSpecializations(value: string, index?: number): string;

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

  export namespace Skill {
    export type AsObject = {
      dots: number,
      name: string,
      untrainedPenalty: number,
      specializationsList: Array<string>,
    }
  }

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

    getDescription(): string;
    setDescription(value: string): void;

    getRules(): string;
    setRules(value: string): void;

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

  export namespace Item {
    export type AsObject = {
      name: string,
      description: string,
      rules: string,
    }
  }

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

    getDicePool(): number;
    setDicePool(value: number): void;

    getDamage(): number;
    setDamage(value: number): void;

    getRange(): number;
    setRange(value: number): void;

    getInitiativeModifier(): number;
    setInitiativeModifier(value: number): void;

    getSize(): number;
    setSize(value: number): void;

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

  export namespace Attack {
    export type AsObject = {
      name: string,
      dicePool: number,
      damage: number,
      range: number,
      initiativeModifier: number,
      size: number,
    }
  }

  export enum SystemFieldsCase {
    SYSTEM_FIELDS_NOT_SET = 0,
    CORE = 28,
    MAGE = 29,
    CHANGELING = 30,
  }
}