@1amageek/tradable
Version:
Cloud Firestore model framework for TypeScript - Google
273 lines (272 loc) • 9.89 kB
TypeScript
import * as Pring from 'pring-admin';
import * as admin from 'firebase-admin';
import * as FirebaseFirestore from '@google-cloud/firestore';
import { Manager, ReserveResult, CheckoutResult, CheckoutChangeResult, CheckoutCancelResult, TransferResult, TransferCancelResult } from './manager';
import { Currency } from './currency';
export { Currency, Manager, ReserveResult, CheckoutResult, CheckoutChangeResult, CheckoutCancelResult, TransferResult, TransferCancelResult };
export { File as PringFile } from 'pring-admin';
export declare let firestore: FirebaseFirestore.Firestore;
export declare const initialize: (app: admin.app.App) => void;
export interface UserProtocol<Order extends OrderProtocol<OrderItem>, OrderItem extends OrderItemProtocol, TradeTransaction extends TradeTransactionProtocol> extends Pring.Base {
isAvailabled: boolean;
country: string;
orders: Pring.NestedCollection<Order>;
receivedOrders: Pring.NestedCollection<Order>;
tradeTransactions: Pring.NestedCollection<TradeTransaction>;
}
export type Balance = {
pending: {
[currency: string]: number;
};
available: {
[currency: string]: number;
};
};
export interface AccountProtocol<Transaction extends BalanceTransactionProtocol, Payout extends PayoutProtocol> extends Pring.Base {
country: string;
isRejected: boolean;
isSigned: boolean;
balance: Balance;
balanceTransactions: Pring.NestedCollection<Transaction>;
payoutRequests: Pring.NestedCollection<Payout>;
accountInformation: {
[key: string]: any;
};
}
export declare enum TradeTransactionType {
unknown = "unknown",
order = "order",
orderChange = "order_change",
orderCancel = "order_cancel",
storage = "storage",
retrieval = "retrieval"
}
export interface TradeTransactionProtocol extends Pring.Base {
type: TradeTransactionType;
selledBy: string;
purchasedBy: string;
order: string;
product?: FirebaseFirestore.DocumentReference;
sku: string;
inventoryStock?: string;
item: FirebaseFirestore.DocumentReference;
}
export declare enum BalanceTransactionType {
unknown = "unknown",
payment = "payment",
paymentRefund = "payment_refund",
transfer = "transfer",
transferRefund = "transfer_refund",
payout = "payout",
payoutCancel = "payout_cancel"
}
export type TransactionResult = {
[key: string]: any;
};
export type AccountOrDestination = string | "platform" | "bank_account";
export interface BalanceTransactionProtocol extends Pring.Base {
type: BalanceTransactionType;
currency: Currency;
amount: number;
from: AccountOrDestination;
to: AccountOrDestination;
order?: string;
transfer?: string;
payout?: string;
transactionResults: TransactionResult[];
}
export declare enum StockType {
bucket = "bucket",
finite = "finite",
infinite = "infinite"
}
export declare enum StockValue {
inStock = "in_stock",
limited = "limited",
outOfStock = "out_of_stock"
}
export type Inventory = {
type: StockType;
quantity?: number;
value?: StockValue;
};
export interface InventoryStockProtocol extends Pring.Base {
isAvailabled: boolean;
SKU: string;
order?: string;
item?: FirebaseFirestore.DocumentReference;
}
export interface SKUProtocol<InventoryStock extends InventoryStockProtocol> extends Pring.Base {
selledBy: string;
createdBy: string;
product?: FirebaseFirestore.DocumentReference;
currency: Currency;
amount: number;
inventory: Inventory;
isAvailabled: boolean;
numberOfFetch: number;
inventoryStocks: Pring.NestedCollection<InventoryStock>;
}
export declare enum OrderItemType {
sku = "sku",
tax = "tax",
shipping = "shipping",
discount = "discount"
}
export declare enum OrderItemStatus {
none = "none",
ordered = "ordered",
changed = "changed",
cancelled = "cancelled"
}
export declare enum OrderTransferStatus {
none = "none",
rejected = "rejected",
transferred = "transferred",
cancelled = "cancelled",
transferFailure = "failure",
cancelFailure = "cancel_failure"
}
export declare enum OrderPaymentStatus {
none = "none",
rejected = "rejected",
authorized = "authorized",
paid = "paid",
cancelled = "cancelled",
paymentFailure = "failure",
cancelFailure = "cancel_failure"
}
export interface OrderItemProtocol extends Pring.Base {
name?: string;
thumbnailImage?: Pring.File;
order: string;
purchasedBy: string;
selledBy: string;
createdBy: string;
type: OrderItemType;
product?: FirebaseFirestore.DocumentReference;
sku?: string;
quantity: number;
currency: Currency;
amount: number;
status: OrderItemStatus;
}
export interface OrderProtocol<OrderItem extends OrderItemProtocol> extends Pring.Base {
parentID?: string;
title?: string;
assets: Pring.File[];
purchasedBy: string;
selledBy: string;
shippingTo: {
[key: string]: string;
};
transferredTo: {
[key: string]: true;
};
paidAt?: Pring.Timestamp;
cancelableDate?: Pring.Timestamp;
expirationDate?: Pring.Timestamp;
currency: Currency;
amount: number;
items: Pring.List<OrderItem>;
paymentStatus: OrderPaymentStatus;
transferStatus: OrderTransferStatus;
transactionResults: TransactionResult[];
isCancelled: boolean;
}
export interface ItemProtocol extends Pring.Base {
order: string;
selledBy: string;
purchasedBy: string;
product?: FirebaseFirestore.DocumentReference;
sku: string;
inventoryStock?: string;
isCancelled: boolean;
}
export declare enum PayoutStatus {
none = "none",
requested = "requested",
rejected = "rejected",
completed = "completed",
cancelled = "cancelled"
}
export interface PayoutProtocol extends Pring.Base {
account: string;
currency: Currency;
amount: number;
status: PayoutStatus;
transactionResults: TransactionResult[];
isCancelled: boolean;
}
export type ShppingInformation = {
address: {
line1: string;
line2?: string;
city?: string;
state?: string;
postal_code?: string;
country?: string;
};
name: string;
carrier?: string;
phone?: string;
tracking_number?: string;
};
export type PaymentOptions = {
source?: string;
customer?: string;
shipping?: ShppingInformation;
vendorType: string;
numberOfShards?: number;
refundFeeRate: number;
reason?: RefundReason;
metadata?: any;
};
export declare enum RefundReason {
duplicate = "duplicate",
fraudulent = "fraudulent",
requestedByCustomer = "requested_by_customer"
}
export type TransferOptions = {
vendorType: string;
transferRate: number;
};
export type PayoutOptions = {
vendorType: string;
};
export interface TradeDelegate {
reserve<OrderItem extends OrderItemProtocol, Order extends OrderProtocol<OrderItem>>(order: Order, orderItem: OrderItem, transaction: FirebaseFirestore.Transaction): void;
createItem<T extends OrderItemProtocol, U extends OrderProtocol<T>>(order: U, orderItem: T, invetoryStock: string | undefined, transaction: FirebaseFirestore.Transaction): FirebaseFirestore.DocumentReference;
getItems<T extends OrderItemProtocol, U extends OrderProtocol<T>>(order: U, orderItem: T, transaction: FirebaseFirestore.Transaction): Promise<FirebaseFirestore.QuerySnapshot>;
cancelItem<T extends OrderItemProtocol, U extends OrderProtocol<T>>(order: U, orderItem: T, item: FirebaseFirestore.DocumentReference, transaction: FirebaseFirestore.Transaction): void;
}
export interface TransactionDelegate {
authorize<U extends OrderItemProtocol, T extends OrderProtocol<U>>(currency: Currency, amount: number, order: T, options: PaymentOptions): Promise<any>;
authorizeCancel<U extends OrderItemProtocol, T extends OrderProtocol<U>>(currency: Currency, amount: number, order: T, options: PaymentOptions): Promise<any>;
pay<U extends OrderItemProtocol, T extends OrderProtocol<U>>(currency: Currency, amount: number, order: T, options: PaymentOptions): Promise<any>;
refund<U extends OrderItemProtocol, T extends OrderProtocol<U>>(currency: Currency, amount: number, order: T, options: PaymentOptions, reason?: string): Promise<any>;
partRefund<U extends OrderItemProtocol, T extends OrderProtocol<U>>(currency: Currency, amount: number, order: T, orderItem: U, options: PaymentOptions, reason?: string): Promise<any>;
transfer<OrderItem extends OrderItemProtocol, Order extends OrderProtocol<OrderItem>, BalanceTransaction extends BalanceTransactionProtocol, Payout extends PayoutProtocol, Account extends AccountProtocol<BalanceTransaction, Payout>>(currency: Currency, amount: number, order: Order, toAccount: Account, options: TransferOptions): Promise<any>;
transferCancel<U extends OrderItemProtocol, T extends OrderProtocol<U>>(currency: Currency, amount: number, order: T, options: TransferOptions, reason?: string): Promise<any>;
payout(currency: Currency, amount: number, accountID: string, options: PayoutOptions): Promise<any>;
payoutCancel(currency: Currency, amount: number, accountID: string, options: PayoutOptions): Promise<any>;
}
export declare enum TradableErrorCode {
invalidArgument = "invalidArgument",
lessMinimumAmount = "lessMinimumAmount",
invalidCurrency = "invalidCurrency",
invalidAmount = "invalidAmount",
invalidShard = "invalidShard",
outOfStock = "outOfStock",
invalidStatus = "invalidStatus",
internal = "internal"
}
export declare class TradableError implements Error {
name: string;
message: string;
stack?: string;
info: {
[key: string]: any;
};
constructor(code: TradableErrorCode, message: string, stack?: string);
}