New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@opengov/ppf-backend-types

Package Overview
Dependencies
Maintainers
146
Versions
427
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@opengov/ppf-backend-types - npm Package Compare versions

Comparing version 1.8.0 to 1.8.1

.graphqlrc.ts

8

CHANGELOG.md

@@ -6,2 +6,10 @@ # Change Log

## [1.8.1](https://github.com/OpenGov/pluggable-payments/compare/@opengov/ppf-backend-types@1.8.0...@opengov/ppf-backend-types@1.8.1) (2024-01-23)
**Note:** Version bump only for package @opengov/ppf-backend-types
# [1.8.0](https://github.com/OpenGov/pluggable-payments/compare/@opengov/ppf-backend-types@1.7.1...@opengov/ppf-backend-types@1.8.0) (2024-01-22)

@@ -8,0 +16,0 @@

1257

dist/types/generated.d.ts

@@ -1,8 +0,8 @@

import type { PaymentProcessorFlow } from "./enums";
import type { ConfigScope } from "./enums";
import type { PaymentMethod } from "./enums";
import type { ImplementationTeam } from "./enums";
import type { PaymentProcessorId } from "./enums";
import type { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from "graphql";
import type { MercuriusContext } from "mercurius";
import { PaymentProcessorFlow } from "./enums";
import { ConfigScope } from "./enums";
import { PaymentMethod } from "./enums";
import { ImplementationTeam } from "./enums";
import { PaymentProcessorId } from "./enums";
import { OpenGovTenant } from "./enums";
import { TransactionStatus } from "./enums";
export type Maybe<T> = T | null;

@@ -21,10 +21,2 @@ export type InputMaybe<T> = Maybe<T>;

};
export type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<import("mercurius-codegen").DeepPartial<TResult>> | import("mercurius-codegen").DeepPartial<TResult>;
export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
export type RequireFields<T, K extends keyof T> = Omit<T, K> & {
[P in K]-?: NonNullable<T[P]>;
};
export type EnumResolverSignature<T, AllowedValues = any> = {
[key in keyof T]?: AllowedValues;
};
/** All built-in and custom scalars, mapped to their actual values */

