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 { PaymentStatus } from "./enums";
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends { [key: string]: unknown }> = {
  [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
  [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
  [SubKey in K]: Maybe<T[SubKey]>;
};
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string;
  String: string;
  Boolean: boolean;
  Int: number;
  Float: number;
  DateTime: Date | string;
  JSON: any;
  /** Opaque token representing a payment account associated with a user. */
  PaymentAccountToken: any;
};

export type ApplicationMetadata = {
  address?: InputMaybe<Scalars["String"]>;
  allowEWalletPayment?: InputMaybe<Scalars["Boolean"]>;
  community?: InputMaybe<Scalars["String"]>;
  departmentID?: InputMaybe<Scalars["ID"]>;
  departmentName?: InputMaybe<Scalars["String"]>;
  itemsMetadata?: InputMaybe<Scalars["String"]>;
  itemsMetadata2?: InputMaybe<Scalars["String"]>;
  itemsMetadata3?: InputMaybe<Scalars["String"]>;
  mode?: InputMaybe<PaymentMode>;
  orgName?: InputMaybe<Scalars["String"]>;
  paymentID?: InputMaybe<Scalars["String"]>;
  paymentMethod?: InputMaybe<Scalars["String"]>;
  recordID?: InputMaybe<Scalars["String"]>;
  recordNo?: InputMaybe<Scalars["String"]>;
  recordStepID?: InputMaybe<Scalars["String"]>;
  recordType?: InputMaybe<Scalars["String"]>;
  recordTypeID?: InputMaybe<Scalars["String"]>;
};

export type ApplicationMetadataResponse = {
  __typename?: "ApplicationMetadataResponse";
  address?: Maybe<Scalars["String"]>;
  community?: Maybe<Scalars["String"]>;
  departmentID?: Maybe<Scalars["ID"]>;
  departmentName?: Maybe<Scalars["String"]>;
  itemsMetadata?: Maybe<Scalars["String"]>;
  paymentID?: Maybe<Scalars["String"]>;
  paymentMethod?: Maybe<Scalars["String"]>;
  recordID?: Maybe<Scalars["String"]>;
  recordNo?: Maybe<Scalars["String"]>;
  recordStepID?: Maybe<Scalars["String"]>;
  recordType?: Maybe<Scalars["String"]>;
  recordTypeID?: Maybe<Scalars["String"]>;
};

export type Card = {
  __typename?: "Card";
  card: CardDetails;
};

export type CardDetails = {
  __typename?: "CardDetails";
  authorizationCode?: Maybe<Scalars["String"]>;
  cardType?: Maybe<CardType>;
  last4?: Maybe<Scalars["String"]>;
};

export enum CardType {
  AMERICAN_EXPRESS = "AMERICAN_EXPRESS",
  DISCOVER = "DISCOVER",
  MASTERCARD = "MASTERCARD",
  UNKNOWN = "UNKNOWN",
  VISA = "VISA",
}

export type Cash = {
  __typename?: "Cash";
  cash: CashDetails;
};

export type CashDetails = {
  __typename?: "CashDetails";
  paidAmount?: Maybe<Scalars["Float"]>;
};

export type Check = {
  __typename?: "Check";
  check: ECheckDetails;
};

export type ConfigPluginFlowRequest = {
  applicationMetadata?: InputMaybe<ApplicationMetadata>;
  community: Scalars["String"];
  processorID: PaymentProcessorId;
  scope: ConfigScope;
  sourceApp?: InputMaybe<OpenGovTenant>;
};

export type ConfigPluginFlowResponse = FlowResponseType & {
  __typename?: "ConfigPluginFlowResponse";
  flowType: PaymentProcessorFlow;
};

export { ConfigScope };

export enum Currency {
  AUD = "AUD",
  USD = "USD",
}

export type ECheck = {
  __typename?: "ECheck";
  e_check: ECheckDetails;
};

export type ECheckDetails = {
  __typename?: "ECheckDetails";
  last4?: Maybe<Scalars["String"]>;
};

export type EnvironmentConfig = {
  __typename?: "EnvironmentConfig";
  key: Scalars["String"];
  value?: Maybe<Scalars["String"]>;
};

export type FeeItem = {
  feeAccountNumber?: InputMaybe<Scalars["String"]>;
  feeAmount?: InputMaybe<Scalars["Float"]>;
  feeTitle?: InputMaybe<Scalars["String"]>;
  recordID?: InputMaybe<Scalars["Int"]>;
  record_StepID?: InputMaybe<Scalars["Int"]>;
  step_FeeID?: InputMaybe<Scalars["ID"]>;
};

export type FeeItemResponse = {
  __typename?: "FeeItemResponse";
  feeAccountNumber?: Maybe<Scalars["String"]>;
  feeAmount?: Maybe<Scalars["Float"]>;
  feeTitle?: Maybe<Scalars["String"]>;
  recordID?: Maybe<Scalars["Int"]>;
  record_StepID?: Maybe<Scalars["Int"]>;
  step_FeeID?: Maybe<Scalars["ID"]>;
};

/** Represents a successful grant with a token */
export type FlowGrant = {
  __typename?: "FlowGrant";
  /** Flow token payload */
  flowToken: Scalars["String"];
  flowType: PaymentProcessorFlow;
};

export type FlowGrantResponse =
  | FlowGrant
  | FlowRequestInvalid
  | FlowUnsupported;

/** Error result when flow request input is invalid. */
export type FlowRequestInvalid = {
  __typename?: "FlowRequestInvalid";
  message?: Maybe<Scalars["String"]>;
};

/**
 * Common interface for all flow responses.
 * The flowType will always match the value of the flowType field in the validation request.
 */
export type FlowResponseType = {
  flowType: PaymentProcessorFlow;
};

/** 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>>;
};

/** 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
  | OnlineVoidFlowResponse
  | TerminalPaymentFlowResponse
  | UpdatePaymentFlowResponse;

export type FuturePaymentFlowRequest = {
  applicationMetadata?: InputMaybe<ApplicationMetadata>;
  entityID: Scalars["String"];
  idempotencyKey?: InputMaybe<Scalars["String"]>;
  invoiceEmail?: InputMaybe<Scalars["String"]>;
  paymentMethod: PaymentMethod;
  processorID: PaymentProcessorId;
  sourceApp: Scalars["String"];
  userID: Scalars["ID"];
};

export type FuturePaymentFlowResponse = FlowResponseType & {
  __typename?: "FuturePaymentFlowResponse";
  flowType: PaymentProcessorFlow;
  idempotencyKey?: Maybe<Scalars["String"]>;
  paymentAccountToken?: Maybe<Scalars["PaymentAccountToken"]>;
  paymentMethodDetails?: Maybe<PaymentMethodDetails>;
  status: Scalars["String"];
};

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 based on an idempotecy key. */
  getMetadata?: Maybe<PaymentMetadataResponse>;
  /** 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. */
  onlinePayment: FlowGrantResponse;
  /** Requests a grant to perform the ONLINE_REFUND flow. */
  onlineRefund: FlowGrantResponse;
  /** Requests a grant to perform the ONLINE_VOID flow. */
  onlineVoid: FlowGrantResponse;
  /** Requests a grant to perform the TERMINAL_PAYMENT flow. */
  terminalPayment: FlowGrantResponse;
  /** Requests a grant to perform the update of a payment */
  updatePayment: FlowGrantResponse;
  /** Requests validation of a signed JWT */
  validateFlowResult: FlowValidationResponse;
};

