/* eslint-disable */
import Long from 'long';
import * as _m0 from 'protobufjs/minimal';
import { Timestamp } from './google/protobuf/timestamp';

export const protobufPackage = 'tinkoff.public.invest.api.contract.v1';

/** Тип инструмента. */
export enum InstrumentType {
  INSTRUMENT_TYPE_UNSPECIFIED = 0,
  /** INSTRUMENT_TYPE_BOND - Облигация. */
  INSTRUMENT_TYPE_BOND = 1,
  /** INSTRUMENT_TYPE_SHARE - Акция. */
  INSTRUMENT_TYPE_SHARE = 2,
  /** INSTRUMENT_TYPE_CURRENCY - Валюта. */
  INSTRUMENT_TYPE_CURRENCY = 3,
  /** INSTRUMENT_TYPE_ETF - Exchange-traded fund. Фонд. */
  INSTRUMENT_TYPE_ETF = 4,
  /** INSTRUMENT_TYPE_FUTURES - Фьючерс. */
  INSTRUMENT_TYPE_FUTURES = 5,
  /** INSTRUMENT_TYPE_SP - Структурная нота. */
  INSTRUMENT_TYPE_SP = 6,
  /** INSTRUMENT_TYPE_OPTION - Опцион. */
  INSTRUMENT_TYPE_OPTION = 7,
  /** INSTRUMENT_TYPE_CLEARING_CERTIFICATE - Clearing certificate. */
  INSTRUMENT_TYPE_CLEARING_CERTIFICATE = 8,
  /** INSTRUMENT_TYPE_INDEX - Индекс. */
  INSTRUMENT_TYPE_INDEX = 9,
  /** INSTRUMENT_TYPE_COMMODITY - Товар. */
  INSTRUMENT_TYPE_COMMODITY = 10,
  /** INSTRUMENT_TYPE_DFA - Цифровой актив. */
  INSTRUMENT_TYPE_DFA = 11,
  UNRECOGNIZED = -1,
}

export function instrumentTypeFromJSON(object: any): InstrumentType {
  switch (object) {
    case 0:
    case 'INSTRUMENT_TYPE_UNSPECIFIED':
      return InstrumentType.INSTRUMENT_TYPE_UNSPECIFIED;
    case 1:
    case 'INSTRUMENT_TYPE_BOND':
      return InstrumentType.INSTRUMENT_TYPE_BOND;
    case 2:
    case 'INSTRUMENT_TYPE_SHARE':
      return InstrumentType.INSTRUMENT_TYPE_SHARE;
    case 3:
    case 'INSTRUMENT_TYPE_CURRENCY':
      return InstrumentType.INSTRUMENT_TYPE_CURRENCY;
    case 4:
    case 'INSTRUMENT_TYPE_ETF':
      return InstrumentType.INSTRUMENT_TYPE_ETF;
    case 5:
    case 'INSTRUMENT_TYPE_FUTURES':
      return InstrumentType.INSTRUMENT_TYPE_FUTURES;
    case 6:
    case 'INSTRUMENT_TYPE_SP':
      return InstrumentType.INSTRUMENT_TYPE_SP;
    case 7:
    case 'INSTRUMENT_TYPE_OPTION':
      return InstrumentType.INSTRUMENT_TYPE_OPTION;
    case 8:
    case 'INSTRUMENT_TYPE_CLEARING_CERTIFICATE':
      return InstrumentType.INSTRUMENT_TYPE_CLEARING_CERTIFICATE;
    case 9:
    case 'INSTRUMENT_TYPE_INDEX':
      return InstrumentType.INSTRUMENT_TYPE_INDEX;
    case 10:
    case 'INSTRUMENT_TYPE_COMMODITY':
      return InstrumentType.INSTRUMENT_TYPE_COMMODITY;
    case 11:
    case 'INSTRUMENT_TYPE_DFA':
      return InstrumentType.INSTRUMENT_TYPE_DFA;
    case -1:
    case 'UNRECOGNIZED':
    default:
      return InstrumentType.UNRECOGNIZED;
  }
}

export function instrumentTypeToJSON(object: InstrumentType): string {
  switch (object) {
    case InstrumentType.INSTRUMENT_TYPE_UNSPECIFIED:
      return 'INSTRUMENT_TYPE_UNSPECIFIED';
    case InstrumentType.INSTRUMENT_TYPE_BOND:
      return 'INSTRUMENT_TYPE_BOND';
    case InstrumentType.INSTRUMENT_TYPE_SHARE:
      return 'INSTRUMENT_TYPE_SHARE';
    case InstrumentType.INSTRUMENT_TYPE_CURRENCY:
      return 'INSTRUMENT_TYPE_CURRENCY';
    case InstrumentType.INSTRUMENT_TYPE_ETF:
      return 'INSTRUMENT_TYPE_ETF';
    case InstrumentType.INSTRUMENT_TYPE_FUTURES:
      return 'INSTRUMENT_TYPE_FUTURES';
    case InstrumentType.INSTRUMENT_TYPE_SP:
      return 'INSTRUMENT_TYPE_SP';
    case InstrumentType.INSTRUMENT_TYPE_OPTION:
      return 'INSTRUMENT_TYPE_OPTION';
    case InstrumentType.INSTRUMENT_TYPE_CLEARING_CERTIFICATE:
      return 'INSTRUMENT_TYPE_CLEARING_CERTIFICATE';
    case InstrumentType.INSTRUMENT_TYPE_INDEX:
      return 'INSTRUMENT_TYPE_INDEX';
    case InstrumentType.INSTRUMENT_TYPE_COMMODITY:
      return 'INSTRUMENT_TYPE_COMMODITY';
    case InstrumentType.INSTRUMENT_TYPE_DFA:
      return 'INSTRUMENT_TYPE_DFA';
    default:
      return 'UNKNOWN';
  }
}

