tinkoff-invest-api/dist/generated/sandbox.js

Node.js SDK for Tinkoff Invest API

import _m0 from "protobufjs/minimal.js";
import { MoneyValue } from "./common.js";
import { GetOperationsByCursorRequest, GetOperationsByCursorResponse, OperationsRequest, OperationsResponse, PortfolioRequest, PortfolioResponse, PositionsRequest, PositionsResponse, WithdrawLimitsRequest, WithdrawLimitsResponse, } from "./operations.js";
import { CancelOrderRequest, CancelOrderResponse, GetMaxLotsRequest, GetMaxLotsResponse, GetOrderPriceRequest, GetOrderPriceResponse, GetOrdersRequest, GetOrdersResponse, GetOrderStateRequest, OrderState, PostOrderAsyncRequest, PostOrderAsyncResponse, PostOrderRequest, PostOrderResponse, ReplaceOrderRequest, } from "./orders.js";
import { CancelStopOrderRequest, CancelStopOrderResponse, GetStopOrdersRequest, GetStopOrdersResponse, PostStopOrderRequest, PostStopOrderResponse, } from "./stoporders.js";
import { GetAccountsRequest, GetAccountsResponse } from "./users.js";
export const protobufPackage = "tinkoff.public.invest.api.contract.v1";
function createBaseOpenSandboxAccountRequest() {
    return { name: undefined };
}
export const OpenSandboxAccountRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.name !== undefined) {
            writer.uint32(10).string(message.name);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.name = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { name: isSet(object.name) ? globalThis.String(object.name) : undefined };
    },
    toJSON(message) {
        const obj = {};
        if (message.name !== undefined) {
            obj.name = message.name;
        }
        return obj;
    },
};
function createBaseOpenSandboxAccountResponse() {
    return { accountId: "" };
}
export const OpenSandboxAccountResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.accountId !== "") {
            writer.uint32(10).string(message.accountId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.accountId = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { accountId: isSet(object.accountId) ? globalThis.String(object.accountId) : "" };
    },
    toJSON(message) {
        const obj = {};
        if (message.accountId !== "") {
            obj.accountId = message.accountId;
        }
        return obj;
    },
};
function createBaseCloseSandboxAccountRequest() {
    return { accountId: "" };
}
export const CloseSandboxAccountRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.accountId !== "") {
            writer.uint32(10).string(message.accountId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.accountId = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { accountId: isSet(object.accountId) ? globalThis.String(object.accountId) : "" };
    },
    toJSON(message) {
        const obj = {};
        if (message.accountId !== "") {
            obj.accountId = message.accountId;
        }
        return obj;
    },
};
function createBaseCloseSandboxAccountResponse() {
    return {};
}
export const CloseSandboxAccountResponse = {
    encode(_, writer = _m0.Writer.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCloseSandboxAccountResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(_) {
        return {};
    },
    toJSON(_) {
        const obj = {};
        return obj;
    },
};
function createBaseSandboxPayInRequest() {
    return { accountId: "", amount: undefined };
}
export const SandboxPayInRequest = {
    encode(message, writer = _m0.Writer.create()) {
        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, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.accountId = reader.string();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.amount = MoneyValue.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            accountId: isSet(object.accountId) ? globalThis.String(object.accountId) : "",
            amount: isSet(object.amount) ? MoneyValue.fromJSON(object.amount) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.accountId !== "") {
            obj.accountId = message.accountId;
        }
        if (message.amount !== undefined) {
            obj.amount = MoneyValue.toJSON(message.amount);
        }
        return obj;
    },
};
function createBaseSandboxPayInResponse() {
    return { balance: undefined };
}
export const SandboxPayInResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.balance !== undefined) {
            MoneyValue.encode(message.balance, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.balance = MoneyValue.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { balance: isSet(object.balance) ? MoneyValue.fromJSON(object.balance) : undefined };
    },
    toJSON(message) {
        const obj = {};
        if (message.balance !== undefined) {
            obj.balance = MoneyValue.toJSON(message.balance);
        }
        return obj;
    },
};
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: {},
        },
    },
};
function isSet(value) {
    return value !== null && value !== undefined;
}
//# sourceMappingURL=sandbox.js.map