export type MutationconfigPluginArgs = {
  request?: InputMaybe<ConfigPluginFlowRequest>;
};

export type MutationfuturePaymentArgs = {
  request?: InputMaybe<FuturePaymentFlowRequest>;
};

export type MutationgetMetadataArgs = {
  idempotencyKey?: InputMaybe<Scalars["String"]>;
};

export type MutationofflinePaymentArgs = {
  request?: InputMaybe<OfflinePaymentFlowRequest>;
};

export type MutationofflineRefundArgs = {
  request?: InputMaybe<OfflineRefundFlowRequest>;
};

export type MutationoneTimePaymentArgs = {
  request?: InputMaybe<OneTimePaymentFlowRequest>;
};

export type MutationonlinePaymentArgs = {
  request?: InputMaybe<OnlinePaymentFlowRequest>;
};

export type MutationonlineRefundArgs = {
  request: OnlineRefundFlowRequest;
};

export type MutationonlineVoidArgs = {
  request: OnlineVoidFlowRequest;
};

export type MutationterminalPaymentArgs = {
  request?: InputMaybe<TerminalPaymentFlowRequest>;
};

export type MutationupdatePaymentArgs = {
  request?: InputMaybe<UpdatePaymentFlowRequest>;
};

export type MutationvalidateFlowResultArgs = {
  flowResult: FlowResult;
  flowType?: InputMaybe<PaymentProcessorFlow>;
};