/** Статус запрашиваемых инструментов. */
export enum InstrumentStatus {
  /** INSTRUMENT_STATUS_UNSPECIFIED - Значение не определено. */
  INSTRUMENT_STATUS_UNSPECIFIED = 0,
  /** INSTRUMENT_STATUS_BASE - По умолчанию — базовый список инструментов, которыми можно торговать через T-Invest API. Сейчас списки доступных бумаг в API и других интерфейсах совпадают — кроме внебиржевых бумаг, но в будущем списки могут различаться. */
  INSTRUMENT_STATUS_BASE = 1,
  /** INSTRUMENT_STATUS_ALL - Список всех инструментов. */
  INSTRUMENT_STATUS_ALL = 2,
  UNRECOGNIZED = -1,
}

export function instrumentStatusFromJSON(object: any): InstrumentStatus {
  switch (object) {
    case 0:
    case 'INSTRUMENT_STATUS_UNSPECIFIED':
      return InstrumentStatus.INSTRUMENT_STATUS_UNSPECIFIED;
    case 1:
    case 'INSTRUMENT_STATUS_BASE':
      return InstrumentStatus.INSTRUMENT_STATUS_BASE;
    case 2:
    case 'INSTRUMENT_STATUS_ALL':
      return InstrumentStatus.INSTRUMENT_STATUS_ALL;
    case -1:
    case 'UNRECOGNIZED':
    default:
      return InstrumentStatus.UNRECOGNIZED;
  }
}

export function instrumentStatusToJSON(object: InstrumentStatus): string {
  switch (object) {
    case InstrumentStatus.INSTRUMENT_STATUS_UNSPECIFIED:
      return 'INSTRUMENT_STATUS_UNSPECIFIED';
    case InstrumentStatus.INSTRUMENT_STATUS_BASE:
      return 'INSTRUMENT_STATUS_BASE';
    case InstrumentStatus.INSTRUMENT_STATUS_ALL:
      return 'INSTRUMENT_STATUS_ALL';
    default:
      return 'UNKNOWN';
  }
}

/** Режим торгов инструмента */
export enum SecurityTradingStatus {
  /** SECURITY_TRADING_STATUS_UNSPECIFIED - Торговый статус не определен. */
  SECURITY_TRADING_STATUS_UNSPECIFIED = 0,
  /** SECURITY_TRADING_STATUS_NOT_AVAILABLE_FOR_TRADING - Недоступен для торгов. */
  SECURITY_TRADING_STATUS_NOT_AVAILABLE_FOR_TRADING = 1,
  /** SECURITY_TRADING_STATUS_OPENING_PERIOD - Период открытия торгов. */
  SECURITY_TRADING_STATUS_OPENING_PERIOD = 2,
  /** SECURITY_TRADING_STATUS_CLOSING_PERIOD - Период закрытия торгов. */
  SECURITY_TRADING_STATUS_CLOSING_PERIOD = 3,
  /** SECURITY_TRADING_STATUS_BREAK_IN_TRADING - Перерыв в торговле. */
  SECURITY_TRADING_STATUS_BREAK_IN_TRADING = 4,
  /** SECURITY_TRADING_STATUS_NORMAL_TRADING - Нормальная торговля. */
  SECURITY_TRADING_STATUS_NORMAL_TRADING = 5,
  /** SECURITY_TRADING_STATUS_CLOSING_AUCTION - Аукцион закрытия. */
  SECURITY_TRADING_STATUS_CLOSING_AUCTION = 6,
  /** SECURITY_TRADING_STATUS_DARK_POOL_AUCTION - Аукцион крупных пакетов. */
  SECURITY_TRADING_STATUS_DARK_POOL_AUCTION = 7,
  /** SECURITY_TRADING_STATUS_DISCRETE_AUCTION - Дискретный аукцион. */
  SECURITY_TRADING_STATUS_DISCRETE_AUCTION = 8,
  /** SECURITY_TRADING_STATUS_OPENING_AUCTION_PERIOD - Аукцион открытия. */
  SECURITY_TRADING_STATUS_OPENING_AUCTION_PERIOD = 9,
  /** SECURITY_TRADING_STATUS_TRADING_AT_CLOSING_AUCTION_PRICE - Период торгов по цене аукциона закрытия. */
  SECURITY_TRADING_STATUS_TRADING_AT_CLOSING_AUCTION_PRICE = 10,
  /** SECURITY_TRADING_STATUS_SESSION_ASSIGNED - Сессия назначена. */
  SECURITY_TRADING_STATUS_SESSION_ASSIGNED = 11,
  /** SECURITY_TRADING_STATUS_SESSION_CLOSE - Сессия закрыта. */
  SECURITY_TRADING_STATUS_SESSION_CLOSE = 12,
  /** SECURITY_TRADING_STATUS_SESSION_OPEN - Сессия открыта. */
  SECURITY_TRADING_STATUS_SESSION_OPEN = 13,
  /** SECURITY_TRADING_STATUS_DEALER_NORMAL_TRADING - Доступна торговля в режиме внутренней ликвидности брокера. */
  SECURITY_TRADING_STATUS_DEALER_NORMAL_TRADING = 14,
  /** SECURITY_TRADING_STATUS_DEALER_BREAK_IN_TRADING - Перерыв торговли в режиме внутренней ликвидности брокера. */
  SECURITY_TRADING_STATUS_DEALER_BREAK_IN_TRADING = 15,
  /** SECURITY_TRADING_STATUS_DEALER_NOT_AVAILABLE_FOR_TRADING - Недоступна торговля в режиме внутренней ликвидности брокера. */
  SECURITY_TRADING_STATUS_DEALER_NOT_AVAILABLE_FOR_TRADING = 16,
  /** SECURITY_TRADING_STATUS_STABILIZATION_AUCTION - Аукцион обновления цен. */
  SECURITY_TRADING_STATUS_STABILIZATION_AUCTION = 17,
  UNRECOGNIZED = -1,
}

