protobuf/gen/web/printer/v1/pdf_invoice_pb.d.ts

import * as jspb from 'google-protobuf'

import * as google_type_money_pb from '../../google/type/money_pb';
import * as google_type_datetime_pb from '../../google/type/datetime_pb';
import * as google_api_annotations_pb from '../../google/api/annotations_pb';


export class InvoiceInfo extends jspb.Message {
  getInvoiceId(): string;
  setInvoiceId(value: string): InvoiceInfo;

  getInvoiceDate(): google_type_datetime_pb.DateTime | undefined;
  setInvoiceDate(value?: google_type_datetime_pb.DateTime): InvoiceInfo;
  hasInvoiceDate(): boolean;
  clearInvoiceDate(): InvoiceInfo;

  getInvoiceDueDate(): google_type_datetime_pb.DateTime | undefined;
  setInvoiceDueDate(value?: google_type_datetime_pb.DateTime): InvoiceInfo;
  hasInvoiceDueDate(): boolean;
  clearInvoiceDueDate(): InvoiceInfo;

  getInvoiceType(): InvoiceType;
  setInvoiceType(value: InvoiceType): InvoiceInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): InvoiceInfo.AsObject;
  static toObject(includeInstance: boolean, msg: InvoiceInfo): InvoiceInfo.AsObject;
  static serializeBinaryToWriter(message: InvoiceInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): InvoiceInfo;
  static deserializeBinaryFromReader(message: InvoiceInfo, reader: jspb.BinaryReader): InvoiceInfo;
}

export namespace InvoiceInfo {
  export type AsObject = {
    invoiceId: string,
    invoiceDate?: google_type_datetime_pb.DateTime.AsObject,
    invoiceDueDate?: google_type_datetime_pb.DateTime.AsObject,
    invoiceType: InvoiceType,
  }
}

export class OrderInfo extends jspb.Message {
  getOrderId(): string;
  setOrderId(value: string): OrderInfo;

  getOrderDate(): google_type_datetime_pb.DateTime | undefined;
  setOrderDate(value?: google_type_datetime_pb.DateTime): OrderInfo;
  hasOrderDate(): boolean;
  clearOrderDate(): OrderInfo;

  getOrderDueDate(): google_type_datetime_pb.DateTime | undefined;
  setOrderDueDate(value?: google_type_datetime_pb.DateTime): OrderInfo;
  hasOrderDueDate(): boolean;
  clearOrderDueDate(): OrderInfo;

  getOrderType(): OrderType;
  setOrderType(value: OrderType): OrderInfo;

  getOrderItemsList(): Array<OrderItem>;
  setOrderItemsList(value: Array<OrderItem>): OrderInfo;
  clearOrderItemsList(): OrderInfo;
  addOrderItems(value?: OrderItem, index?: number): OrderItem;

  getOrderVatItemsList(): Array<OrderVatItem>;
  setOrderVatItemsList(value: Array<OrderVatItem>): OrderInfo;
  clearOrderVatItemsList(): OrderInfo;
  addOrderVatItems(value?: OrderVatItem, index?: number): OrderVatItem;

  getDeposit(): number;
  setDeposit(value: number): OrderInfo;
  hasDeposit(): boolean;
  clearDeposit(): OrderInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): OrderInfo.AsObject;
  static toObject(includeInstance: boolean, msg: OrderInfo): OrderInfo.AsObject;
  static serializeBinaryToWriter(message: OrderInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): OrderInfo;
  static deserializeBinaryFromReader(message: OrderInfo, reader: jspb.BinaryReader): OrderInfo;
}

export namespace OrderInfo {
  export type AsObject = {
    orderId: string,
    orderDate?: google_type_datetime_pb.DateTime.AsObject,
    orderDueDate?: google_type_datetime_pb.DateTime.AsObject,
    orderType: OrderType,
    orderItemsList: Array<OrderItem.AsObject>,
    orderVatItemsList: Array<OrderVatItem.AsObject>,
    deposit?: number,
  }

  export enum DepositCase { 
    _DEPOSIT_NOT_SET = 0,
    DEPOSIT = 7,
  }
}

export class OfferInfo extends jspb.Message {
  getOfferId(): string;
  setOfferId(value: string): OfferInfo;

  getOfferDate(): google_type_datetime_pb.DateTime | undefined;
  setOfferDate(value?: google_type_datetime_pb.DateTime): OfferInfo;
  hasOfferDate(): boolean;
  clearOfferDate(): OfferInfo;