export type OfflinePaymentFlowRequest = {
  amount: Scalars["Float"];
  applicationMetadata?: InputMaybe<ApplicationMetadata>;
  attributes?: InputMaybe<Scalars["JSON"]>;
  currency: Scalars["String"];
  description: Scalars["String"];
  entityID: Scalars["String"];
  idempotencyKey?: InputMaybe<Scalars["String"]>;
  items?: InputMaybe<Array<InputMaybe<FeeItem>>>;
  paymentAccountToken: Scalars["PaymentAccountToken"];
  paymentID: Scalars["String"];
  paymentMethod: PaymentMethod;
  processingFee: Scalars["Float"];
  processorID: PaymentProcessorId;
  sourceApp: Scalars["String"];
  userID: Scalars["ID"];
};

export type OfflinePaymentFlowResponse = FlowResponseType & {
  __typename?: "OfflinePaymentFlowResponse";
  amount: Scalars["Float"];
  attributes?: Maybe<Scalars["JSON"]>;
  currency?: Maybe<Scalars["String"]>;
  description?: Maybe<Scalars["String"]>;
  entityID: Scalars["String"];
  flowType: PaymentProcessorFlow;
  idempotencyKey?: Maybe<Scalars["String"]>;
  items?: Maybe<Array<Maybe<FeeItemResponse>>>;
  /**
   * Token representing the payment account used for this payment.
   * Payment processors may refresh this token periodically.
   */
  paymentAccountToken?: Maybe<Scalars["PaymentAccountToken"]>;
  paymentID: Scalars["ID"];
  paymentMethodDetails: PaymentMethodDetails;
  processingFee?: Maybe<Scalars["Float"]>;
  sourceApp: Scalars["String"];
  status: Scalars["String"];
  transactionID?: Maybe<Scalars["String"]>;
  userID: Scalars["ID"];
};

export type OfflineRefundFlowRequest = {
  amount: Scalars["Float"];
  applicationMetadata?: InputMaybe<ApplicationMetadata>;
  attributes?: InputMaybe<Scalars["JSON"]>;
  currency: Currency;
  entityID: Scalars["String"];
  idempotencyKey?: InputMaybe<Scalars["String"]>;
  items?: InputMaybe<Array<InputMaybe<FeeItem>>>;
  originalPaymentID: Scalars["ID"];
  processingFee: Scalars["Float"];
  processorID: PaymentProcessorId;
  sourceApp: Scalars["String"];
  userID: Scalars["ID"];
};

export type OfflineRefundFlowResponse = FlowResponseType & {
  __typename?: "OfflineRefundFlowResponse";
  amount: Scalars["Float"];
  attributes?: Maybe<Scalars["JSON"]>;
  currency: Currency;
  entityID: Scalars["String"];
  flowType: PaymentProcessorFlow;
  idempotencyKey?: Maybe<Scalars["String"]>;
  items?: Maybe<Array<Maybe<FeeItemResponse>>>;
  originalPaymentID: Scalars["ID"];
  processingFee: Scalars["Float"];
  sourceApp: Scalars["String"];
  userID: Scalars["ID"];
};

export type OneTimePaymentFlowRequest = {
  amount: Scalars["Float"];
  applicationMetadata?: InputMaybe<ApplicationMetadata>;
  currency: Scalars["String"];
  description: Scalars["String"];
  entityID: Scalars["String"];
  paymentID: Scalars["String"];
  paymentMethod: PaymentMethod;
  processingFee: Scalars["Float"];
  processorID: PaymentProcessorId;
  sourceApp: Scalars["String"];
  userID: Scalars["ID"];
};

/** Response from performing the ONETIME_PAYMENT flow. */
export type OneTimePaymentFlowResponse = FlowResponseType & {
  __typename?: "OneTimePaymentFlowResponse";
  amount?: Maybe<Scalars["Float"]>;
  currency?: Maybe<Scalars["String"]>;
  description?: Maybe<Scalars["String"]>;
  flowType: PaymentProcessorFlow;
  paymentAccountToken?: Maybe<Scalars["PaymentAccountToken"]>;
  paymentID: Scalars["ID"];
  paymentMethodDetails: PaymentMethodDetails;
  processingFee?: Maybe<Scalars["Float"]>;
  status: Scalars["String"];
  transactionID?: Maybe<Scalars["String"]>;
};