export function securityTradingStatusFromJSON(object: any): SecurityTradingStatus {
  switch (object) {
    case 0:
    case 'SECURITY_TRADING_STATUS_UNSPECIFIED':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_UNSPECIFIED;
    case 1:
    case 'SECURITY_TRADING_STATUS_NOT_AVAILABLE_FOR_TRADING':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_NOT_AVAILABLE_FOR_TRADING;
    case 2:
    case 'SECURITY_TRADING_STATUS_OPENING_PERIOD':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_OPENING_PERIOD;
    case 3:
    case 'SECURITY_TRADING_STATUS_CLOSING_PERIOD':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_CLOSING_PERIOD;
    case 4:
    case 'SECURITY_TRADING_STATUS_BREAK_IN_TRADING':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_BREAK_IN_TRADING;
    case 5:
    case 'SECURITY_TRADING_STATUS_NORMAL_TRADING':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_NORMAL_TRADING;
    case 6:
    case 'SECURITY_TRADING_STATUS_CLOSING_AUCTION':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_CLOSING_AUCTION;
    case 7:
    case 'SECURITY_TRADING_STATUS_DARK_POOL_AUCTION':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_DARK_POOL_AUCTION;
    case 8:
    case 'SECURITY_TRADING_STATUS_DISCRETE_AUCTION':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_DISCRETE_AUCTION;
    case 9:
    case 'SECURITY_TRADING_STATUS_OPENING_AUCTION_PERIOD':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_OPENING_AUCTION_PERIOD;
    case 10:
    case 'SECURITY_TRADING_STATUS_TRADING_AT_CLOSING_AUCTION_PRICE':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_TRADING_AT_CLOSING_AUCTION_PRICE;
    case 11:
    case 'SECURITY_TRADING_STATUS_SESSION_ASSIGNED':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_SESSION_ASSIGNED;
    case 12:
    case 'SECURITY_TRADING_STATUS_SESSION_CLOSE':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_SESSION_CLOSE;
    case 13:
    case 'SECURITY_TRADING_STATUS_SESSION_OPEN':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_SESSION_OPEN;
    case 14:
    case 'SECURITY_TRADING_STATUS_DEALER_NORMAL_TRADING':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_DEALER_NORMAL_TRADING;
    case 15:
    case 'SECURITY_TRADING_STATUS_DEALER_BREAK_IN_TRADING':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_DEALER_BREAK_IN_TRADING;
    case 16:
    case 'SECURITY_TRADING_STATUS_DEALER_NOT_AVAILABLE_FOR_TRADING':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_DEALER_NOT_AVAILABLE_FOR_TRADING;
    case 17:
    case 'SECURITY_TRADING_STATUS_STABILIZATION_AUCTION':
      return SecurityTradingStatus.SECURITY_TRADING_STATUS_STABILIZATION_AUCTION;
    case -1:
    case 'UNRECOGNIZED':
    default:
      return SecurityTradingStatus.UNRECOGNIZED;
  }
}

