@1amageek/tradable/lib/Manager.d.ts

Cloud Firestore model framework for TypeScript - Google

import { StockManager } from './stockManager';
import { BalanceManager } from './balanceManager';
import { OrderManager } from './orderManager';
import { PayoutManager } from './PayoutManager';
import { SKUProtocol, OrderItemProtocol, OrderProtocol, TradeTransactionProtocol, BalanceTransactionProtocol, AccountProtocol, PaymentOptions, Currency, TransferOptions, UserProtocol, PayoutOptions, TransactionDelegate, TradeDelegate, InventoryStockProtocol, PayoutProtocol } from "./index";
import { DocumentReference, Transaction } from '@google-cloud/firestore';
export type ReserveResult = {
    authorizeResult?: any;
};
export type ReserveCancelResult = {
    authorizeCancelResult?: any;
};
export type TradeResult<T extends TradeTransactionProtocol> = {
    tradeTransactions: T[][];
};
export type CaptureResult = {
    balanceTransaction?: BalanceTransactionProtocol;
    paymentResult?: any;
    refundResult?: any;
};
export type CheckoutResult<T extends TradeTransactionProtocol> = {
    balanceTransaction?: BalanceTransactionProtocol;
    tradeTransactions: T[][];
    paymentResult?: any;
    refundResult?: any;
};
export type CheckoutChangeResult<T extends TradeTransactionProtocol> = {
    balanceTransaction?: BalanceTransactionProtocol;
    tradeTransactions: T[][];
    refundResult: any;
};
export type CheckoutCancelResult<T extends TradeTransactionProtocol> = {
    balanceTransaction?: BalanceTransactionProtocol;
    tradeTransactions: T[];
    refundResult: any;
};
export type TransferResult = {
    balanceTransaction?: BalanceTransactionProtocol;
    transferResult?: any;
    transferCancelResult?: any;
};
export type TransferCancelResult = {
    balanceTransaction?: BalanceTransactionProtocol;
    transferCancelResult?: any;
};
export type PayoutResult = {
    balanceTransaction?: BalanceTransactionProtocol;
    payoutResult?: any;
};
export declare class Manager<InventoryStock extends InventoryStockProtocol, SKU extends SKUProtocol<InventoryStock>, OrderItem extends OrderItemProtocol, Order extends OrderProtocol<OrderItem>, TradeTransaction extends TradeTransactionProtocol, BalanceTransaction extends BalanceTransactionProtocol, Payout extends PayoutProtocol, User extends UserProtocol<Order, OrderItem, TradeTransaction>, Account extends AccountProtocol<BalanceTransaction, Payout>> {
    private _InventoryStock;
    private _SKU;
    private _OrderItem;
    private _Order;
    private _TradeTransaction;
    private _BalanceTransaction;
    private _Payout;
    private _User;
    private _Account;
    stockManager: StockManager<Order, OrderItem, User, InventoryStock, SKU, TradeTransaction>;
    balanceManager: BalanceManager<BalanceTransaction, Payout, Account>;
    orderManager: OrderManager<Order, OrderItem, User, TradeTransaction>;
    payoutManager: PayoutManager<BalanceTransaction, Payout, Account>;
    delegate?: TransactionDelegate;
    tradeDelegate?: TradeDelegate;
    constructor(inventoryStock: {
        new (id?: string, value?: {
            [key: string]: any;
        }): InventoryStock;
    }, sku: {
        new (id?: string, value?: {
            [key: string]: any;
        }): SKU;
    }, orderItem: {
        new (id?: string, value?: {
            [key: string]: any;
        }): OrderItem;
    }, order: {
        new (id?: string, value?: {
            [key: string]: any;
        }): Order;
    }, tradeTransaction: {
        new (id?: string, value?: {
            [key: string]: any;
        }): TradeTransaction;
    }, balanceTransaction: {
        new (id?: string, value?: {
            [key: string]: any;
        }): BalanceTransaction;
    }, payout: {
        new (id?: string, value?: {
            [key: string]: any;
        }): Payout;
    }, user: {
        new (id?: string, value?: {
            [key: string]: any;
        }): User;
    }, account: {
        new (id?: string, value?: {
            [key: string]: any;
        }): Account;
    });
    runTransaction(order: DocumentReference | Order, option: any, block: (order: Order, option: any, transaction: Transaction) => Promise<any>): Promise<any>;
    /**
     * 決済処理、在庫処理を同時に行う
     * @param order
     * @param orderItems
     * @param paymentOptions
     */
    checkout(orderReference: DocumentReference, paymentOptions: PaymentOptions): Promise<CheckoutResult<TradeTransaction>>;
    /**
     * 支払い後、支払いをキャンセルする
     *
     * @param order
     * @param orderItems
     * @param paymentOptions
     */
    checkoutCancel(order: Order, orderItems: OrderItem[], paymentOptions: PaymentOptions): Promise<unknown>;
    /**
     * 支払い後、支払いの内容を変更する
     *
     * @param order
     * @param orderItem
     * @param itemID
     * @param paymentOptions
     */
    checkoutChange(order: Order, orderItem: OrderItem, item: FirebaseFirestore.DocumentReference, paymentOptions: PaymentOptions): Promise<unknown>;
    transfer(order: Order, transferOptions: TransferOptions): Promise<unknown>;
    transferCancel(order: Order, transferOptions: TransferOptions): Promise<void>;
    request(payout: Payout, payoutOptions?: PayoutOptions): Promise<void>;
    payout(payout: Payout, payoutOptions: PayoutOptions): Promise<void>;
    payoutCancel(accountID: string, currency: Currency, amount: number, payoutOptions: PayoutOptions): Promise<void>;
}