export type OnlinePaymentFlowRequest = {
  amount: Scalars["Float"];
  applicationMetadata?: InputMaybe<ApplicationMetadata>;
  currency: Scalars["String"];
  description: Scalars["String"];
  entityID: Scalars["String"];
  idempotencyKey?: InputMaybe<Scalars["String"]>;
  invoiceEmail?: InputMaybe<Scalars["String"]>;
  items?: InputMaybe<Array<InputMaybe<FeeItem>>>;
  paymentID: Scalars["String"];
  paymentMethod: PaymentMethod;
  processingFee: Scalars["Float"];
  processorID: PaymentProcessorId;
  sourceApp: Scalars["String"];
  tenantID?: InputMaybe<Scalars["String"]>;
  userID: Scalars["ID"];
};

export type OnlinePaymentFlowResponse = FlowResponseType & {
  __typename?: "OnlinePaymentFlowResponse";
  amount?: Maybe<Scalars["Float"]>;
  currency?: Maybe<Scalars["String"]>;
  description?: Maybe<Scalars["String"]>;
  destinationPaymentID?: Maybe<Scalars["String"]>;
  flowType: PaymentProcessorFlow;
  idempotencyKey?: Maybe<Scalars["String"]>;
  payer?: Maybe<Payer>;
  paymentChannel?: Maybe<PaymentChannel>;
  paymentID: Scalars["ID"];
  paymentMethodDetails: PaymentMethodDetails;
  /** Deprecated: Use payoutDetails instead */
  payoutDate?: Maybe<Scalars["DateTime"]>;
  payoutDetails?: Maybe<PayoutDetails>;
  processingFee?: Maybe<Scalars["Float"]>;
  status: Scalars["String"];
  transactionID?: Maybe<Scalars["String"]>;
};

export type OnlineRefundFlowRequest = {
  amount: Scalars["Float"];
  applicationMetadata?: InputMaybe<ApplicationMetadata>;
  currency?: InputMaybe<Currency>;
  entityID: Scalars["ID"];
  idempotencyKey?: InputMaybe<Scalars["String"]>;
  items?: InputMaybe<Array<InputMaybe<FeeItem>>>;
  originalPaymentID: Scalars["ID"];
  paymentID: Scalars["ID"];
  processingFee: Scalars["Float"];
  processorID: PaymentProcessorId;
  reason?: InputMaybe<Scalars["String"]>;
  sourceApp: Scalars["String"];
  transactionID: Scalars["String"];
  userID: Scalars["ID"];
};

export type OnlineRefundFlowResponse = FlowResponseType & {
  __typename?: "OnlineRefundFlowResponse";
  amount: Scalars["Float"];
  flowType: PaymentProcessorFlow;
  idempotencyKey?: Maybe<Scalars["String"]>;
  paymentID: Scalars["ID"];
  status: Scalars["String"];
  transactionID?: Maybe<Scalars["String"]>;
};

export type OnlineVoidFlowRequest = {
  applicationMetadata?: InputMaybe<ApplicationMetadata>;
  entityID: Scalars["ID"];
  idempotencyKey?: InputMaybe<Scalars["String"]>;
  processorID: PaymentProcessorId;
  sourceApp: Scalars["String"];
  transactionID: Scalars["String"];
  userID: Scalars["ID"];
};

export type OnlineVoidFlowResponse = FlowResponseType & {
  __typename?: "OnlineVoidFlowResponse";
  flowType: PaymentProcessorFlow;
  status: Scalars["String"];
  transactionID?: Maybe<Scalars["String"]>;
};

export { OpenGovTenant };

export type Payer = {
  __typename?: "Payer";
  name?: Maybe<Scalars["String"]>;
};

export enum PaymentChannel {
  CASHIER = "CASHIER",
  KIOSK = "KIOSK",
  TERMINAL = "TERMINAL",
  WEB = "WEB",
}