  getOfferDueDate(): google_type_datetime_pb.DateTime | undefined;
  setOfferDueDate(value?: google_type_datetime_pb.DateTime): OfferInfo;
  hasOfferDueDate(): boolean;
  clearOfferDueDate(): OfferInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): OfferInfo.AsObject;
  static toObject(includeInstance: boolean, msg: OfferInfo): OfferInfo.AsObject;
  static serializeBinaryToWriter(message: OfferInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): OfferInfo;
  static deserializeBinaryFromReader(message: OfferInfo, reader: jspb.BinaryReader): OfferInfo;
}

export namespace OfferInfo {
  export type AsObject = {
    offerId: string,
    offerDate?: google_type_datetime_pb.DateTime.AsObject,
    offerDueDate?: google_type_datetime_pb.DateTime.AsObject,
  }
}

export class OrderItem extends jspb.Message {
  getDescription(): string;
  setDescription(value: string): OrderItem;

  getVat(): number;
  setVat(value: number): OrderItem;

  getCount(): number;
  setCount(value: number): OrderItem;

  getPriceSingle(): number;
  setPriceSingle(value: number): OrderItem;

  getPriceSum(): number;
  setPriceSum(value: number): OrderItem;

  getPriceNet(): boolean;
  setPriceNet(value: boolean): OrderItem;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): OrderItem.AsObject;
  static toObject(includeInstance: boolean, msg: OrderItem): OrderItem.AsObject;
  static serializeBinaryToWriter(message: OrderItem, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): OrderItem;
  static deserializeBinaryFromReader(message: OrderItem, reader: jspb.BinaryReader): OrderItem;
}

export namespace OrderItem {
  export type AsObject = {
    description: string,
    vat: number,
    count: number,
    priceSingle: number,
    priceSum: number,
    priceNet: boolean,
  }
}

export class OrderVatItem extends jspb.Message {
  getDescription(): string;
  setDescription(value: string): OrderVatItem;

  getVat(): number;
  setVat(value: number): OrderVatItem;

  getVatMoneySum(): number;
  setVatMoneySum(value: number): OrderVatItem;

  getItemsCount(): number;
  setItemsCount(value: number): OrderVatItem;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): OrderVatItem.AsObject;
  static toObject(includeInstance: boolean, msg: OrderVatItem): OrderVatItem.AsObject;
  static serializeBinaryToWriter(message: OrderVatItem, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): OrderVatItem;
  static deserializeBinaryFromReader(message: OrderVatItem, reader: jspb.BinaryReader): OrderVatItem;
}

export namespace OrderVatItem {
  export type AsObject = {
    description: string,
    vat: number,
    vatMoneySum: number,
    itemsCount: number,
  }
}

export class Invoice extends jspb.Message {
  getOrder(): OrderInfo | undefined;
  setOrder(value?: OrderInfo): Invoice;
  hasOrder(): boolean;
  clearOrder(): Invoice;

  getOffer(): OfferInfo | undefined;
  setOffer(value?: OfferInfo): Invoice;
  hasOffer(): boolean;
  clearOffer(): Invoice;

  getInfo(): InvoiceInfo | undefined;
  setInfo(value?: InvoiceInfo): Invoice;
  hasInfo(): boolean;
  clearInfo(): Invoice;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Invoice.AsObject;
  static toObject(includeInstance: boolean, msg: Invoice): Invoice.AsObject;
  static serializeBinaryToWriter(message: Invoice, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Invoice;
  static deserializeBinaryFromReader(message: Invoice, reader: jspb.BinaryReader): Invoice;
}

export namespace Invoice {
  export type AsObject = {
    order?: OrderInfo.AsObject,
    offer?: OfferInfo.AsObject,
    info?: InvoiceInfo.AsObject,
  }
}

export class DocumentResponse extends jspb.Message {
  getDocument(): Uint8Array | string;
  getDocument_asU8(): Uint8Array;
  getDocument_asB64(): string;
  setDocument(value: Uint8Array | string): DocumentResponse;

  getSignature(): string;
  setSignature(value: string): DocumentResponse;

  getSha512(): string;
  setSha512(value: string): DocumentResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DocumentResponse.AsObject;
  static toObject(includeInstance: boolean, msg: DocumentResponse): DocumentResponse.AsObject;
  static serializeBinaryToWriter(message: DocumentResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DocumentResponse;
  static deserializeBinaryFromReader(message: DocumentResponse, reader: jspb.BinaryReader): DocumentResponse;
}

export namespace DocumentResponse {
  export type AsObject = {
    document: Uint8Array | string,
    signature: string,
    sha512: string,
  }
}

export enum InvoiceType { 
  INVOICE_TYPE_UNSPECIFIED = 0,
  INVOICE_TYPE_PAID = 1,
  INVOICE_TYPE_OPEN = 2,
}
export enum OrderType { 
  ORDER_TYPE_UNSPECIFIED = 0,
  ORDER_TYPE_PHONE = 1,
  ORDER_TYPE_WWW = 2,
  ORDER_TYPE_EMAIL = 3,
}