@simpleapps-com/augur-api/dist/cjs/services/payments/resources/unified.d.ts

TypeScript client library for Augur microservices API endpoints

import type { PaymentsClient } from '../client';
import type { TransactionSetupParams, AccountQueryParams, BillingUpdateParams, CardInfoParams, SurchargeParams, ValidateParams } from '../schemas';
type ExecuteRequest = PaymentsClient['executeRequest'];
/**
 * Creates the unified resource methods
 * OpenAPI Path: /api/unified → unified.*
 * @description Unified payment operations through Element Express
 */
export declare function createUnifiedResource(executeRequest: ExecuteRequest): {
    /**
     * Transaction Setup Operations
     */
    transactionSetup: {
        /**
         * Creates a new payment transaction session with customer and account information
         * @fullPath api.payments.unified.transactionSetup.get
         * @service payments
         * @domain payment-processing
         * @dataMethod unifiedData.transactionSetup.get
         * @discoverable true
         */
        get: (params: TransactionSetupParams) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: {
                transactionSetupId: string;
            } & {
                [k: string]: unknown;
            };
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
    /**
     * Account Query Operations
     */
    accountQuery: {
        /**
         * Retrieves payment account information using a transaction setup ID
         * @fullPath api.payments.unified.accountQuery.get
         * @service payments
         * @domain payment-processing
         * @dataMethod unifiedData.accountQuery.get
         * @discoverable true
         */
        get: (params: AccountQueryParams) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: false | import("zod").objectInputType<{
                PaymentAccountID: import("zod").ZodString;
            }, import("zod").ZodTypeAny, "passthrough">;
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
    /**
     * Billing Update Operations
     */
    billingUpdate: {
        /**
         * Updates billing information for an existing transaction
         * @fullPath api.payments.unified.billingUpdate.get
         * @service payments
         * @domain payment-processing
         * @dataMethod unifiedData.billingUpdate.get
         * @discoverable true
         */
        get: (params: BillingUpdateParams) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: boolean;
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
    /**
     * Card Info Operations
     */
    cardInfo: {
        /**
         * Retrieves formatted card information for a transaction
         * @fullPath api.payments.unified.cardInfo.get
         * @service payments
         * @domain payment-processing
         * @dataMethod unifiedData.cardInfo.get
         * @discoverable true
         */
        get: (params: CardInfoParams) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: Record<string, never> | import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">;
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
    /**
     * Surcharge Operations
     */
    surcharge: {
        /**
         * Calculates payment processing surcharges based on location and payment details
         * @fullPath api.payments.unified.surcharge.get
         * @service payments
         * @domain payment-processing
         * @dataMethod unifiedData.surcharge.get
         * @discoverable true
         */
        get: (params: SurchargeParams) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: Record<string, never> | import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">;
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
    /**
     * Validate Operations
     */
    validate: {
        /**
         * Validates an existing transaction setup
         * @fullPath api.payments.unified.validate.get
         * @service payments
         * @domain payment-processing
         * @dataMethod unifiedData.validate.get
         * @discoverable true
         */
        get: (params: ValidateParams) => Promise<{
            params: Record<string, unknown> | unknown[];
            data: boolean;
            options: Record<string, unknown> | unknown[];
            status: number;
            message: string;
            count: number;
            total: number;
            totalResults: number;
        }>;
    };
};
/**
 * Creates the unifiedData resource methods (data-only versions)
 */
export declare function createUnifiedDataResource(unified: ReturnType<typeof createUnifiedResource>): {
    transactionSetup: {
        get: (params: TransactionSetupParams) => Promise<{
            transactionSetupId: string;
        } & {
            [k: string]: unknown;
        }>;
    };
    accountQuery: {
        get: (params: AccountQueryParams) => Promise<false | import("zod").objectInputType<{
            PaymentAccountID: import("zod").ZodString;
        }, import("zod").ZodTypeAny, "passthrough">>;
    };
    billingUpdate: {
        get: (params: BillingUpdateParams) => Promise<boolean>;
    };
    cardInfo: {
        get: (params: CardInfoParams) => Promise<Record<string, never> | import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>;
    };
    surcharge: {
        get: (params: SurchargeParams) => Promise<Record<string, never> | import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>;
    };
    validate: {
        get: (params: ValidateParams) => Promise<boolean>;
    };
};
export type UnifiedResource = ReturnType<typeof createUnifiedResource>;
export type UnifiedDataResource = ReturnType<typeof createUnifiedDataResource>;
export {};
//# sourceMappingURL=unified.d.ts.map