/* eslint-disable */
import Long from 'long';
import * as _m0 from 'protobufjs/minimal';
import { MoneyValue } from './common';
import { GetAccountsRequest, GetAccountsResponse } from './users';
import {
  PostOrderRequest,
  PostOrderResponse,
  PostOrderAsyncRequest,
  PostOrderAsyncResponse,
  ReplaceOrderRequest,
  GetOrdersRequest,
  GetOrdersResponse,
  CancelOrderRequest,
  CancelOrderResponse,
  GetOrderStateRequest,
  OrderState,
  GetOrderPriceRequest,
  GetOrderPriceResponse,
  GetMaxLotsRequest,
  GetMaxLotsResponse,
} from './orders';
import {
  PositionsRequest,
  PositionsResponse,
  OperationsRequest,
  OperationsResponse,
  GetOperationsByCursorRequest,
  GetOperationsByCursorResponse,
  PortfolioRequest,
  PortfolioResponse,
  WithdrawLimitsRequest,
  WithdrawLimitsResponse,
} from './operations';
import {
  PostStopOrderRequest,
  PostStopOrderResponse,
  GetStopOrdersRequest,
  GetStopOrdersResponse,
  CancelStopOrderRequest,
  CancelStopOrderResponse,
} from './stoporders';

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

/** Запрос открытия счета в песочнице. */
export interface OpenSandboxAccountRequest {
  /** Название счета */
  name?: string | undefined;
}

/** Номер открытого счета в песочнице. */
export interface OpenSandboxAccountResponse {
  /** Номер счета */
  accountId: string;
}

/** Запрос закрытия счета в песочнице. */
export interface CloseSandboxAccountRequest {
  /** Номер счета */
  accountId: string;
}

/** Результат закрытия счета в песочнице. */
export interface CloseSandboxAccountResponse {}

/** Запрос пополнения счета в песочнице. */
export interface SandboxPayInRequest {
  /** Номер счета */
  accountId: string;
  /** Сумма пополнения счета в рублях */
  amount: MoneyValue | undefined;
}

/** Результат пополнения счета, текущий баланс. */
export interface SandboxPayInResponse {
  /** Текущий баланс счета */
  balance: MoneyValue | undefined;
}

function createBaseOpenSandboxAccountRequest(): OpenSandboxAccountRequest {
  return { name: undefined };
}

export const OpenSandboxAccountRequest = {
  encode(message: OpenSandboxAccountRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.name !== undefined) {
      writer.uint32(10).string(message.name);
    }
    return writer;
  },

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

  fromJSON(object: any): OpenSandboxAccountRequest {
    return {
      name: isSet(object.name) ? String(object.name) : undefined,
    };
  },

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

  fromPartial(object: DeepPartial<OpenSandboxAccountRequest>): OpenSandboxAccountRequest {
    const message = createBaseOpenSandboxAccountRequest();
    message.name = object.name ?? undefined;
    return message;
  },
};

function createBaseOpenSandboxAccountResponse(): OpenSandboxAccountResponse {
  return { accountId: '' };
}

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

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

  fromJSON(object: any): OpenSandboxAccountResponse {
    return {
      accountId: isSet(object.accountId) ? String(object.accountId) : '',
    };
  },

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

  fromPartial(object: DeepPartial<OpenSandboxAccountResponse>): OpenSandboxAccountResponse {
    const message = createBaseOpenSandboxAccountResponse();
    message.accountId = object.accountId ?? '';
    return message;
  },
};

function createBaseCloseSandboxAccountRequest(): CloseSandboxAccountRequest {
  return { accountId: '' };
}

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

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

  fromJSON(object: any): CloseSandboxAccountRequest {
    return {
      accountId: isSet(object.accountId) ? String(object.accountId) : '',
    };
  },

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

  fromPartial(object: DeepPartial<CloseSandboxAccountRequest>): CloseSandboxAccountRequest {
    const message = createBaseCloseSandboxAccountRequest();
    message.accountId = object.accountId ?? '';
    return message;
  },
};

function createBaseCloseSandboxAccountResponse(): CloseSandboxAccountResponse {
  return {};
}

export const CloseSandboxAccountResponse = {
  encode(_: CloseSandboxAccountResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    return writer;
  },

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

  fromJSON(_: any): CloseSandboxAccountResponse {
    return {};
  },

  toJSON(_: CloseSandboxAccountResponse): unknown {
    const obj: any = {};
    return obj;
  },

  fromPartial(_: DeepPartial<CloseSandboxAccountResponse>): CloseSandboxAccountResponse {
    const message = createBaseCloseSandboxAccountResponse();
    return message;
  },
};