export function securityTradingStatusToJSON(object: SecurityTradingStatus): string {
  switch (object) {
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_UNSPECIFIED:
      return 'SECURITY_TRADING_STATUS_UNSPECIFIED';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_NOT_AVAILABLE_FOR_TRADING:
      return 'SECURITY_TRADING_STATUS_NOT_AVAILABLE_FOR_TRADING';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_OPENING_PERIOD:
      return 'SECURITY_TRADING_STATUS_OPENING_PERIOD';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_CLOSING_PERIOD:
      return 'SECURITY_TRADING_STATUS_CLOSING_PERIOD';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_BREAK_IN_TRADING:
      return 'SECURITY_TRADING_STATUS_BREAK_IN_TRADING';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_NORMAL_TRADING:
      return 'SECURITY_TRADING_STATUS_NORMAL_TRADING';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_CLOSING_AUCTION:
      return 'SECURITY_TRADING_STATUS_CLOSING_AUCTION';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_DARK_POOL_AUCTION:
      return 'SECURITY_TRADING_STATUS_DARK_POOL_AUCTION';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_DISCRETE_AUCTION:
      return 'SECURITY_TRADING_STATUS_DISCRETE_AUCTION';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_OPENING_AUCTION_PERIOD:
      return 'SECURITY_TRADING_STATUS_OPENING_AUCTION_PERIOD';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_TRADING_AT_CLOSING_AUCTION_PRICE:
      return 'SECURITY_TRADING_STATUS_TRADING_AT_CLOSING_AUCTION_PRICE';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_SESSION_ASSIGNED:
      return 'SECURITY_TRADING_STATUS_SESSION_ASSIGNED';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_SESSION_CLOSE:
      return 'SECURITY_TRADING_STATUS_SESSION_CLOSE';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_SESSION_OPEN:
      return 'SECURITY_TRADING_STATUS_SESSION_OPEN';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_DEALER_NORMAL_TRADING:
      return 'SECURITY_TRADING_STATUS_DEALER_NORMAL_TRADING';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_DEALER_BREAK_IN_TRADING:
      return 'SECURITY_TRADING_STATUS_DEALER_BREAK_IN_TRADING';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_DEALER_NOT_AVAILABLE_FOR_TRADING:
      return 'SECURITY_TRADING_STATUS_DEALER_NOT_AVAILABLE_FOR_TRADING';
    case SecurityTradingStatus.SECURITY_TRADING_STATUS_STABILIZATION_AUCTION:
      return 'SECURITY_TRADING_STATUS_STABILIZATION_AUCTION';
    default:
      return 'UNKNOWN';
  }
}

/** Тип цены. */
export enum PriceType {
  /** PRICE_TYPE_UNSPECIFIED - Значение не определено. */
  PRICE_TYPE_UNSPECIFIED = 0,
  /** PRICE_TYPE_POINT - Цена в пунктах (только для фьючерсов и облигаций). */
  PRICE_TYPE_POINT = 1,
  /** PRICE_TYPE_CURRENCY - Цена в валюте расчетов по инструменту. */
  PRICE_TYPE_CURRENCY = 2,
  UNRECOGNIZED = -1,
}

export function priceTypeFromJSON(object: any): PriceType {
  switch (object) {
    case 0:
    case 'PRICE_TYPE_UNSPECIFIED':
      return PriceType.PRICE_TYPE_UNSPECIFIED;
    case 1:
    case 'PRICE_TYPE_POINT':
      return PriceType.PRICE_TYPE_POINT;
    case 2:
    case 'PRICE_TYPE_CURRENCY':
      return PriceType.PRICE_TYPE_CURRENCY;
    case -1:
    case 'UNRECOGNIZED':
    default:
      return PriceType.UNRECOGNIZED;
  }
}

export function priceTypeToJSON(object: PriceType): string {
  switch (object) {
    case PriceType.PRICE_TYPE_UNSPECIFIED:
      return 'PRICE_TYPE_UNSPECIFIED';
    case PriceType.PRICE_TYPE_POINT:
      return 'PRICE_TYPE_POINT';
    case PriceType.PRICE_TYPE_CURRENCY:
      return 'PRICE_TYPE_CURRENCY';
    default:
      return 'UNKNOWN';
  }
}

export enum ResultSubscriptionStatus {
  /** RESULT_SUBSCRIPTION_STATUS_UNSPECIFIED - Статус подписки не определен. */
  RESULT_SUBSCRIPTION_STATUS_UNSPECIFIED = 0,
  /** RESULT_SUBSCRIPTION_STATUS_OK - Подписка успешно установлена. */
  RESULT_SUBSCRIPTION_STATUS_OK = 1,
  /** RESULT_SUBSCRIPTION_STATUS_ERROR - Ошибка подписки */
  RESULT_SUBSCRIPTION_STATUS_ERROR = 13,
  UNRECOGNIZED = -1,
}

export function resultSubscriptionStatusFromJSON(object: any): ResultSubscriptionStatus {
  switch (object) {
    case 0:
    case 'RESULT_SUBSCRIPTION_STATUS_UNSPECIFIED':
      return ResultSubscriptionStatus.RESULT_SUBSCRIPTION_STATUS_UNSPECIFIED;
    case 1:
    case 'RESULT_SUBSCRIPTION_STATUS_OK':
      return ResultSubscriptionStatus.RESULT_SUBSCRIPTION_STATUS_OK;
    case 13:
    case 'RESULT_SUBSCRIPTION_STATUS_ERROR':
      return ResultSubscriptionStatus.RESULT_SUBSCRIPTION_STATUS_ERROR;
    case -1:
    case 'UNRECOGNIZED':
    default:
      return ResultSubscriptionStatus.UNRECOGNIZED;
  }
}

export function resultSubscriptionStatusToJSON(object: ResultSubscriptionStatus): string {
  switch (object) {
    case ResultSubscriptionStatus.RESULT_SUBSCRIPTION_STATUS_UNSPECIFIED:
      return 'RESULT_SUBSCRIPTION_STATUS_UNSPECIFIED';
    case ResultSubscriptionStatus.RESULT_SUBSCRIPTION_STATUS_OK:
      return 'RESULT_SUBSCRIPTION_STATUS_OK';
    case ResultSubscriptionStatus.RESULT_SUBSCRIPTION_STATUS_ERROR:
      return 'RESULT_SUBSCRIPTION_STATUS_ERROR';
    default:
      return 'UNKNOWN';
  }
}

/** Реальная площадка исполнения расчетов. */
export enum RealExchange {
  /** REAL_EXCHANGE_UNSPECIFIED - Тип не определен. */
  REAL_EXCHANGE_UNSPECIFIED = 0,
  /** REAL_EXCHANGE_MOEX - Московская биржа. */
  REAL_EXCHANGE_MOEX = 1,
  /** REAL_EXCHANGE_RTS - Санкт-Петербургская биржа. */
  REAL_EXCHANGE_RTS = 2,
  /** REAL_EXCHANGE_OTC - Внебиржевой инструмент. */
  REAL_EXCHANGE_OTC = 3,
  /** REAL_EXCHANGE_DEALER - Инструмент, торгуемый на площадке брокера. */
  REAL_EXCHANGE_DEALER = 4,
  UNRECOGNIZED = -1,
}

export function realExchangeFromJSON(object: any): RealExchange {
  switch (object) {
    case 0:
    case 'REAL_EXCHANGE_UNSPECIFIED':
      return RealExchange.REAL_EXCHANGE_UNSPECIFIED;
    case 1:
    case 'REAL_EXCHANGE_MOEX':
      return RealExchange.REAL_EXCHANGE_MOEX;
    case 2:
    case 'REAL_EXCHANGE_RTS':
      return RealExchange.REAL_EXCHANGE_RTS;
    case 3:
    case 'REAL_EXCHANGE_OTC':
      return RealExchange.REAL_EXCHANGE_OTC;
    case 4:
    case 'REAL_EXCHANGE_DEALER':
      return RealExchange.REAL_EXCHANGE_DEALER;
    case -1:
    case 'UNRECOGNIZED':
    default:
      return RealExchange.UNRECOGNIZED;
  }
}

export function realExchangeToJSON(object: RealExchange): string {
  switch (object) {
    case RealExchange.REAL_EXCHANGE_UNSPECIFIED:
      return 'REAL_EXCHANGE_UNSPECIFIED';
    case RealExchange.REAL_EXCHANGE_MOEX:
      return 'REAL_EXCHANGE_MOEX';
    case RealExchange.REAL_EXCHANGE_RTS:
      return 'REAL_EXCHANGE_RTS';
    case RealExchange.REAL_EXCHANGE_OTC:
      return 'REAL_EXCHANGE_OTC';
    case RealExchange.REAL_EXCHANGE_DEALER:
      return 'REAL_EXCHANGE_DEALER';
    default:
      return 'UNKNOWN';
  }
}

/** Денежная сумма в определенной валюте. */
export interface MoneyValue {
  /** Строковый ISO-код валюты. */
  currency: string;
  /** Целая часть суммы, может быть отрицательным числом. */
  units: number;
  /** Дробная часть суммы, может быть отрицательным числом. */
  nano: number;
}

/** Котировка — денежная сумма без указания валюты. */
export interface Quotation {
  /** Целая часть суммы, может быть отрицательным числом. */
  units: number;
  /** Дробная часть суммы, может быть отрицательным числом. */
  nano: number;
}

export interface PingRequest {
  /** Время формирования запроса. */
  time?: Date | undefined;
}

export interface PingDelaySettings {
  /** Задержка (пинг) сообщений:  5000–180 000 миллисекунд. Значение по умолчанию — 120 000. */
  pingDelayMs?: number | undefined;
}

/** Проверка активности стрима. */
export interface Ping {
  /** Время проверки. */
  time: Date | undefined;
  /** Идентификатор соединения. */
  streamId: string;
  /** Время формирования запроса. */
  pingRequestTime?: Date | undefined;
}

