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

Node.js SDK for Tinkoff Invest API

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SandboxServiceDefinition = exports.SandboxPayInResponse = exports.SandboxPayInRequest = exports.CloseSandboxAccountResponse = exports.CloseSandboxAccountRequest = exports.OpenSandboxAccountResponse = exports.OpenSandboxAccountRequest = exports.protobufPackage = void 0;
const minimal_js_1 = __importDefault(require("protobufjs/minimal.js"));
const common_js_1 = require("./common.js");
const operations_js_1 = require("./operations.js");
const orders_js_1 = require("./orders.js");
const stoporders_js_1 = require("./stoporders.js");
const users_js_1 = require("./users.js");
exports.protobufPackage = "tinkoff.public.invest.api.contract.v1";
function createBaseOpenSandboxAccountRequest() {
    return { name: undefined };
}
exports.OpenSandboxAccountRequest = {
    encode(message, writer = minimal_js_1.default.Writer.create()) {
        if (message.name !== undefined) {
            writer.uint32(10).string(message.name);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_js_1.default.Reader ? input : minimal_js_1.default.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: "" };
}
exports.OpenSandboxAccountResponse = {
    encode(message, writer = minimal_js_1.default.Writer.create()) {
        if (message.accountId !== "") {
            writer.uint32(10).string(message.accountId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_js_1.default.Reader ? input : minimal_js_1.default.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: "" };
}
exports.CloseSandboxAccountRequest = {
    encode(message, writer = minimal_js_1.default.Writer.create()) {
        if (message.accountId !== "") {
            writer.uint32(10).string(message.accountId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_js_1.default.Reader ? input : minimal_js_1.default.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 {};
}
exports.CloseSandboxAccountResponse = {
    encode(_, writer = minimal_js_1.default.Writer.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_js_1.default.Reader ? input : minimal_js_1.default.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 };
}
exports.SandboxPayInRequest = {
    encode(message, writer = minimal_js_1.default.Writer.create()) {
        if (message.accountId !== "") {
            writer.uint32(10).string(message.accountId);
        }
        if (message.amount !== undefined) {
            common_js_1.MoneyValue.encode(message.amount, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_js_1.default.Reader ? input : minimal_js_1.default.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 = common_js_1.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) ? common_js_1.MoneyValue.fromJSON(object.amount) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.accountId !== "") {
            obj.accountId = message.accountId;
        }
        if (message.amount !== undefined) {
            obj.amount = common_js_1.MoneyValue.toJSON(message.amount);
        }
        return obj;
    },
};
function createBaseSandboxPayInResponse() {
    return { balance: undefined };
}
exports.SandboxPayInResponse = {
    encode(message, writer = minimal_js_1.default.Writer.create()) {
        if (message.balance !== undefined) {
            common_js_1.MoneyValue.encode(message.balance, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_js_1.default.Reader ? input : minimal_js_1.default.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 = common_js_1.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) ? common_js_1.MoneyValue.fromJSON(object.balance) : undefined };
    },
    toJSON(message) {
        const obj = {};
        if (message.balance !== undefined) {
            obj.balance = common_js_1.MoneyValue.toJSON(message.balance);
        }
        return obj;
    },
};
exports.SandboxServiceDefinition = {
    name: "SandboxService",
    fullName: "tinkoff.public.invest.api.contract.v1.SandboxService",
    methods: {
        /** OpenSandboxAccount — зарегистрировать счет */
        openSandboxAccount: {
            name: "OpenSandboxAccount",
            requestType: exports.OpenSandboxAccountRequest,
            requestStream: false,
            responseType: exports.OpenSandboxAccountResponse,
            responseStream: false,
            options: {},
        },
        /** GetSandboxAccounts — счета пользователя */
        getSandboxAccounts: {
            name: "GetSandboxAccounts",
            requestType: users_js_1.GetAccountsRequest,
            requestStream: false,
            responseType: users_js_1.GetAccountsResponse,
            responseStream: false,
            options: {},
        },
        /** CloseSandboxAccount — закрыть счет */
        closeSandboxAccount: {
            name: "CloseSandboxAccount",
            requestType: exports.CloseSandboxAccountRequest,
            requestStream: false,
            responseType: exports.CloseSandboxAccountResponse,
            responseStream: false,
            options: {},
        },
        /** PostSandboxOrder — выставить заявку */
        postSandboxOrder: {
            name: "PostSandboxOrder",
            requestType: orders_js_1.PostOrderRequest,
            requestStream: false,
            responseType: orders_js_1.PostOrderResponse,
            responseStream: false,
            options: {},
        },
        /**
         * PostSandboxOrderAsync — выставить заявку асинхронным методом
         * Особенности работы приведены в [статье](/invest/services/orders/async).
         */
        postSandboxOrderAsync: {
            name: "PostSandboxOrderAsync",
            requestType: orders_js_1.PostOrderAsyncRequest,
            requestStream: false,
            responseType: orders_js_1.PostOrderAsyncResponse,
            responseStream: false,
            options: {},
        },
        /** ReplaceSandboxOrder — изменить выставленную заявку */
        replaceSandboxOrder: {
            name: "ReplaceSandboxOrder",
            requestType: orders_js_1.ReplaceOrderRequest,
            requestStream: false,
            responseType: orders_js_1.PostOrderResponse,
            responseStream: false,
            options: {},
        },
        /** GetSandboxOrders — получить список активных заявок по счету */
        getSandboxOrders: {
            name: "GetSandboxOrders",
            requestType: orders_js_1.GetOrdersRequest,
            requestStream: false,
            responseType: orders_js_1.GetOrdersResponse,
            responseStream: false,
            options: {},
        },
        /** CancelSandboxOrder — отменить заявку */
        cancelSandboxOrder: {
            name: "CancelSandboxOrder",
            requestType: orders_js_1.CancelOrderRequest,
            requestStream: false,
            responseType: orders_js_1.CancelOrderResponse,
            responseStream: false,
            options: {},
        },
        /** GetSandboxOrderState — получить статус торгового поручения */
        getSandboxOrderState: {
            name: "GetSandboxOrderState",
            requestType: orders_js_1.GetOrderStateRequest,
            requestStream: false,
            responseType: orders_js_1.OrderState,
            responseStream: false,
            options: {},
        },
        /** GetSandboxOrderPrice — получить предварительную стоимость для лимитной заявки */
        getSandboxOrderPrice: {
            name: "GetSandboxOrderPrice",
            requestType: orders_js_1.GetOrderPriceRequest,
            requestStream: false,
            responseType: orders_js_1.GetOrderPriceResponse,
            responseStream: false,
            options: {},
        },
        /** GetSandboxPositions — список позиций по счету */
        getSandboxPositions: {
            name: "GetSandboxPositions",
            requestType: operations_js_1.PositionsRequest,
            requestStream: false,
            responseType: operations_js_1.PositionsResponse,
            responseStream: false,
            options: {},
        },
        /**
         * GetSandboxOperations — список операций по счету
         * При работе с методом учитывайте [особенности взаимодействия](/invest/services/operations/operations_problems).
         */
        getSandboxOperations: {
            name: "GetSandboxOperations",
            requestType: operations_js_1.OperationsRequest,
            requestStream: false,
            responseType: operations_js_1.OperationsResponse,
            responseStream: false,
            options: {},
        },
        /**
         * GetSandboxOperationsByCursor — список операций по счету с пагинацией
         * При работе с методом учитывайте [особенности взаимодействия](/invest/services/operations/operations_problems).
         */
        getSandboxOperationsByCursor: {
            name: "GetSandboxOperationsByCursor",
            requestType: operations_js_1.GetOperationsByCursorRequest,
            requestStream: false,
            responseType: operations_js_1.GetOperationsByCursorResponse,
            responseStream: false,
            options: {},
        },
        /** GetSandboxPortfolio — портфель по счету */
        getSandboxPortfolio: {
            name: "GetSandboxPortfolio",
            requestType: operations_js_1.PortfolioRequest,
            requestStream: false,
            responseType: operations_js_1.PortfolioResponse,
            responseStream: false,
            options: {},
        },
        /** SandboxPayIn — пополнить счет. */
        sandboxPayIn: {
            name: "SandboxPayIn",
            requestType: exports.SandboxPayInRequest,
            requestStream: false,
            responseType: exports.SandboxPayInResponse,
            responseStream: false,
            options: {},
        },
        /** GetSandboxWithdrawLimits — доступный остаток для вывода средств */
        getSandboxWithdrawLimits: {
            name: "GetSandboxWithdrawLimits",
            requestType: operations_js_1.WithdrawLimitsRequest,
            requestStream: false,
            responseType: operations_js_1.WithdrawLimitsResponse,
            responseStream: false,
            options: {},
        },
        /** GetSandboxMaxLots — расчет количества доступных для покупки/продажи лотов */
        getSandboxMaxLots: {
            name: "GetSandboxMaxLots",
            requestType: orders_js_1.GetMaxLotsRequest,
            requestStream: false,
            responseType: orders_js_1.GetMaxLotsResponse,
            responseStream: false,
            options: {},
        },
        /** PostSandboxStopOrder — выставить стоп-заявку */
        postSandboxStopOrder: {
            name: "PostSandboxStopOrder",
            requestType: stoporders_js_1.PostStopOrderRequest,
            requestStream: false,
            responseType: stoporders_js_1.PostStopOrderResponse,
            responseStream: false,
            options: {},
        },
        /** GetSandboxStopOrders — получить список активных стоп-заявок по счету */
        getSandboxStopOrders: {
            name: "GetSandboxStopOrders",
            requestType: stoporders_js_1.GetStopOrdersRequest,
            requestStream: false,
            responseType: stoporders_js_1.GetStopOrdersResponse,
            responseStream: false,
            options: {},
        },
        /** CancelSandboxStopOrder — отменить стоп-заявку */
        cancelSandboxStopOrder: {
            name: "CancelSandboxStopOrder",
            requestType: stoporders_js_1.CancelStopOrderRequest,
            requestStream: false,
            responseType: stoporders_js_1.CancelStopOrderResponse,
            responseStream: false,
            options: {},
        },
    },
};
function isSet(value) {
    return value !== null && value !== undefined;
}
//# sourceMappingURL=sandbox.js.map