function createBaseSandboxPayInRequest(): SandboxPayInRequest {
  return { accountId: '', amount: undefined };
}

export const SandboxPayInRequest = {
  encode(message: SandboxPayInRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.accountId !== '') {
      writer.uint32(10).string(message.accountId);
    }
    if (message.amount !== undefined) {
      MoneyValue.encode(message.amount, writer.uint32(18).fork()).ldelim();
    }
    return writer;
  },

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

  fromJSON(object: any): SandboxPayInRequest {
    return {
      accountId: isSet(object.accountId) ? String(object.accountId) : '',
      amount: isSet(object.amount) ? MoneyValue.fromJSON(object.amount) : undefined,
    };
  },

  toJSON(message: SandboxPayInRequest): unknown {
    const obj: any = {};
    message.accountId !== undefined && (obj.accountId = message.accountId);
    message.amount !== undefined && (obj.amount = message.amount ? MoneyValue.toJSON(message.amount) : undefined);
    return obj;
  },

  fromPartial(object: DeepPartial<SandboxPayInRequest>): SandboxPayInRequest {
    const message = createBaseSandboxPayInRequest();
    message.accountId = object.accountId ?? '';
    message.amount =
      object.amount !== undefined && object.amount !== null ? MoneyValue.fromPartial(object.amount) : undefined;
    return message;
  },
};

function createBaseSandboxPayInResponse(): SandboxPayInResponse {
  return { balance: undefined };
}

export const SandboxPayInResponse = {
  encode(message: SandboxPayInResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.balance !== undefined) {
      MoneyValue.encode(message.balance, writer.uint32(10).fork()).ldelim();
    }
    return writer;
  },

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

  fromJSON(object: any): SandboxPayInResponse {
    return {
      balance: isSet(object.balance) ? MoneyValue.fromJSON(object.balance) : undefined,
    };
  },

  toJSON(message: SandboxPayInResponse): unknown {
    const obj: any = {};
    message.balance !== undefined && (obj.balance = message.balance ? MoneyValue.toJSON(message.balance) : undefined);
    return obj;
  },

  fromPartial(object: DeepPartial<SandboxPayInResponse>): SandboxPayInResponse {
    const message = createBaseSandboxPayInResponse();
    message.balance =
      object.balance !== undefined && object.balance !== null ? MoneyValue.fromPartial(object.balance) : undefined;
    return message;
  },
};