export interface Page {
  /** Максимальное число возвращаемых записей. */
  limit: number;
  /** Порядковый номер страницы, начиная с 0. */
  pageNumber: number;
}

export interface PageResponse {
  /** Максимальное число возвращаемых записей. */
  limit: number;
  /** Порядковый номер страницы, начиная с 0. */
  pageNumber: number;
  /** Общее количество записей. */
  totalCount: number;
}

export interface ResponseMetadata {
  /** Идентификатор трекинга. */
  trackingId: string;
  /** Серверное время. */
  serverTime: Date | undefined;
}

export interface BrandData {
  /** Логотип инструмента. Имя файла для получения логотипа. */
  logoName: string;
  /** Цвет бренда. */
  logoBaseColor: string;
  /** Цвет текста для цвета логотипа бренда. */
  textColor: string;
}

export interface ErrorDetail {
  /** Код ошибки. */
  code: string;
  /** Описание ошибки. */
  message: string;
}

function createBaseMoneyValue(): MoneyValue {
  return { currency: '', units: 0, nano: 0 };
}

export const MoneyValue = {
  encode(message: MoneyValue, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.currency !== '') {
      writer.uint32(10).string(message.currency);
    }
    if (message.units !== 0) {
      writer.uint32(16).int64(message.units);
    }
    if (message.nano !== 0) {
      writer.uint32(24).int32(message.nano);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): MoneyValue {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseMoneyValue();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.currency = reader.string();
          break;
        case 2:
          message.units = longToNumber(reader.int64() as Long);
          break;
        case 3:
          message.nano = reader.int32();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): MoneyValue {
    return {
      currency: isSet(object.currency) ? String(object.currency) : '',
      units: isSet(object.units) ? Number(object.units) : 0,
      nano: isSet(object.nano) ? Number(object.nano) : 0,
    };
  },

  toJSON(message: MoneyValue): unknown {
    const obj: any = {};
    message.currency !== undefined && (obj.currency = message.currency);
    message.units !== undefined && (obj.units = Math.round(message.units));
    message.nano !== undefined && (obj.nano = Math.round(message.nano));
    return obj;
  },

  fromPartial(object: DeepPartial<MoneyValue>): MoneyValue {
    const message = createBaseMoneyValue();
    message.currency = object.currency ?? '';
    message.units = object.units ?? 0;
    message.nano = object.nano ?? 0;
    return message;
  },
};

function createBaseQuotation(): Quotation {
  return { units: 0, nano: 0 };
}

export const Quotation = {
  encode(message: Quotation, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.units !== 0) {
      writer.uint32(8).int64(message.units);
    }
    if (message.nano !== 0) {
      writer.uint32(16).int32(message.nano);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): Quotation {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQuotation();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.units = longToNumber(reader.int64() as Long);
          break;
        case 2:
          message.nano = reader.int32();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): Quotation {
    return {
      units: isSet(object.units) ? Number(object.units) : 0,
      nano: isSet(object.nano) ? Number(object.nano) : 0,
    };
  },

  toJSON(message: Quotation): unknown {
    const obj: any = {};
    message.units !== undefined && (obj.units = Math.round(message.units));
    message.nano !== undefined && (obj.nano = Math.round(message.nano));
    return obj;
  },

  fromPartial(object: DeepPartial<Quotation>): Quotation {
    const message = createBaseQuotation();
    message.units = object.units ?? 0;
    message.nano = object.nano ?? 0;
    return message;
  },
};

function createBasePingRequest(): PingRequest {
  return { time: undefined };
}

export const PingRequest = {
  encode(message: PingRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.time !== undefined) {
      Timestamp.encode(toTimestamp(message.time), writer.uint32(10).fork()).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): PingRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePingRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): PingRequest {
    return {
      time: isSet(object.time) ? fromJsonTimestamp(object.time) : undefined,
    };
  },

  toJSON(message: PingRequest): unknown {
    const obj: any = {};
    message.time !== undefined && (obj.time = message.time.toISOString());
    return obj;
  },

  fromPartial(object: DeepPartial<PingRequest>): PingRequest {
    const message = createBasePingRequest();
    message.time = object.time ?? undefined;
    return message;
  },
};

function createBasePingDelaySettings(): PingDelaySettings {
  return { pingDelayMs: undefined };
}

export const PingDelaySettings = {
  encode(message: PingDelaySettings, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.pingDelayMs !== undefined) {
      writer.uint32(120).int32(message.pingDelayMs);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): PingDelaySettings {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePingDelaySettings();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 15:
          message.pingDelayMs = reader.int32();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): PingDelaySettings {
    return {
      pingDelayMs: isSet(object.pingDelayMs) ? Number(object.pingDelayMs) : undefined,
    };
  },

  toJSON(message: PingDelaySettings): unknown {
    const obj: any = {};
    message.pingDelayMs !== undefined && (obj.pingDelayMs = Math.round(message.pingDelayMs));
    return obj;
  },

  fromPartial(object: DeepPartial<PingDelaySettings>): PingDelaySettings {
    const message = createBasePingDelaySettings();
    message.pingDelayMs = object.pingDelayMs ?? undefined;
    return message;
  },
};