export type PaymentMetadataResponse = {
  __typename?: "PaymentMetadataResponse";
  amount?: Maybe<Scalars["Float"]>;
  applicationMetadata?: Maybe<ApplicationMetadataResponse>;
  currency?: Maybe<Scalars["String"]>;
  description?: Maybe<Scalars["String"]>;
  entityID?: Maybe<Scalars["String"]>;
  idempotencyKey?: Maybe<Scalars["String"]>;
  items?: Maybe<Array<Maybe<FeeItemResponse>>>;
  originalPaymentID?: Maybe<Scalars["String"]>;
  paymentID?: Maybe<Scalars["String"]>;
  paymentMethod?: Maybe<PaymentMethod>;
  processingFee?: Maybe<Scalars["Float"]>;
  processorID?: Maybe<PaymentProcessorId>;
  sourceApp?: Maybe<Scalars["String"]>;
  tenantID?: Maybe<Scalars["String"]>;
  userID?: Maybe<Scalars["ID"]>;
};

export { PaymentMethod };

export type PaymentMethodDetails = Card | Cash | Check | ECheck;

export enum PaymentMode {
  LIVE = "LIVE",
  TEST = "TEST",
}

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 { PaymentProcessorFlow };

export { PaymentProcessorId };

export { PaymentStatus };

export type PayoutDetails = {
  __typename?: "PayoutDetails";
  date?: Maybe<Scalars["DateTime"]>;
  id?: Maybe<Scalars["String"]>;
};

export type ProcessingFeeMetadata = {
  __typename?: "ProcessingFeeMetadata";
  allowCommunityPays?: Maybe<Scalars["Boolean"]>;
  calculatesFeesAtCheckout?: Maybe<Scalars["Boolean"]>;
  fee?: Maybe<Scalars["String"]>;
  scheduled?: Maybe<Scalars["String"]>;
};

export type ProcessingFees = {
  __typename?: "ProcessingFees";
  CREDIT_CARD?: Maybe<ProcessingFeeMetadata>;
  E_CHECK?: Maybe<ProcessingFeeMetadata>;
};

export type Query = {
  __typename?: "Query";
  SEPSMetadata: SEPSMetadata;
  paymentProcessor?: Maybe<PaymentProcessor>;
};

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 type SEPSMetadata = {
  __typename?: "SEPSMetadata";
  environment: Scalars["String"];
  supportedPaymentProcessors: Array<PaymentProcessor>;
};

export type Signature = {
  header?: InputMaybe<Header>;
  protected: Scalars["String"];
  signature: Scalars["String"];
};

export enum TerminalPaySessionResultStatus {
  APPROVED = "APPROVED",
  DECLINED = "DECLINED",
  ERROR = "ERROR",
  IN_PROGRESS = "IN_PROGRESS",
  UNKNOWN = "UNKNOWN",
}

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"];
  idempotencyKey?: InputMaybe<Scalars["String"]>;
  invoiceEmail?: InputMaybe<Scalars["String"]>;
  items?: InputMaybe<Array<InputMaybe<FeeItem>>>;
  /** 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?: InputMaybe<Scalars["String"]>;
  /** Options if need to mention for terminal device */
  terminalOptions?: InputMaybe<Scalars["String"]>;
  /** Type of terminal device */
  terminalType?: InputMaybe<Scalars["String"]>;
  /** User initiating or on behalf of whom the payment is being made */
  userID?: InputMaybe<Scalars["ID"]>;
  /** Deprecated: User initiating or on behalf of whom the payment is being made */
  userId: Scalars["ID"];
};

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;
};

export type UpdatePaymentFlowRequest = {
  amount?: InputMaybe<Scalars["Float"]>;
  currency?: InputMaybe<Scalars["String"]>;
  entityID: Scalars["String"];
  last4?: InputMaybe<Scalars["String"]>;
  paymentReference: Scalars["String"];
  processingFee?: InputMaybe<Scalars["Float"]>;
  processorID: PaymentProcessorId;
  status: PaymentStatus;
  tenantID: OpenGovTenant;
  transactionID?: InputMaybe<Scalars["String"]>;
};

export type UpdatePaymentFlowResponse = FlowResponseType & {
  __typename?: "UpdatePaymentFlowResponse";
  amount?: Maybe<Scalars["Float"]>;
  currency?: Maybe<Scalars["String"]>;
  destinationPaymentID?: Maybe<Scalars["String"]>;
  entityID: Scalars["String"];
  flowType: PaymentProcessorFlow;
  last4?: Maybe<Scalars["String"]>;
  paymentReference: Scalars["String"];
  payoutDetails?: Maybe<PayoutDetails>;
  processingFee?: Maybe<Scalars["Float"]>;
  processorID: PaymentProcessorId;
  status?: Maybe<PaymentStatus>;
  tenantID: OpenGovTenant;
  transactionID?: Maybe<Scalars["String"]>;
};