/** Методы для работы с песочницей T-Invest API */
export type SandboxServiceDefinition = typeof SandboxServiceDefinition;
export const SandboxServiceDefinition = {
  name: 'SandboxService',
  fullName: 'tinkoff.public.invest.api.contract.v1.SandboxService',
  methods: {
    /** OpenSandboxAccount — зарегистрировать счет */
    openSandboxAccount: {
      name: 'OpenSandboxAccount',
      requestType: OpenSandboxAccountRequest,
      requestStream: false,
      responseType: OpenSandboxAccountResponse,
      responseStream: false,
      options: {},
    },
    /** GetSandboxAccounts — счета пользователя */
    getSandboxAccounts: {
      name: 'GetSandboxAccounts',
      requestType: GetAccountsRequest,
      requestStream: false,
      responseType: GetAccountsResponse,
      responseStream: false,
      options: {},
    },
    /** CloseSandboxAccount — закрыть счет */
    closeSandboxAccount: {
      name: 'CloseSandboxAccount',
      requestType: CloseSandboxAccountRequest,
      requestStream: false,
      responseType: CloseSandboxAccountResponse,
      responseStream: false,
      options: {},
    },
    /** PostSandboxOrder — выставить заявку */
    postSandboxOrder: {
      name: 'PostSandboxOrder',
      requestType: PostOrderRequest,
      requestStream: false,
      responseType: PostOrderResponse,
      responseStream: false,
      options: {},
    },
    /**
     * PostSandboxOrderAsync — выставить заявку асинхронным методом
     * Особенности работы приведены в [статье](/invest/services/orders/async).
     */
    postSandboxOrderAsync: {
      name: 'PostSandboxOrderAsync',
      requestType: PostOrderAsyncRequest,
      requestStream: false,
      responseType: PostOrderAsyncResponse,
      responseStream: false,
      options: {},
    },
    /** ReplaceSandboxOrder — изменить выставленную заявку */
    replaceSandboxOrder: {
      name: 'ReplaceSandboxOrder',
      requestType: ReplaceOrderRequest,
      requestStream: false,
      responseType: PostOrderResponse,
      responseStream: false,
      options: {},
    },
    /** GetSandboxOrders — получить список активных заявок по счету */
    getSandboxOrders: {
      name: 'GetSandboxOrders',
      requestType: GetOrdersRequest,
      requestStream: false,
      responseType: GetOrdersResponse,
      responseStream: false,
      options: {},
    },
    /** CancelSandboxOrder — отменить заявку */
    cancelSandboxOrder: {
      name: 'CancelSandboxOrder',
      requestType: CancelOrderRequest,
      requestStream: false,
      responseType: CancelOrderResponse,
      responseStream: false,
      options: {},
    },
    /** GetSandboxOrderState — получить статус торгового поручения */
    getSandboxOrderState: {
      name: 'GetSandboxOrderState',
      requestType: GetOrderStateRequest,
      requestStream: false,
      responseType: OrderState,
      responseStream: false,
      options: {},
    },
    /** GetSandboxOrderPrice — получить предварительную стоимость для лимитной заявки */
    getSandboxOrderPrice: {
      name: 'GetSandboxOrderPrice',
      requestType: GetOrderPriceRequest,
      requestStream: false,
      responseType: GetOrderPriceResponse,
      responseStream: false,
      options: {},
    },
    /** GetSandboxPositions — список позиций по счету */
    getSandboxPositions: {
      name: 'GetSandboxPositions',
      requestType: PositionsRequest,
      requestStream: false,
      responseType: PositionsResponse,
      responseStream: false,
      options: {},
    },
    /**
     * GetSandboxOperations — список операций по счету
     * При работе с методом учитывайте [особенности взаимодействия](/invest/services/operations/operations_problems).
     */
    getSandboxOperations: {
      name: 'GetSandboxOperations',
      requestType: OperationsRequest,
      requestStream: false,
      responseType: OperationsResponse,
      responseStream: false,
      options: {},
    },
    /**
     * GetSandboxOperationsByCursor — список операций по счету с пагинацией
     * При работе с методом учитывайте [особенности взаимодействия](/invest/services/operations/operations_problems).
     */
    getSandboxOperationsByCursor: {
      name: 'GetSandboxOperationsByCursor',
      requestType: GetOperationsByCursorRequest,
      requestStream: false,
      responseType: GetOperationsByCursorResponse,
      responseStream: false,
      options: {},
    },
    /** GetSandboxPortfolio — портфель по счету */
    getSandboxPortfolio: {
      name: 'GetSandboxPortfolio',
      requestType: PortfolioRequest,
      requestStream: false,
      responseType: PortfolioResponse,
      responseStream: false,
      options: {},
    },
    /** SandboxPayIn — пополнить счет. */
    sandboxPayIn: {
      name: 'SandboxPayIn',
      requestType: SandboxPayInRequest,
      requestStream: false,
      responseType: SandboxPayInResponse,
      responseStream: false,
      options: {},
    },
    /** GetSandboxWithdrawLimits — доступный остаток для вывода средств */
    getSandboxWithdrawLimits: {
      name: 'GetSandboxWithdrawLimits',
      requestType: WithdrawLimitsRequest,
      requestStream: false,
      responseType: WithdrawLimitsResponse,
      responseStream: false,
      options: {},
    },
    /** GetSandboxMaxLots — расчет количества доступных для покупки/продажи лотов */
    getSandboxMaxLots: {
      name: 'GetSandboxMaxLots',
      requestType: GetMaxLotsRequest,
      requestStream: false,
      responseType: GetMaxLotsResponse,
      responseStream: false,
      options: {},
    },
    /** PostSandboxStopOrder — выставить стоп-заявку */
    postSandboxStopOrder: {
      name: 'PostSandboxStopOrder',
      requestType: PostStopOrderRequest,
      requestStream: false,
      responseType: PostStopOrderResponse,
      responseStream: false,
      options: {},
    },
    /** GetSandboxStopOrders — получить список активных стоп-заявок по счету */
    getSandboxStopOrders: {
      name: 'GetSandboxStopOrders',
      requestType: GetStopOrdersRequest,
      requestStream: false,
      responseType: GetStopOrdersResponse,
      responseStream: false,
      options: {},
    },
    /** CancelSandboxStopOrder — отменить стоп-заявку */
    cancelSandboxStopOrder: {
      name: 'CancelSandboxStopOrder',
      requestType: CancelStopOrderRequest,
      requestStream: false,
      responseType: CancelStopOrderResponse,
      responseStream: false,
      options: {},
    },
  },
} as const;

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>;

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

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