function createBasePing(): Ping {
  return { time: undefined, streamId: '', pingRequestTime: undefined };
}

export const Ping = {
  encode(message: Ping, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.time !== undefined) {
      Timestamp.encode(toTimestamp(message.time), writer.uint32(10).fork()).ldelim();
    }
    if (message.streamId !== '') {
      writer.uint32(18).string(message.streamId);
    }
    if (message.pingRequestTime !== undefined) {
      Timestamp.encode(toTimestamp(message.pingRequestTime), writer.uint32(34).fork()).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): Ping {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePing();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
          break;
        case 2:
          message.streamId = reader.string();
          break;
        case 4:
          message.pingRequestTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): Ping {
    return {
      time: isSet(object.time) ? fromJsonTimestamp(object.time) : undefined,
      streamId: isSet(object.streamId) ? String(object.streamId) : '',
      pingRequestTime: isSet(object.pingRequestTime) ? fromJsonTimestamp(object.pingRequestTime) : undefined,
    };
  },

  toJSON(message: Ping): unknown {
    const obj: any = {};
    message.time !== undefined && (obj.time = message.time.toISOString());
    message.streamId !== undefined && (obj.streamId = message.streamId);
    message.pingRequestTime !== undefined && (obj.pingRequestTime = message.pingRequestTime.toISOString());
    return obj;
  },

  fromPartial(object: DeepPartial<Ping>): Ping {
    const message = createBasePing();
    message.time = object.time ?? undefined;
    message.streamId = object.streamId ?? '';
    message.pingRequestTime = object.pingRequestTime ?? undefined;
    return message;
  },
};

function createBasePage(): Page {
  return { limit: 0, pageNumber: 0 };
}

export const Page = {
  encode(message: Page, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.limit !== 0) {
      writer.uint32(8).int32(message.limit);
    }
    if (message.pageNumber !== 0) {
      writer.uint32(16).int32(message.pageNumber);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): Page {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePage();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.limit = reader.int32();
          break;
        case 2:
          message.pageNumber = reader.int32();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): Page {
    return {
      limit: isSet(object.limit) ? Number(object.limit) : 0,
      pageNumber: isSet(object.pageNumber) ? Number(object.pageNumber) : 0,
    };
  },

  toJSON(message: Page): unknown {
    const obj: any = {};
    message.limit !== undefined && (obj.limit = Math.round(message.limit));
    message.pageNumber !== undefined && (obj.pageNumber = Math.round(message.pageNumber));
    return obj;
  },

  fromPartial(object: DeepPartial<Page>): Page {
    const message = createBasePage();
    message.limit = object.limit ?? 0;
    message.pageNumber = object.pageNumber ?? 0;
    return message;
  },
};

function createBasePageResponse(): PageResponse {
  return { limit: 0, pageNumber: 0, totalCount: 0 };
}

export const PageResponse = {
  encode(message: PageResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.limit !== 0) {
      writer.uint32(8).int32(message.limit);
    }
    if (message.pageNumber !== 0) {
      writer.uint32(16).int32(message.pageNumber);
    }
    if (message.totalCount !== 0) {
      writer.uint32(24).int32(message.totalCount);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): PageResponse {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePageResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.limit = reader.int32();
          break;
        case 2:
          message.pageNumber = reader.int32();
          break;
        case 3:
          message.totalCount = reader.int32();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): PageResponse {
    return {
      limit: isSet(object.limit) ? Number(object.limit) : 0,
      pageNumber: isSet(object.pageNumber) ? Number(object.pageNumber) : 0,
      totalCount: isSet(object.totalCount) ? Number(object.totalCount) : 0,
    };
  },

  toJSON(message: PageResponse): unknown {
    const obj: any = {};
    message.limit !== undefined && (obj.limit = Math.round(message.limit));
    message.pageNumber !== undefined && (obj.pageNumber = Math.round(message.pageNumber));
    message.totalCount !== undefined && (obj.totalCount = Math.round(message.totalCount));
    return obj;
  },

  fromPartial(object: DeepPartial<PageResponse>): PageResponse {
    const message = createBasePageResponse();
    message.limit = object.limit ?? 0;
    message.pageNumber = object.pageNumber ?? 0;
    message.totalCount = object.totalCount ?? 0;
    return message;
  },
};

function createBaseResponseMetadata(): ResponseMetadata {
  return { trackingId: '', serverTime: undefined };
}

export const ResponseMetadata = {
  encode(message: ResponseMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.trackingId !== '') {
      writer.uint32(338).string(message.trackingId);
    }
    if (message.serverTime !== undefined) {
      Timestamp.encode(toTimestamp(message.serverTime), writer.uint32(346).fork()).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): ResponseMetadata {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseResponseMetadata();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 42:
          message.trackingId = reader.string();
          break;
        case 43:
          message.serverTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): ResponseMetadata {
    return {
      trackingId: isSet(object.trackingId) ? String(object.trackingId) : '',
      serverTime: isSet(object.serverTime) ? fromJsonTimestamp(object.serverTime) : undefined,
    };
  },

  toJSON(message: ResponseMetadata): unknown {
    const obj: any = {};
    message.trackingId !== undefined && (obj.trackingId = message.trackingId);
    message.serverTime !== undefined && (obj.serverTime = message.serverTime.toISOString());
    return obj;
  },

  fromPartial(object: DeepPartial<ResponseMetadata>): ResponseMetadata {
    const message = createBaseResponseMetadata();
    message.trackingId = object.trackingId ?? '';
    message.serverTime = object.serverTime ?? undefined;
    return message;
  },
};

function createBaseBrandData(): BrandData {
  return { logoName: '', logoBaseColor: '', textColor: '' };
}

export const BrandData = {
  encode(message: BrandData, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.logoName !== '') {
      writer.uint32(10).string(message.logoName);
    }
    if (message.logoBaseColor !== '') {
      writer.uint32(18).string(message.logoBaseColor);
    }
    if (message.textColor !== '') {
      writer.uint32(26).string(message.textColor);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): BrandData {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseBrandData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.logoName = reader.string();
          break;
        case 2:
          message.logoBaseColor = reader.string();
          break;
        case 3:
          message.textColor = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): BrandData {
    return {
      logoName: isSet(object.logoName) ? String(object.logoName) : '',
      logoBaseColor: isSet(object.logoBaseColor) ? String(object.logoBaseColor) : '',
      textColor: isSet(object.textColor) ? String(object.textColor) : '',
    };
  },

  toJSON(message: BrandData): unknown {
    const obj: any = {};
    message.logoName !== undefined && (obj.logoName = message.logoName);
    message.logoBaseColor !== undefined && (obj.logoBaseColor = message.logoBaseColor);
    message.textColor !== undefined && (obj.textColor = message.textColor);
    return obj;
  },

  fromPartial(object: DeepPartial<BrandData>): BrandData {
    const message = createBaseBrandData();
    message.logoName = object.logoName ?? '';
    message.logoBaseColor = object.logoBaseColor ?? '';
    message.textColor = object.textColor ?? '';
    return message;
  },
};

function createBaseErrorDetail(): ErrorDetail {
  return { code: '', message: '' };
}

export const ErrorDetail = {
  encode(message: ErrorDetail, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.code !== '') {
      writer.uint32(10).string(message.code);
    }
    if (message.message !== '') {
      writer.uint32(26).string(message.message);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): ErrorDetail {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseErrorDetail();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.code = reader.string();
          break;
        case 3:
          message.message = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): ErrorDetail {
    return {
      code: isSet(object.code) ? String(object.code) : '',
      message: isSet(object.message) ? String(object.message) : '',
    };
  },

  toJSON(message: ErrorDetail): unknown {
    const obj: any = {};
    message.code !== undefined && (obj.code = message.code);
    message.message !== undefined && (obj.message = message.message);
    return obj;
  },

  fromPartial(object: DeepPartial<ErrorDetail>): ErrorDetail {
    const message = createBaseErrorDetail();
    message.code = object.code ?? '';
    message.message = object.message ?? '';
    return message;
  },
};

declare var self: any | undefined;
declare var window: any | undefined;
declare var global: any | undefined;
var globalThis: any = (() => {
  if (typeof globalThis !== 'undefined') return globalThis;
  if (typeof self !== 'undefined') return self;
  if (typeof window !== 'undefined') return window;
  if (typeof global !== 'undefined') return global;
  throw 'Unable to locate global object';
})();

type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;

export type DeepPartial<T> = T extends Builtin
  ? T
  : T extends Array<infer U>
  ? Array<DeepPartial<U>>
  : T extends ReadonlyArray<infer U>
  ? ReadonlyArray<DeepPartial<U>>
  : T extends {}
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>;

function toTimestamp(date: Date): Timestamp {
  const seconds = date.getTime() / 1_000;
  const nanos = (date.getTime() % 1_000) * 1_000_000;
  return { seconds, nanos };
}

function fromTimestamp(t: Timestamp): Date {
  let millis = t.seconds * 1_000;
  millis += t.nanos / 1_000_000;
  return new Date(millis);
}

function fromJsonTimestamp(o: any): Date {
  if (o instanceof Date) {
    return o;
  } else if (typeof o === 'string') {
    return new Date(o);
  } else {
    return fromTimestamp(Timestamp.fromJSON(o));
  }
}

function longToNumber(long: Long): number {
  if (long.gt(Number.MAX_SAFE_INTEGER)) {
    throw new globalThis.Error('Value is larger than Number.MAX_SAFE_INTEGER');
  }
  return long.toNumber();
}

if (_m0.util.Long !== Long) {
  _m0.util.Long = Long as any;
  _m0.configure();
}

function isSet(value: any): boolean {
  return value !== null && value !== undefined;
}