@@ -39,43 +31,50 @@ export type Scalars = {

PaymentAccountToken: any;
_FieldSet: any;
};
export type Query = {
__typename?: "Query";
paymentProcessor?: Maybe<PaymentProcessor>;
SEPSMetadata: SEPSMetadata;
export type ApplicationMetadata = {
community?: InputMaybe<Scalars["String"]>;
departmentID?: InputMaybe<Scalars["ID"]>;
departmentName?: InputMaybe<Scalars["String"]>;
paymentID?: InputMaybe<Scalars["String"]>;
paymentMethod?: InputMaybe<Scalars["String"]>;
recordNo?: InputMaybe<Scalars["String"]>;
recordStepID?: InputMaybe<Scalars["String"]>;
recordType?: InputMaybe<Scalars["String"]>;
recordTypeID?: InputMaybe<Scalars["String"]>;
};
export type QuerypaymentProcessorArgs = {
id: PaymentProcessorId;
export type Card = {
__typename?: "Card";
card: CardDetails;
};
export type SEPSMetadata = {
__typename?: "SEPSMetadata";
environment: Scalars["String"];
supportedPaymentProcessors: Array<PaymentProcessor>;
export type CardDetails = {
__typename?: "CardDetails";
authorizationCode?: Maybe<Scalars["String"]>;
cardType?: Maybe<CardType>;
last4?: Maybe<Scalars["String"]>;
};
export type PaymentProcessor = {
__typename?: "PaymentProcessor";
id: PaymentProcessorId;
name: Scalars["String"];
supportedFlows: Array<PaymentProcessorFlow>;
supportedPaymentMethods: Array<PaymentMethod>;
baseFee?: Maybe<Scalars["Int"]>;
supportsWebhooks?: Maybe<Scalars["Boolean"]>;
implementationTeam?: Maybe<ImplementationTeam>;
processingFees?: Maybe<ProcessingFees>;
/** For use in client SDK */
clientPluginUrl?: Maybe<Scalars["String"]>;
pluginDependencyUrls?: Maybe<Array<Scalars["String"]>>;
config?: Maybe<Array<EnvironmentConfig>>;
export declare enum CardType {
AMERICAN_EXPRESS = "AMERICAN_EXPRESS",
DISCOVER = "DISCOVER",
MASTERCARD = "MASTERCARD",
UNKNOWN = "UNKNOWN",
VISA = "VISA"
}
export type ConfigPluginFlowRequest = {
applicationMetadata?: InputMaybe<ApplicationMetadata>;
community: Scalars["String"];
processorID: PaymentProcessorId;
scope: ConfigScope;
};
export type ProcessingFeeMetadata = {
__typename?: "ProcessingFeeMetadata";
allowCommunityPays?: Maybe<Scalars["Boolean"]>;
fee?: Maybe<Scalars["String"]>;
scheduled?: Maybe<Scalars["String"]>;
export type ConfigPluginFlowResponse = FlowResponseType & {
__typename?: "ConfigPluginFlowResponse";
flowType: PaymentProcessorFlow;
};
export type ProcessingFees = {
__typename?: "ProcessingFees";
E_CHECK?: Maybe<ProcessingFeeMetadata>;
CREDIT_CARD?: Maybe<ProcessingFeeMetadata>;
export { ConfigScope };
export type ECheck = {
__typename?: "ECheck";
e_check: ECheckDetails;
};
export type ECheckDetails = {
__typename?: "ECheckDetails";
last4?: Maybe<Scalars["String"]>;
};
export type EnvironmentConfig = {

@@ -86,14 +85,15 @@ __typename?: "EnvironmentConfig";

};
export type FeeItem = {
feeAccountNumber?: InputMaybe<Scalars["String"]>;
feeAmount?: InputMaybe<Scalars["Float"]>;
feeTitle?: InputMaybe<Scalars["String"]>;
};
/** Represents a successful grant with a token */
export type FlowGrant = {
__typename?: "FlowGrant";
flowType: PaymentProcessorFlow;
/** Flow token payload */
flowToken: Scalars["String"];
flowType: PaymentProcessorFlow;
};
/** Error result when processor does not support the request flow type. */
export type FlowUnsupported = {
__typename?: "FlowUnsupported";
message?: Maybe<Scalars["String"]>;
};
export type FlowGrantResponse = FlowGrant | FlowRequestInvalid | FlowUnsupported;
/** Error result when flow request input is invalid. */

@@ -104,35 +104,2 @@ export type FlowRequestInvalid = {

};
export type Card = {
__typename?: "Card";
card: CardDetails;
};
export type ECheck = {
__typename?: "ECheck";
e_check: ECheckDetails;
};
export type CardDetails = {
__typename?: "CardDetails";
last4?: Maybe<Scalars["String"]>;
cardType?: Maybe<CardType>;
authorizationCode?: Maybe<Scalars["String"]>;
};
export type ECheckDetails = {
__typename?: "ECheckDetails";
last4?: Maybe<Scalars["String"]>;
};
/** Common interface for mutation responses that fail for predictable reasons. */
export type ResponseErrorMessage = {
message: Scalars["String"];
};
export type ApplicationMetadata = {
community?: InputMaybe<Scalars["String"]>;
recordType?: InputMaybe<Scalars["String"]>;
recordTypeID?: InputMaybe<Scalars["String"]>;
recordNo?: InputMaybe<Scalars["String"]>;
recordStepID?: InputMaybe<Scalars["String"]>;
departmentName?: InputMaybe<Scalars["String"]>;
departmentID?: InputMaybe<Scalars["ID"]>;
paymentMethod?: InputMaybe<Scalars["String"]>;
paymentID?: InputMaybe<Scalars["String"]>;
};
/**

@@ -145,38 +112,56 @@ * Common interface for all flow responses.

};
export { PaymentProcessorFlow };
export type FeeItem = {
feeAmount?: InputMaybe<Scalars["Float"]>;
feeTitle?: InputMaybe<Scalars["String"]>;
feeAccountNumber?: InputMaybe<Scalars["String"]>;
/** Signed FlowResult from the SEPS SDK using JWS standard (see https://tools.ietf.org/id/draft-ietf-jose-json-web-signature-14.html#JSComplete) */
export type FlowResult = {
header?: InputMaybe<Header>;
payload: Scalars["String"];
protected?: InputMaybe<Scalars["String"]>;
signature?: InputMaybe<Scalars["String"]>;
signatures?: InputMaybe<Array<Signature>>;
};
export type OnlinePaymentFlowRequest = {
/** Error result when processor does not support the request flow type. */
export type FlowUnsupported = {
__typename?: "FlowUnsupported";
message?: Maybe<Scalars["String"]>;
};
export type FlowValidationResponse = ConfigPluginFlowResponse | FuturePaymentFlowResponse | InvalidFlowResult | InvalidSignature | OfflinePaymentFlowResponse | OfflineRefundFlowResponse | OneTimePaymentFlowResponse | OnlinePaymentFlowResponse | OnlineRefundFlowResponse | TerminalPaymentFlowResponse | UpdatePaymentFlowResponse;
export type FuturePaymentFlowRequest = {
entityID: Scalars["String"];
paymentMethod: PaymentMethod;
processorID: PaymentProcessorId;
amount: Scalars["Float"];
processingFee: Scalars["Float"];
currency: Scalars["String"];
paymentMethod: PaymentMethod;
paymentID: Scalars["String"];
entityID: Scalars["String"];
sourceApp: Scalars["String"];
description: Scalars["String"];
userID: Scalars["ID"];
applicationMetadata?: InputMaybe<ApplicationMetadata>;
tenantID?: InputMaybe<Scalars["String"]>;
items?: InputMaybe<Array<InputMaybe<FeeItem>>>;
};
export type OnlinePaymentFlowResponse = FlowResponseType & {
__typename?: "OnlinePaymentFlowResponse";
export type FuturePaymentFlowResponse = FlowResponseType & {
__typename?: "FuturePaymentFlowResponse";
flowType: PaymentProcessorFlow;
paymentID: Scalars["ID"];
transactionID?: Maybe<Scalars["String"]>;
amount?: Maybe<Scalars["Float"]>;
processingFee?: Maybe<Scalars["Float"]>;
currency?: Maybe<Scalars["String"]>;
description?: Maybe<Scalars["String"]>;
paymentAccountToken?: Maybe<Scalars["PaymentAccountToken"]>;
paymentMethodDetails?: Maybe<PaymentMethodDetails>;
status: Scalars["String"];
paymentMethodDetails: PaymentMethodDetails;
};
export type FlowValidationResponse = OnlinePaymentFlowResponse | OnlineRefundFlowResponse | OfflineRefundFlowResponse | OfflinePaymentFlowResponse | TerminalPaymentFlowResponse | OneTimePaymentFlowResponse | FuturePaymentFlowResponse | ConfigPluginFlowResponse | UpdatePaymentFlowResponse | InvalidSignature | InvalidFlowResult;
export type Header = {
alg?: InputMaybe<Scalars["String"]>;
};
export { ImplementationTeam };
/** Error response when FlowResult contains invalid payload data. */
export type InvalidFlowResult = ResponseErrorMessage & {
__typename?: "InvalidFlowResult";
message: Scalars["String"];
};
/** Error response when FlowResult signature is invalid. */
export type InvalidSignature = ResponseErrorMessage & {
__typename?: "InvalidSignature";
message: Scalars["String"];
};
export type Mutation = {
__typename?: "Mutation";
/** Requests configuration flow grant for payment Processor. */
configPlugin: FlowGrantResponse;
/** Requests a grant to perform the FUTURE_PAYMENT flow. */
futurePayment: FlowGrantResponse;
/** Requests a grant to perform the OFFLINE_PAYMENT flow. */
offlinePayment: FlowGrantResponse;
/** Requests a grant to perform the OFFLINE_REFUND flow. */
offlineRefund: FlowGrantResponse;
/** Requests a grant to perform the ONETIME_PAYMENT flow. */
oneTimePayment: FlowGrantResponse;
/** Requests a grant to perform the ONLINE_PAYMENT flow. */

@@ -186,14 +171,4 @@ onlinePayment: FlowGrantResponse;

onlineRefund: FlowGrantResponse;
/** Requests a grant to perform the OFFLINE_REFUND flow. */
offlineRefund: FlowGrantResponse;
/** Requests a grant to perform the OFFLINE_PAYMENT flow. */
offlinePayment: FlowGrantResponse;
/** Requests a grant to perform the TERMINAL_PAYMENT flow. */
terminalPayment: FlowGrantResponse;
/** Requests a grant to perform the ONETIME_PAYMENT flow. */
oneTimePayment: FlowGrantResponse;
/** Requests a grant to perform the FUTURE_PAYMENT flow. */
futurePayment: FlowGrantResponse;
/** Requests configuration flow grant for payment Processor. */
configPlugin: FlowGrantResponse;
/** Requests a grant to perform the update of a payment */

@@ -204,16 +179,13 @@ updatePayment: FlowGrantResponse;

};
export type MutationonlinePaymentArgs = {
request?: InputMaybe<OnlinePaymentFlowRequest>;
export type MutationconfigPluginArgs = {
request?: InputMaybe<ConfigPluginFlowRequest>;
};
export type MutationonlineRefundArgs = {
request?: InputMaybe<OnlineRefundFlowRequest>;
export type MutationfuturePaymentArgs = {
request?: InputMaybe<FuturePaymentFlowRequest>;
};
export type MutationofflineRefundArgs = {
request?: InputMaybe<OfflineRefundFlowRequest>;
};
export type MutationofflinePaymentArgs = {
request?: InputMaybe<OfflinePaymentFlowRequest>;
};
export type MutationterminalPaymentArgs = {
request?: InputMaybe<TerminalPaymentFlowRequest>;
export type MutationofflineRefundArgs = {
request?: InputMaybe<OfflineRefundFlowRequest>;
};

@@ -223,8 +195,11 @@ export type MutationoneTimePaymentArgs = {

};
export type MutationfuturePaymentArgs = {
request?: InputMaybe<FuturePaymentFlowRequest>;
export type MutationonlinePaymentArgs = {
request?: InputMaybe<OnlinePaymentFlowRequest>;
};
export type MutationconfigPluginArgs = {
request?: InputMaybe<ConfigPluginFlowRequest>;
export type MutationonlineRefundArgs = {
request?: InputMaybe<OnlineRefundFlowRequest>;
};
export type MutationterminalPaymentArgs = {
request?: InputMaybe<TerminalPaymentFlowRequest>;
};
export type MutationupdatePaymentArgs = {

@@ -234,68 +209,25 @@ request?: InputMaybe<UpdatePaymentFlowRequest>;

export type MutationvalidateFlowResultArgs = {
flowResult: FlowResult;
flowType?: InputMaybe<PaymentProcessorFlow>;
flowResult: FlowResult;
};
export type OnlineRefundFlowRequest = {
processorId: PaymentProcessorId;
userId: Scalars["ID"];
paymentId: Scalars["ID"];
currency?: InputMaybe<Scalars["String"]>;
refundAmount: Scalars["Float"];
reason?: InputMaybe<Scalars["String"]>;
};
export type OnlineRefundFlowResponse = FlowResponseType & {
__typename?: "OnlineRefundFlowResponse";
flowType: PaymentProcessorFlow;
paymentID: Scalars["ID"];
};
export type RefundMethodDetails = {
__typename?: "RefundMethodDetails";
recordID?: Maybe<Scalars["String"]>;
recordStepID?: Maybe<Scalars["String"]>;
feeID?: Maybe<Scalars["String"]>;
userID?: Maybe<Scalars["String"]>;
label?: Maybe<Scalars["String"]>;
};
export type OfflineRefundFlowRequest = {
processorId: PaymentProcessorId;
originalPaymentID: Scalars["ID"];
paymentID: Scalars["ID"];
export type OfflinePaymentFlowRequest = {
amount: Scalars["Float"];
reason?: InputMaybe<Scalars["String"]>;
applicationMetadata?: InputMaybe<ApplicationMetadata>;
};
export type OfflineRefundFlowResponse = FlowResponseType & {
__typename?: "OfflineRefundFlowResponse";
flowType: PaymentProcessorFlow;
originalPaymentID: Scalars["ID"];
paymentID: Scalars["ID"];
amount: Scalars["Float"];
currency?: Maybe<Scalars["String"]>;
offlineRefundDetails?: Maybe<RefundMethodDetails>;
};
export type OfflinePaymentFlowRequest = {
processorID: PaymentProcessorId;
currency: Scalars["String"];
description: Scalars["String"];
entityID: Scalars["String"];
paymentAccountToken: Scalars["PaymentAccountToken"];
amount: Scalars["Float"];
paymentID: Scalars["String"];
paymentMethod: PaymentMethod;
processingFee: Scalars["Float"];
currency: Scalars["String"];
paymentMethod: PaymentMethod;
paymentID: Scalars["String"];
entityID: Scalars["String"];
processorID: PaymentProcessorId;
sourceApp: Scalars["String"];
description: Scalars["String"];
userID: Scalars["ID"];
applicationMetadata?: InputMaybe<ApplicationMetadata>;
};
export type OfflinePaymentFlowResponse = FlowResponseType & {
__typename?: "OfflinePaymentFlowResponse";
flowType: PaymentProcessorFlow;
paymentID: Scalars["ID"];
transactionID?: Maybe<Scalars["String"]>;
amount?: Maybe<Scalars["Float"]>;
processingFee?: Maybe<Scalars["Float"]>;
currency?: Maybe<Scalars["String"]>;
description?: Maybe<Scalars["String"]>;
status: Scalars["String"];
paymentMethodDetails: PaymentMethodDetails;
flowType: PaymentProcessorFlow;
/**

@@ -306,51 +238,37 @@ * Token representing the payment account used for this payment.

paymentAccountToken?: Maybe<Scalars["PaymentAccountToken"]>;
paymentID: Scalars["ID"];
paymentMethodDetails: PaymentMethodDetails;
processingFee?: Maybe<Scalars["Float"]>;
status: Scalars["String"];
transactionID?: Maybe<Scalars["String"]>;
};
export type TerminalPaymentFlowRequest = {
/** Payment plug processor */
processorId: PaymentProcessorId;
/** User initiating or on behalf of whom the payment is being made */
userId: Scalars["ID"];
/** Unique payent transaction reference in integrator system */
paymentID: Scalars["String"];
/** Integrator system or client system or tenant */
entityID: Scalars["String"];
/** Amount to be paid */
export type OfflineRefundFlowRequest = {
amount: Scalars["Float"];
/** Type of payment channel for transaction */
paymentMethod: PaymentMethod;
/** Identifier for terminal device */
terminalID: Scalars["String"];
/** Type of terminal device */
terminalType: Scalars["String"];
/** Options if need to mention for terminal device */
terminalOptions?: InputMaybe<Scalars["String"]>;
/** Processing fee to be paid */
processingFee?: InputMaybe<Scalars["Float"]>;
currency?: InputMaybe<Scalars["String"]>;
sourceApp?: InputMaybe<Scalars["String"]>;
description?: InputMaybe<Scalars["String"]>;
applicationMetadata?: InputMaybe<ApplicationMetadata>;
originalPaymentID: Scalars["ID"];
paymentID: Scalars["ID"];
processorId: PaymentProcessorId;
reason?: InputMaybe<Scalars["String"]>;
};
export type TerminalPaymentFlowResponse = FlowResponseType & {
__typename?: "TerminalPaymentFlowResponse";
export type OfflineRefundFlowResponse = FlowResponseType & {
__typename?: "OfflineRefundFlowResponse";
amount: Scalars["Float"];
currency?: Maybe<Scalars["String"]>;
flowType: PaymentProcessorFlow;
txnReferenceId: Scalars["String"];
txnSessionId: Scalars["Int"];
txnSessionResultStatus: TerminalPaySessionResultStatus;
txnSessionMessage?: Maybe<Scalars["String"]>;
serviceFeeAmount?: Maybe<Scalars["Float"]>;
paymentMethodDetails: PaymentMethodDetails;
offlineRefundDetails?: Maybe<RefundMethodDetails>;
originalPaymentID: Scalars["ID"];
paymentID: Scalars["ID"];
};
export type OneTimePaymentFlowRequest = {
processorID: PaymentProcessorId;
amount: Scalars["Float"];
processingFee: Scalars["Float"];
applicationMetadata?: InputMaybe<ApplicationMetadata>;
currency: Scalars["String"];
description: Scalars["String"];
entityID: Scalars["String"];
paymentID: Scalars["String"];
paymentMethod: PaymentMethod;
paymentID: Scalars["String"];
entityID: Scalars["String"];
processingFee: Scalars["Float"];
processorID: PaymentProcessorId;
sourceApp: Scalars["String"];
description: Scalars["String"];
userID: Scalars["ID"];
applicationMetadata?: InputMaybe<ApplicationMetadata>;
};

@@ -360,94 +278,114 @@ /** Response from performing the ONETIME_PAYMENT flow. */

__typename?: "OneTimePaymentFlowResponse";
amount?: Maybe<Scalars["Float"]>;
currency?: Maybe<Scalars["String"]>;
description?: Maybe<Scalars["String"]>;
flowType: PaymentProcessorFlow;
paymentAccountToken?: Maybe<Scalars["PaymentAccountToken"]>;
paymentID: Scalars["ID"];
transactionID?: Maybe<Scalars["String"]>;
amount?: Maybe<Scalars["Float"]>;
paymentMethodDetails: PaymentMethodDetails;
processingFee?: Maybe<Scalars["Float"]>;
currency?: Maybe<Scalars["String"]>;
description?: Maybe<Scalars["String"]>;
status: Scalars["String"];
paymentMethodDetails: PaymentMethodDetails;
paymentAccountToken?: Maybe<Scalars["PaymentAccountToken"]>;
transactionID?: Maybe<Scalars["String"]>;
};
export type FuturePaymentFlowRequest = {
export type OnlinePaymentFlowRequest = {
amount: Scalars["Float"];
applicationMetadata?: InputMaybe<ApplicationMetadata>;
currency: Scalars["String"];
description: Scalars["String"];
entityID: Scalars["String"];
items?: InputMaybe<Array<InputMaybe<FeeItem>>>;
paymentID: Scalars["String"];
paymentMethod: PaymentMethod;
processingFee: Scalars["Float"];
processorID: PaymentProcessorId;
paymentMethod: PaymentMethod;
entityID: Scalars["String"];
sourceApp: Scalars["String"];
tenantID?: InputMaybe<Scalars["String"]>;
userID: Scalars["ID"];
};
export type FuturePaymentFlowResponse = FlowResponseType & {
__typename?: "FuturePaymentFlowResponse";
export type OnlinePaymentFlowResponse = FlowResponseType & {
__typename?: "OnlinePaymentFlowResponse";
amount?: Maybe<Scalars["Float"]>;
currency?: Maybe<Scalars["String"]>;
description?: Maybe<Scalars["String"]>;
flowType: PaymentProcessorFlow;
paymentID: Scalars["ID"];
paymentMethodDetails: PaymentMethodDetails;
processingFee?: Maybe<Scalars["Float"]>;
status: Scalars["String"];
paymentAccountToken?: Maybe<Scalars["PaymentAccountToken"]>;
paymentMethodDetails?: Maybe<PaymentMethodDetails>;
transactionID?: Maybe<Scalars["String"]>;
};
export type ConfigPluginFlowRequest = {
processorID: PaymentProcessorId;
community: Scalars["String"];
scope: ConfigScope;
applicationMetadata?: InputMaybe<ApplicationMetadata>;
};
export type ConfigPluginFlowResponse = FlowResponseType & {
__typename?: "ConfigPluginFlowResponse";
flowType: PaymentProcessorFlow;
};
export type UpdatePaymentFlowRequest = {
processorID: PaymentProcessorId;
entityID: Scalars["String"];
status: TransactionStatus;
tenantID: OpenGovTenant;
paymentID: Scalars["ID"];
transactionID?: InputMaybe<Scalars["String"]>;
amount?: InputMaybe<Scalars["Float"]>;
processingFee?: InputMaybe<Scalars["Float"]>;
export type OnlineRefundFlowRequest = {
currency?: InputMaybe<Scalars["String"]>;
paymentId: Scalars["ID"];
processorId: PaymentProcessorId;
reason?: InputMaybe<Scalars["String"]>;
refundAmount: Scalars["Float"];
userId: Scalars["ID"];
};
export type UpdatePaymentFlowResponse = FlowResponseType & {
__typename?: "UpdatePaymentFlowResponse";
export type OnlineRefundFlowResponse = FlowResponseType & {
__typename?: "OnlineRefundFlowResponse";
flowType: PaymentProcessorFlow;
processorID: PaymentProcessorId;
entityID: Scalars["String"];
status: TransactionStatus;
tenantID: OpenGovTenant;
paymentID: Scalars["ID"];
transactionID?: Maybe<Scalars["String"]>;
amount?: Maybe<Scalars["Float"]>;
processingFee?: Maybe<Scalars["Float"]>;
currency?: Maybe<Scalars["String"]>;
};
export type Header = {
alg?: InputMaybe<Scalars["String"]>;
export { OpenGovTenant };
export { PaymentMethod };
export type PaymentMethodDetails = Card | ECheck;
export type PaymentProcessor = {
__typename?: "PaymentProcessor";
baseFee?: Maybe<Scalars["Int"]>;
/** For use in client SDK */
clientPluginUrl?: Maybe<Scalars["String"]>;
config?: Maybe<Array<EnvironmentConfig>>;
id: PaymentProcessorId;
implementationTeam?: Maybe<ImplementationTeam>;
name: Scalars["String"];
pluginDependencyUrls?: Maybe<Array<Scalars["String"]>>;
processingFees?: Maybe<ProcessingFees>;
supportedFlows: Array<PaymentProcessorFlow>;
supportedPaymentMethods: Array<PaymentMethod>;
supportsWebhooks?: Maybe<Scalars["Boolean"]>;
};
export type Signature = {
protected: Scalars["String"];
header?: InputMaybe<Header>;
signature: Scalars["String"];
export { PaymentProcessorFlow };
export { PaymentProcessorId };
export type ProcessingFeeMetadata = {
__typename?: "ProcessingFeeMetadata";
allowCommunityPays?: Maybe<Scalars["Boolean"]>;
fee?: Maybe<Scalars["String"]>;
scheduled?: Maybe<Scalars["String"]>;
};
/** Signed FlowResult from the SEPS SDK using JWS standard (see https://tools.ietf.org/id/draft-ietf-jose-json-web-signature-14.html#JSComplete) */
export type FlowResult = {
payload: Scalars["String"];
protected?: InputMaybe<Scalars["String"]>;
header?: InputMaybe<Header>;
signature?: InputMaybe<Scalars["String"]>;
signatures?: InputMaybe<Array<Signature>>;
export type ProcessingFees = {
__typename?: "ProcessingFees";
CREDIT_CARD?: Maybe<ProcessingFeeMetadata>;
E_CHECK?: Maybe<ProcessingFeeMetadata>;
};
/** Error response when FlowResult signature is invalid. */
export type InvalidSignature = ResponseErrorMessage & {
__typename?: "InvalidSignature";
message: Scalars["String"];
export type Query = {
__typename?: "Query";
SEPSMetadata: SEPSMetadata;
paymentProcessor?: Maybe<PaymentProcessor>;
};
/** Error response when FlowResult contains invalid payload data. */
export type InvalidFlowResult = ResponseErrorMessage & {
__typename?: "InvalidFlowResult";
export type QuerypaymentProcessorArgs = {
id: PaymentProcessorId;
};
export type RefundMethodDetails = {
__typename?: "RefundMethodDetails";
feeID?: Maybe<Scalars["String"]>;
label?: Maybe<Scalars["String"]>;
recordID?: Maybe<Scalars["String"]>;
recordStepID?: Maybe<Scalars["String"]>;
userID?: Maybe<Scalars["String"]>;
};
/** Common interface for mutation responses that fail for predictable reasons. */
export type ResponseErrorMessage = {
message: Scalars["String"];
};
export declare enum CardType {
UNKNOWN = "UNKNOWN",
AMERICAN_EXPRESS = "AMERICAN_EXPRESS",
DISCOVER = "DISCOVER",
MASTERCARD = "MASTERCARD",
VISA = "VISA"
}
export type SEPSMetadata = {
__typename?: "SEPSMetadata";
environment: Scalars["String"];
supportedPaymentProcessors: Array<PaymentProcessor>;
};
export type Signature = {
header?: InputMaybe<Header>;
protected: Scalars["String"];
signature: Scalars["String"];
};
export declare enum TerminalPaySessionResultStatus {

@@ -460,678 +398,63 @@ APPROVED = "APPROVED",

}
export { ImplementationTeam };
export { PaymentMethod };
export { ConfigScope };
export { PaymentProcessorId };
export declare enum OpenGovTenant {
plc = "plc"
}
export declare enum TransactionStatus {
SUCCEDED = "SUCCEDED",
PENDING = "PENDING",
FAILED = "FAILED",
DISPUTED = "DISPUTED",
LOST = "LOST"
}
export type FlowGrantResponse = FlowGrant | FlowUnsupported | FlowRequestInvalid;
export type PaymentMethodDetails = Card | ECheck;
export type ResolverTypeWrapper<T> = Promise<T> | T;
export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
export type TerminalPaymentFlowRequest = {
/** Amount to be paid */
amount: Scalars["Float"];
applicationMetadata?: InputMaybe<ApplicationMetadata>;
currency?: InputMaybe<Scalars["String"]>;
description?: InputMaybe<Scalars["String"]>;
/** Integrator system or client system or tenant */
entityID: Scalars["String"];
/** Unique payent transaction reference in integrator system */
paymentID: Scalars["String"];
/** Type of payment channel for transaction */
paymentMethod: PaymentMethod;
/** Processing fee to be paid */
processingFee?: InputMaybe<Scalars["Float"]>;
/** Payment plug processor */
processorId: PaymentProcessorId;
sourceApp?: InputMaybe<Scalars["String"]>;
/** Identifier for terminal device */
terminalID: Scalars["String"];
/** Options if need to mention for terminal device */
terminalOptions?: InputMaybe<Scalars["String"]>;
/** Type of terminal device */
terminalType: Scalars["String"];
/** User initiating or on behalf of whom the payment is being made */
userId: Scalars["ID"];
};
export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
subscribe: SubscriptionSubscribeFn<{
[key in TKey]: TResult;
}, TParent, TContext, TArgs>;
resolve?: SubscriptionResolveFn<TResult, {
[key in TKey]: TResult;
}, TContext, TArgs>;
}
export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
}
export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> = ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>) | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
export type NextResolverFn<T> = () => Promise<T>;
export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
/** Mapping of union types */
export type ResolversUnionTypes = {
FlowValidationResponse: (Omit<OnlinePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversTypes["PaymentMethodDetails"];
}) | OnlineRefundFlowResponse | OfflineRefundFlowResponse | (Omit<OfflinePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversTypes["PaymentMethodDetails"];
}) | (Omit<TerminalPaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversTypes["PaymentMethodDetails"];
}) | (Omit<OneTimePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversTypes["PaymentMethodDetails"];
}) | (Omit<FuturePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails?: Maybe<ResolversTypes["PaymentMethodDetails"]>;
}) | ConfigPluginFlowResponse | UpdatePaymentFlowResponse | InvalidSignature | InvalidFlowResult;
FlowGrantResponse: FlowGrant | FlowUnsupported | FlowRequestInvalid;
PaymentMethodDetails: Card | ECheck;
export type TerminalPaymentFlowResponse = FlowResponseType & {
__typename?: "TerminalPaymentFlowResponse";
flowType: PaymentProcessorFlow;
paymentMethodDetails: PaymentMethodDetails;
serviceFeeAmount?: Maybe<Scalars["Float"]>;
txnReferenceId: Scalars["String"];
txnSessionId: Scalars["Int"];
txnSessionMessage?: Maybe<Scalars["String"]>;
txnSessionResultStatus: TerminalPaySessionResultStatus;
};
/** Mapping of union parent types */
export type ResolversUnionParentTypes = {
FlowValidationResponse: (Omit<OnlinePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversParentTypes["PaymentMethodDetails"];
}) | OnlineRefundFlowResponse | OfflineRefundFlowResponse | (Omit<OfflinePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversParentTypes["PaymentMethodDetails"];
}) | (Omit<TerminalPaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversParentTypes["PaymentMethodDetails"];
}) | (Omit<OneTimePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversParentTypes["PaymentMethodDetails"];
}) | (Omit<FuturePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails?: Maybe<ResolversParentTypes["PaymentMethodDetails"]>;
}) | ConfigPluginFlowResponse | UpdatePaymentFlowResponse | InvalidSignature | InvalidFlowResult;
FlowGrantResponse: FlowGrant | FlowUnsupported | FlowRequestInvalid;
PaymentMethodDetails: Card | ECheck;
export { TransactionStatus };
export type UpdatePaymentFlowRequest = {
amount?: InputMaybe<Scalars["Float"]>;
currency?: InputMaybe<Scalars["String"]>;
entityID: Scalars["String"];
paymentID: Scalars["ID"];
processingFee?: InputMaybe<Scalars["Float"]>;
processorID: PaymentProcessorId;
status: TransactionStatus;
tenantID: OpenGovTenant;
transactionID?: InputMaybe<Scalars["String"]>;
};
/** Mapping between all available schema types and the resolvers types */
export type ResolversTypes = {
PaymentAccountToken: ResolverTypeWrapper<Scalars["PaymentAccountToken"]>;
Query: ResolverTypeWrapper<{}>;
SEPSMetadata: ResolverTypeWrapper<SEPSMetadata>;
String: ResolverTypeWrapper<Scalars["String"]>;
PaymentProcessor: ResolverTypeWrapper<PaymentProcessor>;
Int: ResolverTypeWrapper<Scalars["Int"]>;
Boolean: ResolverTypeWrapper<Scalars["Boolean"]>;
ProcessingFeeMetadata: ResolverTypeWrapper<ProcessingFeeMetadata>;
ProcessingFees: ResolverTypeWrapper<ProcessingFees>;
EnvironmentConfig: ResolverTypeWrapper<EnvironmentConfig>;
FlowGrant: ResolverTypeWrapper<FlowGrant>;
FlowUnsupported: ResolverTypeWrapper<FlowUnsupported>;
FlowRequestInvalid: ResolverTypeWrapper<FlowRequestInvalid>;
Card: ResolverTypeWrapper<Card>;
ECheck: ResolverTypeWrapper<ECheck>;
CardDetails: ResolverTypeWrapper<CardDetails>;
ECheckDetails: ResolverTypeWrapper<ECheckDetails>;
ResponseErrorMessage: ResolversTypes["InvalidSignature"] | ResolversTypes["InvalidFlowResult"];
ApplicationMetadata: ApplicationMetadata;
ID: ResolverTypeWrapper<Scalars["ID"]>;
FlowResponseType: ResolversTypes["OnlinePaymentFlowResponse"] | ResolversTypes["OnlineRefundFlowResponse"] | ResolversTypes["OfflineRefundFlowResponse"] | ResolversTypes["OfflinePaymentFlowResponse"] | ResolversTypes["TerminalPaymentFlowResponse"] | ResolversTypes["OneTimePaymentFlowResponse"] | ResolversTypes["FuturePaymentFlowResponse"] | ResolversTypes["ConfigPluginFlowResponse"] | ResolversTypes["UpdatePaymentFlowResponse"];
PaymentProcessorFlow: PaymentProcessorFlow;
FeeItem: FeeItem;
Float: ResolverTypeWrapper<Scalars["Float"]>;
OnlinePaymentFlowRequest: OnlinePaymentFlowRequest;
OnlinePaymentFlowResponse: ResolverTypeWrapper<Omit<OnlinePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversTypes["PaymentMethodDetails"];
}>;
FlowValidationResponse: ResolverTypeWrapper<ResolversUnionTypes["FlowValidationResponse"]>;
Mutation: ResolverTypeWrapper<{}>;
OnlineRefundFlowRequest: OnlineRefundFlowRequest;
OnlineRefundFlowResponse: ResolverTypeWrapper<OnlineRefundFlowResponse>;
RefundMethodDetails: ResolverTypeWrapper<RefundMethodDetails>;
OfflineRefundFlowRequest: OfflineRefundFlowRequest;
OfflineRefundFlowResponse: ResolverTypeWrapper<OfflineRefundFlowResponse>;
OfflinePaymentFlowRequest: OfflinePaymentFlowRequest;
OfflinePaymentFlowResponse: ResolverTypeWrapper<Omit<OfflinePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversTypes["PaymentMethodDetails"];
}>;
TerminalPaymentFlowRequest: TerminalPaymentFlowRequest;
TerminalPaymentFlowResponse: ResolverTypeWrapper<Omit<TerminalPaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversTypes["PaymentMethodDetails"];
}>;
OneTimePaymentFlowRequest: OneTimePaymentFlowRequest;
OneTimePaymentFlowResponse: ResolverTypeWrapper<Omit<OneTimePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversTypes["PaymentMethodDetails"];
}>;
FuturePaymentFlowRequest: FuturePaymentFlowRequest;
FuturePaymentFlowResponse: ResolverTypeWrapper<Omit<FuturePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails?: Maybe<ResolversTypes["PaymentMethodDetails"]>;
}>;
ConfigPluginFlowRequest: ConfigPluginFlowRequest;
ConfigPluginFlowResponse: ResolverTypeWrapper<ConfigPluginFlowResponse>;
UpdatePaymentFlowRequest: UpdatePaymentFlowRequest;
UpdatePaymentFlowResponse: ResolverTypeWrapper<UpdatePaymentFlowResponse>;
Header: Header;
Signature: Signature;
FlowResult: FlowResult;
InvalidSignature: ResolverTypeWrapper<InvalidSignature>;
InvalidFlowResult: ResolverTypeWrapper<InvalidFlowResult>;
CardType: CardType;
TerminalPaySessionResultStatus: TerminalPaySessionResultStatus;
ImplementationTeam: ImplementationTeam;
PaymentMethod: PaymentMethod;
ConfigScope: ConfigScope;
PaymentProcessorId: PaymentProcessorId;
OpenGovTenant: OpenGovTenant;
TransactionStatus: TransactionStatus;
FlowGrantResponse: ResolverTypeWrapper<ResolversUnionTypes["FlowGrantResponse"]>;
PaymentMethodDetails: ResolverTypeWrapper<ResolversUnionTypes["PaymentMethodDetails"]>;
export type UpdatePaymentFlowResponse = FlowResponseType & {
__typename?: "UpdatePaymentFlowResponse";
amount?: Maybe<Scalars["Float"]>;
currency?: Maybe<Scalars["String"]>;
entityID: Scalars["String"];
flowType: PaymentProcessorFlow;
paymentID: Scalars["ID"];
processingFee?: Maybe<Scalars["Float"]>;
processorID: PaymentProcessorId;
status: TransactionStatus;
tenantID: OpenGovTenant;
transactionID?: Maybe<Scalars["String"]>;
};
/** Mapping between all available schema types and the resolvers parents */
export type ResolversParentTypes = {
PaymentAccountToken: Scalars["PaymentAccountToken"];
Query: {};
SEPSMetadata: SEPSMetadata;
String: Scalars["String"];
PaymentProcessor: PaymentProcessor;
Int: Scalars["Int"];
Boolean: Scalars["Boolean"];
ProcessingFeeMetadata: ProcessingFeeMetadata;
ProcessingFees: ProcessingFees;
EnvironmentConfig: EnvironmentConfig;
FlowGrant: FlowGrant;
FlowUnsupported: FlowUnsupported;
FlowRequestInvalid: FlowRequestInvalid;
Card: Card;
ECheck: ECheck;
CardDetails: CardDetails;
ECheckDetails: ECheckDetails;
ResponseErrorMessage: ResolversParentTypes["InvalidSignature"] | ResolversParentTypes["InvalidFlowResult"];
ApplicationMetadata: ApplicationMetadata;
ID: Scalars["ID"];
FlowResponseType: ResolversParentTypes["OnlinePaymentFlowResponse"] | ResolversParentTypes["OnlineRefundFlowResponse"] | ResolversParentTypes["OfflineRefundFlowResponse"] | ResolversParentTypes["OfflinePaymentFlowResponse"] | ResolversParentTypes["TerminalPaymentFlowResponse"] | ResolversParentTypes["OneTimePaymentFlowResponse"] | ResolversParentTypes["FuturePaymentFlowResponse"] | ResolversParentTypes["ConfigPluginFlowResponse"] | ResolversParentTypes["UpdatePaymentFlowResponse"];
FeeItem: FeeItem;
Float: Scalars["Float"];
OnlinePaymentFlowRequest: OnlinePaymentFlowRequest;
OnlinePaymentFlowResponse: Omit<OnlinePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversParentTypes["PaymentMethodDetails"];
};
FlowValidationResponse: ResolversUnionParentTypes["FlowValidationResponse"];
Mutation: {};
OnlineRefundFlowRequest: OnlineRefundFlowRequest;
OnlineRefundFlowResponse: OnlineRefundFlowResponse;
RefundMethodDetails: RefundMethodDetails;
OfflineRefundFlowRequest: OfflineRefundFlowRequest;
OfflineRefundFlowResponse: OfflineRefundFlowResponse;
OfflinePaymentFlowRequest: OfflinePaymentFlowRequest;
OfflinePaymentFlowResponse: Omit<OfflinePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversParentTypes["PaymentMethodDetails"];
};
TerminalPaymentFlowRequest: TerminalPaymentFlowRequest;
TerminalPaymentFlowResponse: Omit<TerminalPaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversParentTypes["PaymentMethodDetails"];
};
OneTimePaymentFlowRequest: OneTimePaymentFlowRequest;
OneTimePaymentFlowResponse: Omit<OneTimePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails: ResolversParentTypes["PaymentMethodDetails"];
};
FuturePaymentFlowRequest: FuturePaymentFlowRequest;
FuturePaymentFlowResponse: Omit<FuturePaymentFlowResponse, "paymentMethodDetails"> & {
paymentMethodDetails?: Maybe<ResolversParentTypes["PaymentMethodDetails"]>;
};
ConfigPluginFlowRequest: ConfigPluginFlowRequest;
ConfigPluginFlowResponse: ConfigPluginFlowResponse;
UpdatePaymentFlowRequest: UpdatePaymentFlowRequest;
UpdatePaymentFlowResponse: UpdatePaymentFlowResponse;
Header: Header;
Signature: Signature;
FlowResult: FlowResult;
InvalidSignature: InvalidSignature;
InvalidFlowResult: InvalidFlowResult;
FlowGrantResponse: ResolversUnionParentTypes["FlowGrantResponse"];
PaymentMethodDetails: ResolversUnionParentTypes["PaymentMethodDetails"];
};
export type authDirectiveArgs = {};
export type authDirectiveResolver<Result, Parent, ContextType = MercuriusContext, Args = authDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
export type constraintDirectiveArgs = {
maximum?: Maybe<Scalars["Int"]>;
minimum?: Maybe<Scalars["Int"]>;
exclusiveMaximum?: Maybe<Scalars["Int"]>;
exclusiveMinimum?: Maybe<Scalars["Int"]>;
multipleOf?: Maybe<Scalars["Int"]>;
maxLength?: Maybe<Scalars["Int"]>;
minLength?: Maybe<Scalars["Int"]>;
pattern?: Maybe<Scalars["String"]>;
maxProperties?: Maybe<Scalars["Int"]>;
minProperties?: Maybe<Scalars["Int"]>;
required?: Maybe<Array<Scalars["String"]>>;
maxItems?: Maybe<Scalars["Int"]>;
minItems?: Maybe<Scalars["Int"]>;
uniqueItems?: Maybe<Scalars["Boolean"]>;
type?: Maybe<Array<Scalars["String"]>>;
format?: Maybe<Scalars["String"]>;
schema?: Maybe<Scalars["String"]>;
};
export type constraintDirectiveResolver<Result, Parent, ContextType = MercuriusContext, Args = constraintDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
export interface PaymentAccountTokenScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes["PaymentAccountToken"], any> {
name: "PaymentAccountToken";
}
export type QueryResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["Query"] = ResolversParentTypes["Query"]> = {
paymentProcessor?: Resolver<Maybe<ResolversTypes["PaymentProcessor"]>, ParentType, ContextType, RequireFields<QuerypaymentProcessorArgs, "id">>;
SEPSMetadata?: Resolver<ResolversTypes["SEPSMetadata"], ParentType, ContextType>;
};
export type SEPSMetadataResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["SEPSMetadata"] = ResolversParentTypes["SEPSMetadata"]> = {
environment?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
supportedPaymentProcessors?: Resolver<Array<ResolversTypes["PaymentProcessor"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type PaymentProcessorResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["PaymentProcessor"] = ResolversParentTypes["PaymentProcessor"]> = {
id?: Resolver<ResolversTypes["PaymentProcessorId"], ParentType, ContextType>;
name?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
supportedFlows?: Resolver<Array<ResolversTypes["PaymentProcessorFlow"]>, ParentType, ContextType>;
supportedPaymentMethods?: Resolver<Array<ResolversTypes["PaymentMethod"]>, ParentType, ContextType>;
baseFee?: Resolver<Maybe<ResolversTypes["Int"]>, ParentType, ContextType>;
supportsWebhooks?: Resolver<Maybe<ResolversTypes["Boolean"]>, ParentType, ContextType>;
implementationTeam?: Resolver<Maybe<ResolversTypes["ImplementationTeam"]>, ParentType, ContextType>;
processingFees?: Resolver<Maybe<ResolversTypes["ProcessingFees"]>, ParentType, ContextType>;
clientPluginUrl?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
pluginDependencyUrls?: Resolver<Maybe<Array<ResolversTypes["String"]>>, ParentType, ContextType>;
config?: Resolver<Maybe<Array<ResolversTypes["EnvironmentConfig"]>>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type ProcessingFeeMetadataResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["ProcessingFeeMetadata"] = ResolversParentTypes["ProcessingFeeMetadata"]> = {
allowCommunityPays?: Resolver<Maybe<ResolversTypes["Boolean"]>, ParentType, ContextType>;
fee?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
scheduled?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type ProcessingFeesResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["ProcessingFees"] = ResolversParentTypes["ProcessingFees"]> = {
E_CHECK?: Resolver<Maybe<ResolversTypes["ProcessingFeeMetadata"]>, ParentType, ContextType>;
CREDIT_CARD?: Resolver<Maybe<ResolversTypes["ProcessingFeeMetadata"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type EnvironmentConfigResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["EnvironmentConfig"] = ResolversParentTypes["EnvironmentConfig"]> = {
key?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
value?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type FlowGrantResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["FlowGrant"] = ResolversParentTypes["FlowGrant"]> = {
flowType?: Resolver<ResolversTypes["PaymentProcessorFlow"], ParentType, ContextType>;
flowToken?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type FlowUnsupportedResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["FlowUnsupported"] = ResolversParentTypes["FlowUnsupported"]> = {
message?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type FlowRequestInvalidResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["FlowRequestInvalid"] = ResolversParentTypes["FlowRequestInvalid"]> = {
message?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type CardResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["Card"] = ResolversParentTypes["Card"]> = {
card?: Resolver<ResolversTypes["CardDetails"], ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type ECheckResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["ECheck"] = ResolversParentTypes["ECheck"]> = {
e_check?: Resolver<ResolversTypes["ECheckDetails"], ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type CardDetailsResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["CardDetails"] = ResolversParentTypes["CardDetails"]> = {
last4?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
cardType?: Resolver<Maybe<ResolversTypes["CardType"]>, ParentType, ContextType>;
authorizationCode?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type ECheckDetailsResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["ECheckDetails"] = ResolversParentTypes["ECheckDetails"]> = {
last4?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type ResponseErrorMessageResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["ResponseErrorMessage"] = ResolversParentTypes["ResponseErrorMessage"]> = {
resolveType: TypeResolveFn<"InvalidSignature" | "InvalidFlowResult", ParentType, ContextType>;
message?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
};
export type FlowResponseTypeResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["FlowResponseType"] = ResolversParentTypes["FlowResponseType"]> = {
resolveType: TypeResolveFn<"OnlinePaymentFlowResponse" | "OnlineRefundFlowResponse" | "OfflineRefundFlowResponse" | "OfflinePaymentFlowResponse" | "TerminalPaymentFlowResponse" | "OneTimePaymentFlowResponse" | "FuturePaymentFlowResponse" | "ConfigPluginFlowResponse" | "UpdatePaymentFlowResponse", ParentType, ContextType>;
flowType?: Resolver<ResolversTypes["PaymentProcessorFlow"], ParentType, ContextType>;
};
export type PaymentProcessorFlowResolvers = EnumResolverSignature<{
UPDATE_PAYMENT?: any;
CONFIG?: any;
FUTURE_PAYMENT?: any;
ONE_TIME_PAYMENT?: any;
TERMINAL_PAYMENT?: any;
OFFLINE_PAYMENT?: any;
OFFLINE_REFUND?: any;
ONLINE_REFUND?: any;
ONLINE_PAYMENT?: any;
ONETIME_PAYMENT?: any;
}, ResolversTypes["PaymentProcessorFlow"]>;
export type OnlinePaymentFlowResponseResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["OnlinePaymentFlowResponse"] = ResolversParentTypes["OnlinePaymentFlowResponse"]> = {
flowType?: Resolver<ResolversTypes["PaymentProcessorFlow"], ParentType, ContextType>;
paymentID?: Resolver<ResolversTypes["ID"], ParentType, ContextType>;
transactionID?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
amount?: Resolver<Maybe<ResolversTypes["Float"]>, ParentType, ContextType>;
processingFee?: Resolver<Maybe<ResolversTypes["Float"]>, ParentType, ContextType>;
currency?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
description?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
status?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
paymentMethodDetails?: Resolver<ResolversTypes["PaymentMethodDetails"], ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type FlowValidationResponseResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["FlowValidationResponse"] = ResolversParentTypes["FlowValidationResponse"]> = {
resolveType: TypeResolveFn<"OnlinePaymentFlowResponse" | "OnlineRefundFlowResponse" | "OfflineRefundFlowResponse" | "OfflinePaymentFlowResponse" | "TerminalPaymentFlowResponse" | "OneTimePaymentFlowResponse" | "FuturePaymentFlowResponse" | "ConfigPluginFlowResponse" | "UpdatePaymentFlowResponse" | "InvalidSignature" | "InvalidFlowResult", ParentType, ContextType>;
};
export type MutationResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["Mutation"] = ResolversParentTypes["Mutation"]> = {
onlinePayment?: Resolver<ResolversTypes["FlowGrantResponse"], ParentType, ContextType, Partial<MutationonlinePaymentArgs>>;
onlineRefund?: Resolver<ResolversTypes["FlowGrantResponse"], ParentType, ContextType, Partial<MutationonlineRefundArgs>>;
offlineRefund?: Resolver<ResolversTypes["FlowGrantResponse"], ParentType, ContextType, Partial<MutationofflineRefundArgs>>;
offlinePayment?: Resolver<ResolversTypes["FlowGrantResponse"], ParentType, ContextType, Partial<MutationofflinePaymentArgs>>;
terminalPayment?: Resolver<ResolversTypes["FlowGrantResponse"], ParentType, ContextType, Partial<MutationterminalPaymentArgs>>;
oneTimePayment?: Resolver<ResolversTypes["FlowGrantResponse"], ParentType, ContextType, Partial<MutationoneTimePaymentArgs>>;
futurePayment?: Resolver<ResolversTypes["FlowGrantResponse"], ParentType, ContextType, Partial<MutationfuturePaymentArgs>>;
configPlugin?: Resolver<ResolversTypes["FlowGrantResponse"], ParentType, ContextType, Partial<MutationconfigPluginArgs>>;
updatePayment?: Resolver<ResolversTypes["FlowGrantResponse"], ParentType, ContextType, Partial<MutationupdatePaymentArgs>>;
validateFlowResult?: Resolver<ResolversTypes["FlowValidationResponse"], ParentType, ContextType, RequireFields<MutationvalidateFlowResultArgs, "flowResult">>;
};
export type OnlineRefundFlowResponseResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["OnlineRefundFlowResponse"] = ResolversParentTypes["OnlineRefundFlowResponse"]> = {
flowType?: Resolver<ResolversTypes["PaymentProcessorFlow"], ParentType, ContextType>;
paymentID?: Resolver<ResolversTypes["ID"], ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type RefundMethodDetailsResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["RefundMethodDetails"] = ResolversParentTypes["RefundMethodDetails"]> = {
recordID?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
recordStepID?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
feeID?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
userID?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
label?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type OfflineRefundFlowResponseResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["OfflineRefundFlowResponse"] = ResolversParentTypes["OfflineRefundFlowResponse"]> = {
flowType?: Resolver<ResolversTypes["PaymentProcessorFlow"], ParentType, ContextType>;
originalPaymentID?: Resolver<ResolversTypes["ID"], ParentType, ContextType>;
paymentID?: Resolver<ResolversTypes["ID"], ParentType, ContextType>;
amount?: Resolver<ResolversTypes["Float"], ParentType, ContextType>;
currency?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
offlineRefundDetails?: Resolver<Maybe<ResolversTypes["RefundMethodDetails"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type OfflinePaymentFlowResponseResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["OfflinePaymentFlowResponse"] = ResolversParentTypes["OfflinePaymentFlowResponse"]> = {
flowType?: Resolver<ResolversTypes["PaymentProcessorFlow"], ParentType, ContextType>;
paymentID?: Resolver<ResolversTypes["ID"], ParentType, ContextType>;
transactionID?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
amount?: Resolver<Maybe<ResolversTypes["Float"]>, ParentType, ContextType>;
processingFee?: Resolver<Maybe<ResolversTypes["Float"]>, ParentType, ContextType>;
currency?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
description?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
status?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
paymentMethodDetails?: Resolver<ResolversTypes["PaymentMethodDetails"], ParentType, ContextType>;
paymentAccountToken?: Resolver<Maybe<ResolversTypes["PaymentAccountToken"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type TerminalPaymentFlowResponseResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["TerminalPaymentFlowResponse"] = ResolversParentTypes["TerminalPaymentFlowResponse"]> = {
flowType?: Resolver<ResolversTypes["PaymentProcessorFlow"], ParentType, ContextType>;
txnReferenceId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
txnSessionId?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
txnSessionResultStatus?: Resolver<ResolversTypes["TerminalPaySessionResultStatus"], ParentType, ContextType>;
txnSessionMessage?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
serviceFeeAmount?: Resolver<Maybe<ResolversTypes["Float"]>, ParentType, ContextType>;
paymentMethodDetails?: Resolver<ResolversTypes["PaymentMethodDetails"], ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type OneTimePaymentFlowResponseResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["OneTimePaymentFlowResponse"] = ResolversParentTypes["OneTimePaymentFlowResponse"]> = {
flowType?: Resolver<ResolversTypes["PaymentProcessorFlow"], ParentType, ContextType>;
paymentID?: Resolver<ResolversTypes["ID"], ParentType, ContextType>;
transactionID?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
amount?: Resolver<Maybe<ResolversTypes["Float"]>, ParentType, ContextType>;
processingFee?: Resolver<Maybe<ResolversTypes["Float"]>, ParentType, ContextType>;
currency?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
description?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
status?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
paymentMethodDetails?: Resolver<ResolversTypes["PaymentMethodDetails"], ParentType, ContextType>;
paymentAccountToken?: Resolver<Maybe<ResolversTypes["PaymentAccountToken"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type FuturePaymentFlowResponseResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["FuturePaymentFlowResponse"] = ResolversParentTypes["FuturePaymentFlowResponse"]> = {
flowType?: Resolver<ResolversTypes["PaymentProcessorFlow"], ParentType, ContextType>;
status?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
paymentAccountToken?: Resolver<Maybe<ResolversTypes["PaymentAccountToken"]>, ParentType, ContextType>;
paymentMethodDetails?: Resolver<Maybe<ResolversTypes["PaymentMethodDetails"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type ConfigPluginFlowResponseResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["ConfigPluginFlowResponse"] = ResolversParentTypes["ConfigPluginFlowResponse"]> = {
flowType?: Resolver<ResolversTypes["PaymentProcessorFlow"], ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type UpdatePaymentFlowResponseResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["UpdatePaymentFlowResponse"] = ResolversParentTypes["UpdatePaymentFlowResponse"]> = {
flowType?: Resolver<ResolversTypes["PaymentProcessorFlow"], ParentType, ContextType>;
processorID?: Resolver<ResolversTypes["PaymentProcessorId"], ParentType, ContextType>;
entityID?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
status?: Resolver<ResolversTypes["TransactionStatus"], ParentType, ContextType>;
tenantID?: Resolver<ResolversTypes["OpenGovTenant"], ParentType, ContextType>;
paymentID?: Resolver<ResolversTypes["ID"], ParentType, ContextType>;
transactionID?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
amount?: Resolver<Maybe<ResolversTypes["Float"]>, ParentType, ContextType>;
processingFee?: Resolver<Maybe<ResolversTypes["Float"]>, ParentType, ContextType>;
currency?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type InvalidSignatureResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["InvalidSignature"] = ResolversParentTypes["InvalidSignature"]> = {
message?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type InvalidFlowResultResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["InvalidFlowResult"] = ResolversParentTypes["InvalidFlowResult"]> = {
message?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};
export type ImplementationTeamResolvers = EnumResolverSignature<{
PROFESSIONAL_SERVICES?: any;
ENGINEERING?: any;
}, ResolversTypes["ImplementationTeam"]>;
export type PaymentMethodResolvers = EnumResolverSignature<{
CREDIT_CARD?: any;
E_CHECK?: any;
}, ResolversTypes["PaymentMethod"]>;
export type ConfigScopeResolvers = EnumResolverSignature<{
PUBLIC?: any;
PRIVATE?: any;
}, ResolversTypes["ConfigScope"]>;
export type PaymentProcessorIdResolvers = EnumResolverSignature<{
elavonHosted?: any;
paymentTechHosted?: any;
paymentusHosted?: any;
orbiPay?: any;
paceFuze?: any;
}, ResolversTypes["PaymentProcessorId"]>;
export type FlowGrantResponseResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["FlowGrantResponse"] = ResolversParentTypes["FlowGrantResponse"]> = {
resolveType: TypeResolveFn<"FlowGrant" | "FlowUnsupported" | "FlowRequestInvalid", ParentType, ContextType>;
};
export type PaymentMethodDetailsResolvers<ContextType = MercuriusContext, ParentType extends ResolversParentTypes["PaymentMethodDetails"] = ResolversParentTypes["PaymentMethodDetails"]> = {
resolveType: TypeResolveFn<"Card" | "ECheck", ParentType, ContextType>;
};
export type Resolvers<ContextType = MercuriusContext> = {
PaymentAccountToken?: GraphQLScalarType;
Query?: QueryResolvers<ContextType>;
SEPSMetadata?: SEPSMetadataResolvers<ContextType>;
PaymentProcessor?: PaymentProcessorResolvers<ContextType>;
ProcessingFeeMetadata?: ProcessingFeeMetadataResolvers<ContextType>;
ProcessingFees?: ProcessingFeesResolvers<ContextType>;
EnvironmentConfig?: EnvironmentConfigResolvers<ContextType>;
FlowGrant?: FlowGrantResolvers<ContextType>;
FlowUnsupported?: FlowUnsupportedResolvers<ContextType>;
FlowRequestInvalid?: FlowRequestInvalidResolvers<ContextType>;
Card?: CardResolvers<ContextType>;
ECheck?: ECheckResolvers<ContextType>;
CardDetails?: CardDetailsResolvers<ContextType>;
ECheckDetails?: ECheckDetailsResolvers<ContextType>;
ResponseErrorMessage?: ResponseErrorMessageResolvers<ContextType>;
FlowResponseType?: FlowResponseTypeResolvers<ContextType>;
PaymentProcessorFlow?: PaymentProcessorFlowResolvers;
OnlinePaymentFlowResponse?: OnlinePaymentFlowResponseResolvers<ContextType>;
FlowValidationResponse?: FlowValidationResponseResolvers<ContextType>;
Mutation?: MutationResolvers<ContextType>;
OnlineRefundFlowResponse?: OnlineRefundFlowResponseResolvers<ContextType>;
RefundMethodDetails?: RefundMethodDetailsResolvers<ContextType>;
OfflineRefundFlowResponse?: OfflineRefundFlowResponseResolvers<ContextType>;
OfflinePaymentFlowResponse?: OfflinePaymentFlowResponseResolvers<ContextType>;
TerminalPaymentFlowResponse?: TerminalPaymentFlowResponseResolvers<ContextType>;
OneTimePaymentFlowResponse?: OneTimePaymentFlowResponseResolvers<ContextType>;
FuturePaymentFlowResponse?: FuturePaymentFlowResponseResolvers<ContextType>;
ConfigPluginFlowResponse?: ConfigPluginFlowResponseResolvers<ContextType>;
UpdatePaymentFlowResponse?: UpdatePaymentFlowResponseResolvers<ContextType>;
InvalidSignature?: InvalidSignatureResolvers<ContextType>;
InvalidFlowResult?: InvalidFlowResultResolvers<ContextType>;
ImplementationTeam?: ImplementationTeamResolvers;
PaymentMethod?: PaymentMethodResolvers;
ConfigScope?: ConfigScopeResolvers;
PaymentProcessorId?: PaymentProcessorIdResolvers;
FlowGrantResponse?: FlowGrantResponseResolvers<ContextType>;
PaymentMethodDetails?: PaymentMethodDetailsResolvers<ContextType>;
};
export type DirectiveResolvers<ContextType = MercuriusContext> = {
auth?: authDirectiveResolver<any, any, ContextType>;
constraint?: constraintDirectiveResolver<any, any, ContextType>;
};
export type Loader<TReturn, TObj, TParams, TContext> = (queries: Array<{
obj: TObj;
params: TParams;
}>, context: TContext & {
reply: import("fastify").FastifyReply;
}) => Promise<Array<import("mercurius-codegen").DeepPartial<TReturn>>>;
export type LoaderResolver<TReturn, TObj, TParams, TContext> = Loader<TReturn, TObj, TParams, TContext> | {
loader: Loader<TReturn, TObj, TParams, TContext>;
opts?: {
cache?: boolean;
};
};
export interface Loaders<TContext = import("mercurius").MercuriusContext & {
reply: import("fastify").FastifyReply;
}> {
SEPSMetadata?: {
environment?: LoaderResolver<Scalars["String"], SEPSMetadata, {}, TContext>;
supportedPaymentProcessors?: LoaderResolver<Array<PaymentProcessor>, SEPSMetadata, {}, TContext>;
};
PaymentProcessor?: {
id?: LoaderResolver<PaymentProcessorId, PaymentProcessor, {}, TContext>;
name?: LoaderResolver<Scalars["String"], PaymentProcessor, {}, TContext>;
supportedFlows?: LoaderResolver<Array<PaymentProcessorFlow>, PaymentProcessor, {}, TContext>;
supportedPaymentMethods?: LoaderResolver<Array<PaymentMethod>, PaymentProcessor, {}, TContext>;
baseFee?: LoaderResolver<Maybe<Scalars["Int"]>, PaymentProcessor, {}, TContext>;
supportsWebhooks?: LoaderResolver<Maybe<Scalars["Boolean"]>, PaymentProcessor, {}, TContext>;
implementationTeam?: LoaderResolver<Maybe<ImplementationTeam>, PaymentProcessor, {}, TContext>;
processingFees?: LoaderResolver<Maybe<ProcessingFees>, PaymentProcessor, {}, TContext>;
clientPluginUrl?: LoaderResolver<Maybe<Scalars["String"]>, PaymentProcessor, {}, TContext>;
pluginDependencyUrls?: LoaderResolver<Maybe<Array<Scalars["String"]>>, PaymentProcessor, {}, TContext>;
config?: LoaderResolver<Maybe<Array<EnvironmentConfig>>, PaymentProcessor, {}, TContext>;
};
ProcessingFeeMetadata?: {
allowCommunityPays?: LoaderResolver<Maybe<Scalars["Boolean"]>, ProcessingFeeMetadata, {}, TContext>;
fee?: LoaderResolver<Maybe<Scalars["String"]>, ProcessingFeeMetadata, {}, TContext>;
scheduled?: LoaderResolver<Maybe<Scalars["String"]>, ProcessingFeeMetadata, {}, TContext>;
};
ProcessingFees?: {
E_CHECK?: LoaderResolver<Maybe<ProcessingFeeMetadata>, ProcessingFees, {}, TContext>;
CREDIT_CARD?: LoaderResolver<Maybe<ProcessingFeeMetadata>, ProcessingFees, {}, TContext>;
};
EnvironmentConfig?: {
key?: LoaderResolver<Scalars["String"], EnvironmentConfig, {}, TContext>;
value?: LoaderResolver<Maybe<Scalars["String"]>, EnvironmentConfig, {}, TContext>;
};
FlowGrant?: {
flowType?: LoaderResolver<PaymentProcessorFlow, FlowGrant, {}, TContext>;
flowToken?: LoaderResolver<Scalars["String"], FlowGrant, {}, TContext>;
};
FlowUnsupported?: {
message?: LoaderResolver<Maybe<Scalars["String"]>, FlowUnsupported, {}, TContext>;
};
FlowRequestInvalid?: {
message?: LoaderResolver<Maybe<Scalars["String"]>, FlowRequestInvalid, {}, TContext>;
};
Card?: {
card?: LoaderResolver<CardDetails, Card, {}, TContext>;
};
ECheck?: {
e_check?: LoaderResolver<ECheckDetails, ECheck, {}, TContext>;
};
CardDetails?: {
last4?: LoaderResolver<Maybe<Scalars["String"]>, CardDetails, {}, TContext>;
cardType?: LoaderResolver<Maybe<CardType>, CardDetails, {}, TContext>;
authorizationCode?: LoaderResolver<Maybe<Scalars["String"]>, CardDetails, {}, TContext>;
};
ECheckDetails?: {
last4?: LoaderResolver<Maybe<Scalars["String"]>, ECheckDetails, {}, TContext>;
};
OnlinePaymentFlowResponse?: {
flowType?: LoaderResolver<PaymentProcessorFlow, OnlinePaymentFlowResponse, {}, TContext>;
paymentID?: LoaderResolver<Scalars["ID"], OnlinePaymentFlowResponse, {}, TContext>;
transactionID?: LoaderResolver<Maybe<Scalars["String"]>, OnlinePaymentFlowResponse, {}, TContext>;
amount?: LoaderResolver<Maybe<Scalars["Float"]>, OnlinePaymentFlowResponse, {}, TContext>;
processingFee?: LoaderResolver<Maybe<Scalars["Float"]>, OnlinePaymentFlowResponse, {}, TContext>;
currency?: LoaderResolver<Maybe<Scalars["String"]>, OnlinePaymentFlowResponse, {}, TContext>;
description?: LoaderResolver<Maybe<Scalars["String"]>, OnlinePaymentFlowResponse, {}, TContext>;
status?: LoaderResolver<Scalars["String"], OnlinePaymentFlowResponse, {}, TContext>;
paymentMethodDetails?: LoaderResolver<PaymentMethodDetails, OnlinePaymentFlowResponse, {}, TContext>;
};
OnlineRefundFlowResponse?: {
flowType?: LoaderResolver<PaymentProcessorFlow, OnlineRefundFlowResponse, {}, TContext>;
paymentID?: LoaderResolver<Scalars["ID"], OnlineRefundFlowResponse, {}, TContext>;
};
RefundMethodDetails?: {
recordID?: LoaderResolver<Maybe<Scalars["String"]>, RefundMethodDetails, {}, TContext>;
recordStepID?: LoaderResolver<Maybe<Scalars["String"]>, RefundMethodDetails, {}, TContext>;
feeID?: LoaderResolver<Maybe<Scalars["String"]>, RefundMethodDetails, {}, TContext>;
userID?: LoaderResolver<Maybe<Scalars["String"]>, RefundMethodDetails, {}, TContext>;
label?: LoaderResolver<Maybe<Scalars["String"]>, RefundMethodDetails, {}, TContext>;
};
OfflineRefundFlowResponse?: {
flowType?: LoaderResolver<PaymentProcessorFlow, OfflineRefundFlowResponse, {}, TContext>;
originalPaymentID?: LoaderResolver<Scalars["ID"], OfflineRefundFlowResponse, {}, TContext>;
paymentID?: LoaderResolver<Scalars["ID"], OfflineRefundFlowResponse, {}, TContext>;
amount?: LoaderResolver<Scalars["Float"], OfflineRefundFlowResponse, {}, TContext>;
currency?: LoaderResolver<Maybe<Scalars["String"]>, OfflineRefundFlowResponse, {}, TContext>;
offlineRefundDetails?: LoaderResolver<Maybe<RefundMethodDetails>, OfflineRefundFlowResponse, {}, TContext>;
};
OfflinePaymentFlowResponse?: {
flowType?: LoaderResolver<PaymentProcessorFlow, OfflinePaymentFlowResponse, {}, TContext>;
paymentID?: LoaderResolver<Scalars["ID"], OfflinePaymentFlowResponse, {}, TContext>;
transactionID?: LoaderResolver<Maybe<Scalars["String"]>, OfflinePaymentFlowResponse, {}, TContext>;
amount?: LoaderResolver<Maybe<Scalars["Float"]>, OfflinePaymentFlowResponse, {}, TContext>;
processingFee?: LoaderResolver<Maybe<Scalars["Float"]>, OfflinePaymentFlowResponse, {}, TContext>;
currency?: LoaderResolver<Maybe<Scalars["String"]>, OfflinePaymentFlowResponse, {}, TContext>;
description?: LoaderResolver<Maybe<Scalars["String"]>, OfflinePaymentFlowResponse, {}, TContext>;
status?: LoaderResolver<Scalars["String"], OfflinePaymentFlowResponse, {}, TContext>;
paymentMethodDetails?: LoaderResolver<PaymentMethodDetails, OfflinePaymentFlowResponse, {}, TContext>;
paymentAccountToken?: LoaderResolver<Maybe<Scalars["PaymentAccountToken"]>, OfflinePaymentFlowResponse, {}, TContext>;
};
TerminalPaymentFlowResponse?: {
flowType?: LoaderResolver<PaymentProcessorFlow, TerminalPaymentFlowResponse, {}, TContext>;
txnReferenceId?: LoaderResolver<Scalars["String"], TerminalPaymentFlowResponse, {}, TContext>;
txnSessionId?: LoaderResolver<Scalars["Int"], TerminalPaymentFlowResponse, {}, TContext>;
txnSessionResultStatus?: LoaderResolver<TerminalPaySessionResultStatus, TerminalPaymentFlowResponse, {}, TContext>;
txnSessionMessage?: LoaderResolver<Maybe<Scalars["String"]>, TerminalPaymentFlowResponse, {}, TContext>;
serviceFeeAmount?: LoaderResolver<Maybe<Scalars["Float"]>, TerminalPaymentFlowResponse, {}, TContext>;
paymentMethodDetails?: LoaderResolver<PaymentMethodDetails, TerminalPaymentFlowResponse, {}, TContext>;
};
OneTimePaymentFlowResponse?: {
flowType?: LoaderResolver<PaymentProcessorFlow, OneTimePaymentFlowResponse, {}, TContext>;
paymentID?: LoaderResolver<Scalars["ID"], OneTimePaymentFlowResponse, {}, TContext>;
transactionID?: LoaderResolver<Maybe<Scalars["String"]>, OneTimePaymentFlowResponse, {}, TContext>;
amount?: LoaderResolver<Maybe<Scalars["Float"]>, OneTimePaymentFlowResponse, {}, TContext>;
processingFee?: LoaderResolver<Maybe<Scalars["Float"]>, OneTimePaymentFlowResponse, {}, TContext>;
currency?: LoaderResolver<Maybe<Scalars["String"]>, OneTimePaymentFlowResponse, {}, TContext>;
description?: LoaderResolver<Maybe<Scalars["String"]>, OneTimePaymentFlowResponse, {}, TContext>;
status?: LoaderResolver<Scalars["String"], OneTimePaymentFlowResponse, {}, TContext>;
paymentMethodDetails?: LoaderResolver<PaymentMethodDetails, OneTimePaymentFlowResponse, {}, TContext>;
paymentAccountToken?: LoaderResolver<Maybe<Scalars["PaymentAccountToken"]>, OneTimePaymentFlowResponse, {}, TContext>;
};
FuturePaymentFlowResponse?: {
flowType?: LoaderResolver<PaymentProcessorFlow, FuturePaymentFlowResponse, {}, TContext>;
status?: LoaderResolver<Scalars["String"], FuturePaymentFlowResponse, {}, TContext>;
paymentAccountToken?: LoaderResolver<Maybe<Scalars["PaymentAccountToken"]>, FuturePaymentFlowResponse, {}, TContext>;
paymentMethodDetails?: LoaderResolver<Maybe<PaymentMethodDetails>, FuturePaymentFlowResponse, {}, TContext>;
};
ConfigPluginFlowResponse?: {
flowType?: LoaderResolver<PaymentProcessorFlow, ConfigPluginFlowResponse, {}, TContext>;
};
UpdatePaymentFlowResponse?: {
flowType?: LoaderResolver<PaymentProcessorFlow, UpdatePaymentFlowResponse, {}, TContext>;
processorID?: LoaderResolver<PaymentProcessorId, UpdatePaymentFlowResponse, {}, TContext>;
entityID?: LoaderResolver<Scalars["String"], UpdatePaymentFlowResponse, {}, TContext>;
status?: LoaderResolver<TransactionStatus, UpdatePaymentFlowResponse, {}, TContext>;
tenantID?: LoaderResolver<OpenGovTenant, UpdatePaymentFlowResponse, {}, TContext>;
paymentID?: LoaderResolver<Scalars["ID"], UpdatePaymentFlowResponse, {}, TContext>;
transactionID?: LoaderResolver<Maybe<Scalars["String"]>, UpdatePaymentFlowResponse, {}, TContext>;
amount?: LoaderResolver<Maybe<Scalars["Float"]>, UpdatePaymentFlowResponse, {}, TContext>;
processingFee?: LoaderResolver<Maybe<Scalars["Float"]>, UpdatePaymentFlowResponse, {}, TContext>;
currency?: LoaderResolver<Maybe<Scalars["String"]>, UpdatePaymentFlowResponse, {}, TContext>;
};
InvalidSignature?: {
message?: LoaderResolver<Scalars["String"], InvalidSignature, {}, TContext>;
};
InvalidFlowResult?: {
message?: LoaderResolver<Scalars["String"], InvalidFlowResult, {}, TContext>;
};
}
declare module "mercurius" {
interface IResolvers extends Resolvers<import("mercurius").MercuriusContext> {
}
interface MercuriusLoaders extends Loaders {
}
}
//# sourceMappingURL=generated.d.ts.map

30

dist/types/generated.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.TransactionStatus = exports.OpenGovTenant = exports.TerminalPaySessionResultStatus = exports.CardType = void 0;
exports.TransactionStatus = exports.TerminalPaySessionResultStatus = exports.PaymentProcessorId = exports.PaymentProcessorFlow = exports.PaymentMethod = exports.OpenGovTenant = exports.ImplementationTeam = exports.ConfigScope = exports.CardType = void 0;
const enums_1 = require("./enums");
Object.defineProperty(exports, "PaymentProcessorFlow", { enumerable: true, get: function () { return enums_1.PaymentProcessorFlow; } });
const enums_2 = require("./enums");
Object.defineProperty(exports, "ConfigScope", { enumerable: true, get: function () { return enums_2.ConfigScope; } });
const enums_3 = require("./enums");
Object.defineProperty(exports, "PaymentMethod", { enumerable: true, get: function () { return enums_3.PaymentMethod; } });
const enums_4 = require("./enums");
Object.defineProperty(exports, "ImplementationTeam", { enumerable: true, get: function () { return enums_4.ImplementationTeam; } });
const enums_5 = require("./enums");
Object.defineProperty(exports, "PaymentProcessorId", { enumerable: true, get: function () { return enums_5.PaymentProcessorId; } });
const enums_6 = require("./enums");
Object.defineProperty(exports, "OpenGovTenant", { enumerable: true, get: function () { return enums_6.OpenGovTenant; } });
const enums_7 = require("./enums");
Object.defineProperty(exports, "TransactionStatus", { enumerable: true, get: function () { return enums_7.TransactionStatus; } });
var CardType;
(function (CardType) {
CardType["UNKNOWN"] = "UNKNOWN";
CardType["AMERICAN_EXPRESS"] = "AMERICAN_EXPRESS";
CardType["DISCOVER"] = "DISCOVER";
CardType["MASTERCARD"] = "MASTERCARD";
CardType["UNKNOWN"] = "UNKNOWN";
CardType["VISA"] = "VISA";

@@ -20,14 +34,2 @@ })(CardType || (exports.CardType = CardType = {}));

})(TerminalPaySessionResultStatus || (exports.TerminalPaySessionResultStatus = TerminalPaySessionResultStatus = {}));
var OpenGovTenant;
(function (OpenGovTenant) {
OpenGovTenant["plc"] = "plc";
})(OpenGovTenant || (exports.OpenGovTenant = OpenGovTenant = {}));
var TransactionStatus;
(function (TransactionStatus) {
TransactionStatus["SUCCEDED"] = "SUCCEDED";
TransactionStatus["PENDING"] = "PENDING";
TransactionStatus["FAILED"] = "FAILED";
TransactionStatus["DISPUTED"] = "DISPUTED";
TransactionStatus["LOST"] = "LOST";
})(TransactionStatus || (exports.TransactionStatus = TransactionStatus = {}));
//# sourceMappingURL=generated.js.map

19

package.json
{
"name": "@opengov/ppf-backend-types",
"version": "1.8.0",
"version": "1.8.1",
"description": "PPF Backend types",

@@ -14,6 +14,9 @@ "homepage": "https://github.com/OpenGov/pluggable-payments#readme",

"build": "tsc --build tsconfig.build.json",
"watch": "tsc --build tsconfig.build.json --watch"
"watch": "tsc --build tsconfig.build.json --watch",
"codegen": "graphql-codegen --require",
"prebuild": "npm run codegen"
},
"dependencies": {
"@opengov/plc-fastify-auth-plugin": "0.0.9"
"@opengov/plc-fastify-auth-plugin": "0.0.9",
"@opengov/ppf-backend-graphql-schema": "^0.6.1"
},

@@ -27,3 +30,11 @@ "repository": {

},
"gitHead": "a5c5895f8bcc309ccc3b5adf77315cbeb20b882c"
"devDependencies": {
"@graphql-codegen/cli": "^5.0.0",
"@graphql-codegen/typescript-operations": "^4.0.1",
"@graphql-codegen/typescript-resolvers": "^4.0.1",
"eslint": "^8.56.0",
"graphql": "^16.8.1",
"prettier": "^3.2.4"
},
"gitHead": "9e1a66fefe7969896b057cecdb52fa8764e4c74d"
}
dist/types/generated.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/generated.js.map

Sorry, the diff of this file is not supported yet

src/types/generated.ts

Sorry, the diff of this file is too big to display

tsconfig.build.tsbuildinfo

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc