@vtex/payment-provider-sdk/lib/service/typings/api.d.ts

VTEX Payment Provider SDK

/// <reference types="node" />
import type { IncomingHttpHeaders } from 'http2';
import type { ParsedUrlQuery } from 'querystring';
import { Enum } from 'typescript-string-enums';
export declare type Maybe<T> = T | undefined;
export declare const RecipientRole: {
    marketplace: "marketplace";
    seller: "seller";
};
export declare type RecipientRole = Enum<typeof RecipientRole>;
export declare const DocumentType: {
    CNPJ: "CNPJ";
    CPF: "CPF";
    SSN: "SSN";
};
export declare type DocumentType = Enum<typeof DocumentType>;
export interface AuthenticationHeaders extends IncomingHttpHeaders {
    'x-provider-api-appkey': string;
    'x-provider-api-apptoken': string;
}
export interface Recipient {
    id: string;
    name: string;
    documentType: DocumentType;
    document: string;
    role: RecipientRole;
    chargeProcessingFee: boolean;
    chargebackLiable: boolean;
    amount: number;
}
export interface Card {
    number: string;
    holder: string;
    expiration: Expiration;
    csc: string;
    document: unknown;
}
export interface TokenizedCard {
    holderToken: string;
    bin: string;
    numberToken: string;
    numberLength: number;
    cscToken: string;
    expiration: Expiration;
}
export interface Expiration {
    month: string;
    year: string;
}
export interface MiniCart {
    buyer: Buyer;
    shippingAddress: Maybe<Address>;
    billingAddress: Maybe<Address>;
    items: Maybe<Item[]>;
    shippingValue: Maybe<number>;
    taxValue: Maybe<number>;
}
export interface Buyer {
    id: Maybe<string>;
    firstName: string;
    lastName: string;
    document: string;
    documentType: Maybe<string>;
    corporateName: Maybe<string>;
    tradeName: Maybe<string>;
    corporateDocument: Maybe<string>;
    isCorporate: Maybe<boolean>;
    email: Maybe<string>;
    phone: Maybe<string>;
    createdDate: Maybe<Date>;
}
export interface Address {
    country: Maybe<string>;
    street: Maybe<string>;
    number: Maybe<string>;
    complement: Maybe<string>;
    neighborhood: Maybe<string>;
    postalCode: Maybe<string>;
    city: Maybe<string>;
    state: Maybe<string>;
}
export interface Item {
    id: Maybe<string>;
    name: Maybe<string>;
    price: Maybe<number>;
    quantity: Maybe<number>;
    discount: Maybe<number>;
    deliveryType: Maybe<string>;
}
export interface AppData {
    appName: Maybe<string>;
    payload: Maybe<string>;
}
export interface PaymentIdParam extends ParsedUrlQuery {
    paymentId: string;
}
export declare const DebitCard: {
    "Visa Electron": "Visa Electron";
    Maestro: "Maestro";
    "Mastercard Debit": "Mastercard Debit";
};
export declare type DebitCard = Enum<typeof DebitCard>;
export declare const CreditCard: {
    Visa: "Visa";
    Mastercard: "Mastercard";
    "American Express": "American Express";
    Discover: "Discover";
    JCB: "JCB";
    Diners: "Diners";
    Elo: "Elo";
    Hipercard: "Hipercard";
    Aura: "Aura";
    Benricompras: "Benricompras";
    Credz: "Credz";
    Cabal: "Cabal";
};
export declare type CreditCard = Enum<typeof CreditCard>;
export declare const AdhocCard: {
    Cobranded: "Cobranded";
    Privatelabels: "Privatelabels";
};
export declare type AdhocCard = Enum<typeof AdhocCard>;
export declare const BankInvoice: {
    BankInvoice: "BankInvoice";
};
export declare type BankInvoice = Enum<typeof BankInvoice>;
export declare const Generic: {
    Promissories: "Promissories";
    Cash: "Cash";
};
export declare type Generic = Enum<typeof Generic>;
export declare const Voucher: {
    SPEI: "SPEI";
    Safetypay: "Safetypay";
};
export declare type Voucher = Enum<typeof Voucher>;
export declare const Cryptocurrency: {
    Bitcoin: "Bitcoin";
};
export declare type Cryptocurrency = Enum<typeof Cryptocurrency>;
export declare type PaymentMethod = CreditCard | DebitCard | AdhocCard | Generic | BankInvoice | Voucher | Cryptocurrency;
export interface AvailablePaymentsResponse {
    paymentMethods: PaymentMethod[];
}
export declare type AllowSplitOptions = 'onAuthorize' | 'onCapture' | 'disabled';
export interface PaymentMethodInfo {
    name: PaymentMethod;
    allowsSplit: AllowSplitOptions;
}
export declare type CustomFieldTypeOptions = 'text' | 'select';
export declare type SelectTypeOptions = 'type' | 'value';
export interface CustomSelectFields {
    text: string;
    value: string;
}
export interface CustomFieldOptions {
    name: string;
    type: CustomFieldTypeOptions;
    options?: CustomSelectFields[];
}
export interface ProviderManifestResponse {
    paymentMethods: PaymentMethodInfo[];
    customFields?: CustomFieldOptions[];
}
export interface CancellationRequest extends PaymentRequest {
    authorizationId: string;
    tid: Maybe<string>;
}
export interface CancellationResponse extends PaymentRequest {
    cancellationId: Maybe<string> | null;
    code: Maybe<'cancel-manually'> | null;
    message: Maybe<string> | null;
}
export interface PaymentRequest {
    transactionId: string;
    paymentId: string;
    requestId: string;
}
export interface Authorization extends PaymentRequest {
    reference: string;
    orderId: string;
    paymentMethod: PaymentMethod;
    paymentMethodCustomCode: Maybe<string>;
    merchantName: string;
    value: number;
    currency: string;
    installments: Maybe<number>;
    deviceFingerprint: Maybe<string>;
    ipAddress: Maybe<string>;
    miniCart: MiniCart;
    url: Maybe<string>;
    callbackUrl: string;
    inboundRequestsUrl: string;
    returnUrl: Maybe<string>;
    recipients: Maybe<Recipient[]>;
}
export interface CardAuthorization extends Authorization {
    secureProxyUrl: Maybe<string>;
    card: Card | TokenizedCard;
    paymentMethod: CreditCard | DebitCard | AdhocCard;
}
export interface CreditCardAuthorization extends CardAuthorization {
    paymentMethod: CreditCard;
}
export interface DebitCardAuthorization extends CardAuthorization {
    paymentMethod: DebitCard;
}
export interface AdhocCardAuthorization extends CardAuthorization {
    paymentMethod: AdhocCard;
}
export interface BankInvoiceAuthorization extends Authorization {
    paymentMethod: BankInvoice;
}
export declare type AuthorizationRequest = CreditCardAuthorization | DebitCardAuthorization | AdhocCardAuthorization | BankInvoiceAuthorization | Authorization;
export declare const isCardAuthorization: (authorization: AuthorizationRequest) => authorization is CardAuthorization;
export declare const isCreditCardAuthorization: (authorization: AuthorizationRequest) => authorization is CreditCardAuthorization;
export declare const isDebitCardAuthorization: (authorization: AuthorizationRequest) => authorization is DebitCardAuthorization;
export declare const isBankInvoiceAuthorization: (authorization: AuthorizationRequest) => authorization is BankInvoiceAuthorization;
export declare const isTokenizedCard: (card: Card | TokenizedCard) => card is TokenizedCard;
export declare type AuthorizationStatus = 'approved' | 'denied' | 'undefined';
export interface PaymentResponse {
    paymentId: string;
    code: Maybe<string> | null;
    message: Maybe<string> | null;
}
export interface Authorized extends PaymentResponse {
    status: AuthorizationStatus;
    tid: Maybe<string> | null;
    acquirer: Maybe<string> | null;
    paymentAppData: Maybe<AppData> | null;
}
export interface ApprovedAuthorization extends Authorized {
    tid: string;
    authorizationId: string;
    nsu: string;
}
export interface CreditCardAuthorized extends ApprovedAuthorization {
    delayToAutoSettle: Maybe<number>;
    delayToAutoSettleAfterAntifraud: Maybe<number>;
}
export interface BankInvoiceAuthorized extends ApprovedAuthorization {
    paymentUrl: string;
    identificationNumber: Maybe<string>;
    identificationNumberFormatted: Maybe<string>;
    barCodeImageType: Maybe<string>;
    barCodeImageNumber: Maybe<string>;
    delayToCancel: Maybe<number>;
}
export interface FailedAuthorization extends Authorized {
    status: 'denied';
}
export interface UndefinedAuthorization extends Authorized {
    status: 'undefined';
    delayToCancel: number;
}
export declare type AuthorizationResponse = ApprovedAuthorization | CreditCardAuthorized | BankInvoiceAuthorized | FailedAuthorization | UndefinedAuthorization | RedirectResponse;
export interface SettlementRequest extends PaymentRequest {
    value: number;
    authorizationId: string;
    tid: Maybe<string>;
    recipients: Maybe<Recipient[]>;
}
export interface SettlementResponse extends PaymentResponse {
    settleId: Maybe<string> | null;
    value: number;
    requestId: string;
}
export interface RefundRequest extends PaymentRequest {
    value: number;
    settleId: string;
    tid: Maybe<string>;
    recipients: Maybe<Recipient[]>;
}
export interface RefundResponse extends PaymentResponse {
    requestId: string;
    refundId: Maybe<string> | null;
    value: number;
}
export interface InboundRequest extends PaymentRequest {
    authorizationId: string;
    tid: string;
    requestData: {
        body: string;
    };
}
export interface InboundResponse extends PaymentResponse {
    responseData: {
        statusCode: number;
        contentType: string;
        content: string;
    };
    requestId: string;
}
export interface RedirectResponse extends UndefinedAuthorization {
    redirectUrl: Maybe<string> | null;
}