import {z} from 'zod'

export type ChargeKey = string;

export type GetApiChargesChargeKeyArgs = {chargeKey: ChargeKey};

export type GetApiChargesChargeKeyOptions = {baseUrl?: string | undefined, ApiKey?: {username: string, password: string} | undefined, fetch?: typeof fetch | undefined};

export const chargeKey = z.string().min(5).max(120);

export const refundedChargeKey = z.string().min(5).max(120);

export const componentsSchemasAcceptorKey = z.string().min(5).max(120);

export const schemasVersion = z.number().int();

export const componentsSchemasAcceptorRef = z.object({key: componentsSchemasAcceptorKey, version: schemasVersion});

export const schemasProcessorTokenKey = z.string().min(5).max(120);

export const outputCard = z.object({maskedNumber: z.string(), processorTokenKey: schemasProcessorTokenKey.optional()});

export const schemasEci = z.string().min(2).max(2);

export const storedTokenDetailsNetwork = z.object({type: z.literal("network"), eci: schemasEci.optional()});

export const storedChargeTokenDetailsDigitalWallet = z.object({type: z.enum(["apple-pay", "google-pay", "paze"]), eci: z.string().min(2).max(2).optional()});

export const storedChargeTokenDetails = z.union([storedTokenDetailsNetwork, storedChargeTokenDetailsDigitalWallet]);

export const componentsSchemasAmountValue = z.number().int().gte(0).lte(999999999999);

export const openapiComponentsSchemasCurrencyCode = z.enum(["AED", "AFN", "ALL", "AMD", "ANG", "AOA", "ARS", "AUD", "AWG", "AZN", "BAM", "BBD", "BDT", "BGN", "BHD", "BIF", "BMD", "BND", "BOB", "BRL", "BSD", "BTN", "BWP", "BYN", "BZD", "CAD", "CDF", "CHF", "CLP", "CNY", "COP", "CRC", "CUC", "CUP", "CVE", "CZK", "DJF", "DKK", "DOP", "DZD", "EGP", "ERN", "ETB", "EUR", "FJD", "FKP", "GBP", "GEL", "GHS", "GIP", "GMD", "GNF", "GTQ", "GYD", "HKD", "HNL", "HTG", "HUF", "IDR", "ILS", "INR", "IQD", "IRR", "ISK", "JMD", "JOD", "JPY", "KES", "KGS", "KHR", "KMF", "KPW", "KRW", "KWD", "KYD", "KZT", "LAK", "LBP", "LKR", "LRD", "LSL", "LYD", "MAD", "MDL", "MGA", "MKD", "MMK", "MNT", "MOP", "MRU", "MUR", "MVR", "MWK", "MXN", "MYR", "MZN", "NAD", "NGN", "NIO", "NOK", "NPR", "NZD", "OMR", "PAB", "PEN", "PGK", "PHP", "PKR", "PLN", "PYG", "QAR", "RON", "RSD", "RUB", "RWF", "SAR", "SBD", "SCR", "SDG", "SEK", "SGD", "SHP", "SLL", "SOS", "SRD", "SSP", "STN", "SVC", "SYP", "SZL", "THB", "TJS", "TMT", "TND", "TOP", "TRY", "TTD", "TWD", "TZS", "UAH", "UGX", "USD", "UYU", "UZS", "VES", "VND", "VUV", "WST", "XAF", "XCD", "XCG", "XOF", "XPF", "YER", "ZAR", "ZMW", "ZWL"]);

export const componentsSchemasAmount = z.object({value: componentsSchemasAmountValue, currency: openapiComponentsSchemasCurrencyCode});

export const commonCurrencyCode = z.enum(["AED", "AFN", "ALL", "AMD", "AOA", "ARS", "AUD", "AWG", "AZN", "BAM", "BBD", "BDT", "BHD", "BIF", "BMD", "BND", "BOB", "BRL", "BSD", "BTN", "BWP", "BYN", "BZD", "CAD", "CDF", "CHF", "CLP", "CNY", "COP", "CRC", "CUC", "CUP", "CVE", "CZK", "DJF", "DKK", "DOP", "DZD", "EGP", "ERN", "ETB", "EUR", "FJD", "FKP", "GBP", "GEL", "GHS", "GIP", "GMD", "GNF", "GTQ", "GYD", "HKD", "HNL", "HTG", "HUF", "IDR", "ILS", "INR", "IQD", "IRR", "ISK", "JMD", "JOD", "JPY", "KES", "KGS", "KHR", "KMF", "KPW", "KRW", "KWD", "KYD", "KZT", "LAK", "LBP", "LKR", "LRD", "LSL", "LYD", "MAD", "MDL", "MGA", "MKD", "MMK", "MNT", "MOP", "MRU", "MUR", "MVR", "MWK", "MXN", "MYR", "MZN", "NAD", "NGN", "NIO", "NOK", "NPR", "NZD", "OMR", "PAB", "PEN", "PGK", "PHP", "PKR", "PLN", "PYG", "QAR", "RON", "RSD", "RUB", "RWF", "SAR", "SBD", "SCR", "SDG", "SEK", "SGD", "SHP", "SOS", "SRD", "SSP", "STN", "SYP", "SZL", "THB", "TJS", "TMT", "TND", "TOP", "TRY", "TTD", "TWD", "TZS", "UAH", "UGX", "USD", "UYU", "UZS", "VES", "VND", "VUV", "WST", "XAF", "XCD", "XCG", "XOF", "XPF", "YER", "ZAR", "ZMW", "ZWL"]);

export const cardholderBillingAmount = z.object({value: componentsSchemasAmountValue, currency: commonCurrencyCode, conversionRate: z.object({cardholderBillingConversionRate: z.number(), decimalIndicator: z.number()})});

export const responseCardEntry = z.enum(["e-commerce", "manual", "card-on-file", "terminal", "token", "token-on-file"]);

export const sequence = z.literal("initial");

export const getResponseChargeType = z.object({intent: z.enum(["purchase", "reservation", "account-status", "refund"]), cardEntry: responseCardEntry, order: z.enum(["checkout", "unspecified", "mail", "phone", "one-click", "recurring", "ucof", "installment", "standing-order", "counter"]), sequence: z.union([sequence, z.literal("subsequent")]).optional()});

export const clearingMode = z.enum(["auto", "manual"]);

export const authenticationStatus = z.enum(["none", "authenticated", "non-authenticated"]);

export const chargeAuthorizationStatus = z.enum(["none", "approved", "declined", "reversed", "approved-partial"]);

export const chargeClearingStatus = z.enum(["none", "manual", "pending", "completed", "cancelled", "abandoned"]);

export const chargeStatus = z.object({authentication: authenticationStatus, authorization: chargeAuthorizationStatus, clearing: chargeClearingStatus});

export const method = z.enum(["3ds1", "3ds2", "device"]);

export const threeDsComplianceReason = z.enum(["mandated", "none", "ucof", "recurring", "installment", "incremental", "delayed-charges", "no-show", "reauthorization", "resubmission", "whitelist", "auto", "mit", "tra", "low-value", "delegation", "scp"]);

export const threeDsAuthenticationResultResponse = z.object({version: z.literal("2.2.0").optional(), directoryServerTransId: z.string().optional()});

export const threeDsAuthentication = z.object({method: method, compliance: z.enum(["mandated", "mit", "exemption"]), complianceReason: threeDsComplianceReason, result: threeDsAuthenticationResultResponse});

export const methodBEP = z.literal("bep");

export const complianceBEP = z.literal("mandated");

export const complianceReasonBEP = z.literal("mandated");

export const bEPAuthenticationResult = z.object({trm: z.enum(["50", "51"])});

export const scaBEP = z.object({method: methodBEP, compliance: complianceBEP, complianceReason: complianceReasonBEP, result: bEPAuthenticationResult});

export const authenticationOutOfScope = z.object({method: z.literal("none"), compliance: z.literal("out-of-scope"), complianceReason: z.enum(["none", "moto", "one-leg", "anonymous-prepaid", "recurring"])});

export const authenticationExempt = z.object({method: z.literal("none"), compliance: z.literal("exemption"), complianceReason: z.enum(["whitelist", "auto", "mit", "tra", "recurring", "low-value", "delegation", "scp", "wip"])});

export const scaMit = z.object({method: z.literal("none"), compliance: z.literal("mit"), complianceReason: z.enum(["installment", "ucof"])});

export const sca = z.union([threeDsAuthentication, scaBEP, authenticationOutOfScope, authenticationExempt, scaMit]);

export const cvcResult = z.enum(["none", "match", "no-match", "not-processed"]);

export const avsResult = z.enum(["none", "match", "partial-match", "no-match", "not-processed"]);

export const chargeAuthentication = z.object({sca: sca, cvc: cvcResult, avs: avsResult});

export const localTransactionDateTime = z.string();

export const transactionType = z.enum(["cryptocurrency", "high-risk-securities", "central-bank-digital-currency", "stablecoin", "blockchain-native-coin", "non-fungible-token"]);

export const fraudLiability = z.enum(["acquirer", "issuer"]);

export const isoFieldResponseCode = z.string();

export const isoFieldResponseCodeDescription = z.string();

export const isoFieldAuthorizationCode = z.string();

export const isoFieldSystemTraceAuditNumber = z.string();

export const isoFieldRetrievalReferenceNumber = z.string();

export const isoFieldEciAmex = z.string();

export const amexSpecificFields = z.object({acquirerReferenceData: z.string(), cvcResult: z.string().optional(), avsResult: z.string().optional()});

export const authorizationIsoFieldsAmericanExpress = z.object({responseCode: isoFieldResponseCode, responseCodeDescription: isoFieldResponseCodeDescription, authorizationCode: isoFieldAuthorizationCode.optional(), networkCode: z.literal("not-applicable"), systemTraceAuditNumber: isoFieldSystemTraceAuditNumber, retrievalReferenceNumber: isoFieldRetrievalReferenceNumber, eci: isoFieldEciAmex, networkSpecificFields: amexSpecificFields});

export const bancontactSpecificFields = z.object({iban: z.string().optional()});

export const authorizationIsoFieldsBancontact = z.object({responseCode: isoFieldResponseCode, responseCodeDescription: isoFieldResponseCodeDescription, authorizationCode: isoFieldAuthorizationCode.optional(), networkCode: z.literal("none"), systemTraceAuditNumber: isoFieldSystemTraceAuditNumber, retrievalReferenceNumber: isoFieldRetrievalReferenceNumber, eci: z.literal("none"), networkSpecificFields: bancontactSpecificFields});

export const isoFieldEciDiners = z.string();

export const dinersSpecificFields = z.object({network: z.literal("diners"), cvvIndicator: z.string().optional(), networkReferenceId: z.string().optional()});

export const authorizationIsoFieldsDiners = z.object({responseCode: isoFieldResponseCode, responseCodeDescription: isoFieldResponseCodeDescription, authorizationCode: isoFieldAuthorizationCode.optional(), networkCode: z.string(), systemTraceAuditNumber: isoFieldSystemTraceAuditNumber, retrievalReferenceNumber: isoFieldRetrievalReferenceNumber, eci: isoFieldEciDiners, networkSpecificFields: dinersSpecificFields});

export const isoFieldNetworkCode = z.string();

export const isoFieldEciDiscover = z.string();

export const discoverSpecificFields = z.object({network: z.literal("discover"), avsResponseCode: z.string().optional(), cidResultCode: z.string().optional(), networkReferenceId: z.string().optional()});

export const authorizationIsoFieldsDiscover = z.object({responseCode: isoFieldResponseCode, responseCodeDescription: isoFieldResponseCodeDescription, authorizationCode: isoFieldAuthorizationCode.optional(), networkCode: isoFieldNetworkCode, systemTraceAuditNumber: isoFieldSystemTraceAuditNumber, retrievalReferenceNumber: isoFieldRetrievalReferenceNumber, eci: isoFieldEciDiscover, networkSpecificFields: discoverSpecificFields});

export const isoFieldEciMastercard = z.string();

export const mastercardSpecificFields = z.object({banknetReference: z.string(), traceId: z.string(), merchantAdviceCode: z.string().optional(), cvcResult: z.string().optional(), nameValidationResult: z.string().optional(), avsResponse: z.string().optional(), paymentAccountReference: z.string().optional(), transactionLinkId: z.string().optional(), digitalCommerceProgramType: z.string().optional(), onBehalfServices: z.array(z.object({onBehalfService: z.string(), onBehalfResult1: z.string(), onBehalfResult2: z.string()})).optional()});

export const authorizationIsoFieldsMastercard = z.object({responseCode: isoFieldResponseCode, responseCodeDescription: isoFieldResponseCodeDescription, authorizationCode: isoFieldAuthorizationCode.optional(), networkCode: isoFieldNetworkCode, systemTraceAuditNumber: isoFieldSystemTraceAuditNumber, retrievalReferenceNumber: isoFieldRetrievalReferenceNumber, eci: isoFieldEciMastercard, networkSpecificFields: mastercardSpecificFields});

export const isoFieldEciUnionPay = z.string();

export const unionPaySpecificFields = z.object({network: z.literal("unionpay"), pvnCheckResult: z.string().optional()});

export const authorizationIsoFieldsUnionPay = z.object({responseCode: isoFieldResponseCode, responseCodeDescription: isoFieldResponseCodeDescription, authorizationCode: isoFieldAuthorizationCode.optional(), networkCode: z.literal("not-applicable"), systemTraceAuditNumber: isoFieldSystemTraceAuditNumber, retrievalReferenceNumber: isoFieldRetrievalReferenceNumber, eci: isoFieldEciUnionPay, networkSpecificFields: unionPaySpecificFields});

export const isoFieldEciVisa = z.string();

export const visaSpecificFields = z.object({transactionIdentifier: z.string(), cvv2ResultCode: z.string().optional(), avsResultCode: z.string().optional(), paymentAccountReference: z.string().optional(), aniResults: z.object({status: z.string(), fullNameMatch: z.string().optional(), firstNameMatch: z.string().optional(), middleNameMatch: z.string().optional(), lastNameMatch: z.string().optional()}).optional(), vaaiScore: z.string().optional(), tokenRequestorId: z.string().optional()});

export const authorizationIsoFieldsVisa = z.object({responseCode: isoFieldResponseCode, responseCodeDescription: isoFieldResponseCodeDescription, authorizationCode: isoFieldAuthorizationCode.optional(), networkCode: isoFieldNetworkCode, systemTraceAuditNumber: isoFieldSystemTraceAuditNumber, retrievalReferenceNumber: isoFieldRetrievalReferenceNumber, eci: isoFieldEciVisa, networkSpecificFields: visaSpecificFields});

export const authorizationIsoFields = z.union([authorizationIsoFieldsAmericanExpress, authorizationIsoFieldsBancontact, authorizationIsoFieldsDiners, authorizationIsoFieldsDiscover, authorizationIsoFieldsMastercard, authorizationIsoFieldsUnionPay, authorizationIsoFieldsVisa]);

export const schemasCountryCodeAlpha3 = z.string().min(3).max(3);

export const schemasCountryCodeAlpha2 = z.string().min(2).max(2);

export const schemasCountryCodeNumeric = z.string().min(3).max(3);

export const schemasCountryCode = z.object({alpha3: schemasCountryCodeAlpha3, alpha2: schemasCountryCodeAlpha2, numeric: schemasCountryCodeNumeric});

export const openapiComponentsSchemasStateOrProvince = z.string().min(1).max(120);

export const openapiComponentsSchemasCity = z.string().min(1).max(120);

export const openapiComponentsSchemasLine1 = z.string().min(1).max(120);

export const openapiComponentsSchemasLine2 = z.string().min(1).max(120);

export const openapiComponentsSchemasPostalCode = z.string().min(1).max(10);

export const billingAddress = z.object({countryCode: schemasCountryCode.optional(), stateOrProvince: openapiComponentsSchemasStateOrProvince.optional(), city: openapiComponentsSchemasCity.optional(), line1: openapiComponentsSchemasLine1.optional(), line2: openapiComponentsSchemasLine2.optional(), postalCode: openapiComponentsSchemasPostalCode});

export const componentsSchemasAddress = z.object({countryCode: schemasCountryCode, stateOrProvince: openapiComponentsSchemasStateOrProvince.optional(), city: openapiComponentsSchemasCity, line1: openapiComponentsSchemasLine1, line2: openapiComponentsSchemasLine2.optional(), postalCode: openapiComponentsSchemasPostalCode});

export const clearAfter = z.string();

export const schemasDynamicDescriptor = z.object({merchantName: z.string().min(1).max(22).optional(), merchantCity: z.string().min(1).max(13).optional()});

export const foreignRetailerDisabled = z.object({indicator: z.literal(false)});

export const foreignRetailerEnabled = z.object({indicator: z.literal(true), amount: z.number().int().gte(1).lte(999999999999).optional()});

export const schemasForeignRetailer = z.union([foreignRetailerDisabled, foreignRetailerEnabled]);

export const subMerchantResponse = z.object({id: z.string().min(1).max(15).optional(), address: componentsSchemasAddress.optional()});

export const riskProvider = z.literal("fraudio");

export const fraudioResult = z.object({score: z.number(), recommendation: z.enum(["green", "amber", "red"]), requestId: z.string(), transactionId: z.string()});

export const riskCheckResult = z.object({provider: riskProvider, fraudioResult: fraudioResult.optional(), actionTaken: z.enum(["proceeded", "aborted"]), result: z.enum(["success", "error"])});

export const openapiComponentsSchemasCreated = z.string();

export const componentsSchemasLastModified = z.string();

export const genericCharge = z.object({key: chargeKey, refundedChargeKey: refundedChargeKey.optional(), merchantAcceptorRef: componentsSchemasAcceptorRef, card: outputCard, tokenDetails: storedChargeTokenDetails.optional(), amount: componentsSchemasAmount, cardholderBillingAmount: cardholderBillingAmount.optional(), type: getResponseChargeType, clearingMode: clearingMode.optional(), status: chargeStatus, authentication: chargeAuthentication, localTransactionDateTime: localTransactionDateTime, transactionType: transactionType.optional(), transactionReference: z.string().min(1).max(120).optional(), fraudLiability: fraudLiability, authorizationIsoFields: authorizationIsoFields, billingAddress: billingAddress.optional(), shippingAddress: componentsSchemasAddress.optional(), clearAfter: clearAfter.optional(), dynamicDescriptor: schemasDynamicDescriptor.optional(), foreignRetailer: schemasForeignRetailer.optional(), subMerchant: subMerchantResponse.optional(), riskCheckResult: riskCheckResult.optional(), created: openapiComponentsSchemasCreated, lastModified: componentsSchemasLastModified.optional(), version: schemasVersion});

export const intentAtm = z.literal("withdrawal");

export const atmTerminalEntryMode = z.enum(["chip", "contactless", "contactless-magstripe", "magstripe", "magstripe-fallback"]);

export const clearingStatus = z.enum(["none", "manual", "pending", "completed", "cancelled", "abandoned"]);

export const atmTerminalCapability = z.enum(["contactChip", "contactlessChip", "contactMagStripe", "contactlessMagStripe"]);

export const transactionReference = z.string().min(1).max(120);

export const atmCharge = z.object({key: chargeKey, type: z.object({intent: intentAtm, terminalEntryMode: atmTerminalEntryMode}), accountSource: z.enum(["unspecified", "savings", "checking", "credit"]), amount: z.object({value: z.number().int().gte(1).lte(999999999999), currency: commonCurrencyCode}), authorizationIsoFields: z.object({responseCode: isoFieldResponseCode, responseCodeDescription: isoFieldResponseCodeDescription, authorizationCode: isoFieldAuthorizationCode.optional(), networkCode: isoFieldNetworkCode, systemTraceAuditNumber: isoFieldSystemTraceAuditNumber, retrievalReferenceNumber: isoFieldRetrievalReferenceNumber, networkSpecificFields: z.union([mastercardSpecificFields, visaSpecificFields])}), card: z.object({maskedNumber: z.string()}), clearingMode: clearingMode, localTransactionDateTime: localTransactionDateTime, merchantAcceptorRef: componentsSchemasAcceptorRef, status: z.object({authorization: z.enum(["approved", "declined", "reversed"]), clearing: clearingStatus}), terminal: z.object({id: z.string().min(1).max(8), capabilities: z.array(atmTerminalCapability)}), clearAfter: clearAfter.optional(), dcc: z.union([z.object({enabled: z.literal(false)}), z.object({enabled: z.literal(true), preConversionAmount: z.object({value: z.number().int().gte(1).lte(999999999999), currency: commonCurrencyCode})})]).optional(), transactionReference: transactionReference.optional(), created: openapiComponentsSchemasCreated, lastModified: componentsSchemasLastModified.optional(), version: schemasVersion});

export const bepChargeType = z.object({intent: z.literal("purchase"), cardEntry: z.literal("e-commerce"), order: z.literal("checkout"), sequence: z.literal("initial").optional()});

export const statusBep = z.object({authentication: z.literal("authenticated"), authorization: z.enum(["approved", "declined"]), clearing: clearingStatus});

export const cvcResultBEP = z.literal("none");

export const avsResultBEP = z.literal("none");

export const chargeAuthenticationBEP = z.object({sca: scaBEP, cvc: cvcResultBEP, avs: avsResultBEP});

export const bepCharge = z.object({key: chargeKey, merchantAcceptorRef: componentsSchemasAcceptorRef, card: outputCard, amount: componentsSchemasAmount, type: bepChargeType, status: statusBep, authentication: chargeAuthenticationBEP, localTransactionDateTime: localTransactionDateTime, transactionReference: transactionReference.optional(), fraudLiability: fraudLiability, clearingMode: z.literal("auto").optional(), authorizationIsoFields: authorizationIsoFieldsBancontact, billingAddress: componentsSchemasAddress.optional(), created: openapiComponentsSchemasCreated, lastModified: componentsSchemasLastModified.optional(), version: schemasVersion});

export const storedTokenDetailsDigitalWallet = z.object({type: z.enum(["apple-pay", "google-pay"]), eci: z.string().min(2).max(2).optional()});

export const storedTokenDetails = z.union([storedTokenDetailsNetwork, storedTokenDetailsDigitalWallet]);

export const fundingIntent = z.literal("funding");

export const fundingCardEntry = z.enum(["e-commerce", "token", "token-on-file", "card-on-file"]);

export const fundingOrder = z.enum(["checkout", "recurring", "ucof", "standing-order", "one-click"]);

export const fundingType = z.enum(["account-to-account", "general-funds-disbursement", "liquid-assets", "wallet-transfer", "person-to-person", "me-to-me", "me-to-me-debit-prepaid"]);

export const fundingChargeType = z.object({intent: fundingIntent, cardEntry: fundingCardEntry, order: fundingOrder, fundingType: fundingType});

export const accountNumberType = z.enum(["card-account", "iban-bank-account", "bic-bank-account", "rtn-bank-account", "email", "phone-number", "wallet-id", "social-network-id"]);

export const fundingReceiver = z.object({firstName: z.string().min(1).max(120), middleName: z.string().min(1).max(120).optional(), lastName: z.string().min(1).max(120), accountNumber: z.string().min(1).max(50), accountNumberType: accountNumberType, address: z.object({countryCode: schemasCountryCode, stateOrProvince: openapiComponentsSchemasStateOrProvince.optional(), city: openapiComponentsSchemasCity, line1: openapiComponentsSchemasLine1, line2: openapiComponentsSchemasLine2.optional(), postalCode: openapiComponentsSchemasPostalCode})});

export const fundingSender = z.object({firstName: z.string().min(1).max(120), middleName: z.string().min(1).max(120).optional(), lastName: z.string().min(1).max(120), accountNumber: z.string().min(1).max(50), accountNumberType: accountNumberType, address: z.object({countryCode: schemasCountryCode, stateOrProvince: openapiComponentsSchemasStateOrProvince.optional(), city: openapiComponentsSchemasCity, line1: openapiComponentsSchemasLine1, line2: openapiComponentsSchemasLine2.optional(), postalCode: openapiComponentsSchemasPostalCode})});

export const authorizationStatus = z.enum(["none", "approved", "approved-partial", "declined", "reversed"]);

export const status = z.object({authentication: authenticationStatus, authorization: authorizationStatus, clearing: clearingStatus});

export const result3DS = z.enum(["full-auth", "attempt"]);

export const fundingPayoutThreeDsAuthenticationResultResponse = z.object({type: result3DS, version: z.literal("2.2.0").optional(), directoryServerTransId: z.string().optional()});

export const fundingPayoutThreeDsAuthentication = z.object({method: method, compliance: z.enum(["mandated", "mit", "exemption"]), complianceReason: threeDsComplianceReason, result: fundingPayoutThreeDsAuthenticationResultResponse});

export const fundingPayoutSca = z.union([fundingPayoutThreeDsAuthentication, scaBEP, authenticationOutOfScope, authenticationExempt, scaMit]);

export const fundingPayoutChargeAuthentication = z.object({sca: fundingPayoutSca, cvc: cvcResult, avs: avsResult});

export const purposeOfPayment = z.string().min(1).max(12);

export const fundingCharge = z.object({key: chargeKey, merchantAcceptorRef: componentsSchemasAcceptorRef, card: outputCard, tokenDetails: storedTokenDetails.optional(), amount: componentsSchemasAmount, type: fundingChargeType, localTransactionDateTime: localTransactionDateTime, transactionReference: transactionReference.optional(), receiver: fundingReceiver, sender: fundingSender, riskCheckResult: riskCheckResult.optional(), fraudLiability: fraudLiability, status: status, authentication: fundingPayoutChargeAuthentication, clearingMode: z.literal("none").optional(), authorizationIsoFields: authorizationIsoFields, purposeOfPayment: purposeOfPayment.optional(), subMerchant: subMerchantResponse.optional(), created: openapiComponentsSchemasCreated, lastModified: componentsSchemasLastModified.optional(), version: schemasVersion});

export const payoutCardEntry = z.literal("e-commerce");

export const payoutOrder = z.literal("checkout");

export const payoutChargeType = z.object({intent: z.literal("payout"), cardEntry: payoutCardEntry, order: payoutOrder, payoutType: z.enum(["account-to-account", "fast-refund", "general-funds-disbursement", "liquid-assets", "merchant-disbursement", "online-gambling", "person-to-person", "wallet-transfer"])});

export const authorizationStatusWithoutPartialApproval = z.enum(["none", "approved", "declined", "reversed"]);

export const statusWithoutPartialApproval = z.object({authentication: authenticationStatus, authorization: authorizationStatusWithoutPartialApproval, clearing: clearingStatus});

export const payoutChargeAccountNumberType = z.enum(["card-account", "iban-bank-account", "bic-bank-account", "rtn-bank-account", "email", "phone-number", "wallet-id", "social-network-id", "other"]);

export const componentsSchemasCountryCodeAlpha3 = z.object({alpha3: schemasCountryCodeAlpha3});

export const componentsSchemasCountryCodeAlpha2 = z.object({alpha2: schemasCountryCodeAlpha2});

export const componentsSchemasCountryCodeNumeric = z.object({numeric: schemasCountryCodeNumeric});

export const payoutSender = z.object({firstName: z.string().min(1).max(120).optional(), middleName: z.string().min(1).max(120).optional(), lastName: z.string().min(1).max(120).optional(), accountNumber: z.string().min(1).max(50).optional(), accountNumberType: payoutChargeAccountNumberType.optional(), address: z.object({countryCode: z.union([componentsSchemasCountryCodeAlpha3, componentsSchemasCountryCodeAlpha2, componentsSchemasCountryCodeNumeric]), stateOrProvince: openapiComponentsSchemasStateOrProvince.optional(), city: openapiComponentsSchemasCity, line1: openapiComponentsSchemasLine1, line2: openapiComponentsSchemasLine2.optional(), postalCode: openapiComponentsSchemasPostalCode}).optional(), identification: z.object({type: z.enum(["date-of-birth", "national-identification", "passport-number", "driver-license", "tax-identification", "company-registration-number", "social-security-number", "other"]), value: z.string().min(1).max(35), issuingCountry: z.string().min(3).max(3).optional()}).optional()});

export const payoutReceiver = z.object({firstName: z.string().min(1).max(120).optional(), middleName: z.string().min(1).max(120).optional(), lastName: z.string().min(1).max(120).optional(), accountNumber: z.string().min(1).max(50).optional(), accountNumberType: payoutChargeAccountNumberType.optional(), address: z.object({countryCode: z.union([componentsSchemasCountryCodeAlpha3, componentsSchemasCountryCodeAlpha2, componentsSchemasCountryCodeNumeric]), stateOrProvince: openapiComponentsSchemasStateOrProvince.optional(), city: openapiComponentsSchemasCity, line1: openapiComponentsSchemasLine1, line2: openapiComponentsSchemasLine2.optional(), postalCode: openapiComponentsSchemasPostalCode}).optional(), identification: z.object({type: z.enum(["date-of-birth", "national-identification", "passport-number", "driver-license", "tax-identification", "company-registration-number", "social-security-number", "other"]), value: z.string().min(1).max(35), issuingCountry: z.string().min(3).max(3).optional()}).optional()});

export const payoutCharge = z.object({key: chargeKey, merchantAcceptorRef: componentsSchemasAcceptorRef, card: outputCard, amount: componentsSchemasAmount, type: payoutChargeType, clearingMode: clearingMode.optional(), status: statusWithoutPartialApproval, authentication: fundingPayoutChargeAuthentication, localTransactionDateTime: localTransactionDateTime, transactionReference: transactionReference.optional(), fraudLiability: z.enum(["acquirer", "issuer"]).optional(), authorizationIsoFields: authorizationIsoFields, sender: payoutSender, receiver: payoutReceiver.optional(), riskCheckResult: riskCheckResult.optional(), purposeOfPayment: purposeOfPayment.optional(), subMerchant: subMerchantResponse.optional(), created: openapiComponentsSchemasCreated, lastModified: componentsSchemasLastModified.optional(), version: schemasVersion});

export const responseAmountBreakdown = z.object({baseAmount: z.number().int().gte(1).lte(999999999999), cashback: z.number().int().gte(1).lte(999999999999).optional()});

export const intentPos = z.enum(["purchase", "reservation", "refund"]);

export const cardEntryPos = z.literal("terminal");

export const orderPos = z.literal("counter");

export const terminalEntryMode = z.enum(["contactless", "manual-entry", "chip", "magstripe", "magstripe-fallback"]);

export const sequencePos = z.literal("subsequent");

export const chargePosType = z.object({intent: intentPos, cardEntry: cardEntryPos, order: orderPos, terminalEntryMode: terminalEntryMode, sequence: sequencePos.optional()});

export const statusPos = z.object({authentication: z.literal("none"), authorization: z.enum(["none", "approved", "approved-partial", "declined", "reversed", "approved-purchase-amount-only"]), clearing: clearingStatus});

export const posAuthorizationIsoFields = z.object({responseCode: isoFieldResponseCode, responseCodeDescription: isoFieldResponseCodeDescription, authorizationCode: isoFieldAuthorizationCode.optional(), networkCode: isoFieldNetworkCode, systemTraceAuditNumber: isoFieldSystemTraceAuditNumber, retrievalReferenceNumber: isoFieldRetrievalReferenceNumber, eci: z.literal("00"), networkSpecificFields: z.union([visaSpecificFields, mastercardSpecificFields])});

export const terminalCapability = z.enum(["contactChip", "contactlessChip", "contactMagStripe", "contactlessMagStripe", "offlineEncipheredPin", "offlinePlaintextPin", "onlinePin", "signature", "keyEntry", "noCvm", "oneTap"]);

export const softPosTerminalCapability = z.enum(["contactlessChip", "onlinePin", "signature", "noCvm", "oneTap"]);

export const terminal = z.union([z.object({type: z.literal("pos"), id: z.string().min(1).max(8), attended: z.boolean(), capabilities: z.array(terminalCapability)}), z.object({type: z.literal("mpos"), id: z.string().min(1).max(8), attended: z.literal(true), capabilities: z.array(terminalCapability)}), z.object({type: z.literal("softpos"), id: z.string().min(1).max(8), attended: z.literal(true), capabilities: z.array(softPosTerminalCapability)})]);

export const pointOfSaleAddress = z.object({countryCode: schemasCountryCode, stateOrProvince: openapiComponentsSchemasStateOrProvince.optional(), city: openapiComponentsSchemasCity, line1: openapiComponentsSchemasLine1, line2: openapiComponentsSchemasLine2.optional(), postalCode: openapiComponentsSchemasPostalCode});

export const posCharge = z.object({key: chargeKey, merchantAcceptorRef: componentsSchemasAcceptorRef, card: outputCard, amount: z.object({value: z.number().int().gte(1).lte(999999999999), currency: commonCurrencyCode, breakdown: responseAmountBreakdown.optional()}), type: chargePosType, status: statusPos, localTransactionDateTime: localTransactionDateTime, transactionReference: transactionReference.optional(), authorizationIsoFields: posAuthorizationIsoFields, clearingMode: clearingMode.optional(), clearAfter: clearAfter.optional(), terminal: terminal, subMerchant: subMerchantResponse.optional(), pointOfSaleAddress: pointOfSaleAddress.optional(), created: openapiComponentsSchemasCreated, lastModified: componentsSchemasLastModified.optional(), version: schemasVersion});

export const schemasRecurringExpiry = z.string();

export const schemasRecurringFrequency = z.number().int().gte(1);

export const initialChargeKey = z.string().min(5).max(120);

export const mitChargeFromInitialCharge = z.object({key: chargeKey, refundedChargeKey: refundedChargeKey.optional(), merchantAcceptorRef: componentsSchemasAcceptorRef, card: outputCard, tokenDetails: storedChargeTokenDetails.optional(), amount: componentsSchemasAmount, cardholderBillingAmount: cardholderBillingAmount.optional(), type: getResponseChargeType, clearingMode: clearingMode.optional(), status: chargeStatus, authentication: chargeAuthentication, localTransactionDateTime: localTransactionDateTime, transactionType: transactionType.optional(), transactionReference: z.string().min(1).max(120).optional(), fraudLiability: fraudLiability, authorizationIsoFields: authorizationIsoFields, billingAddress: billingAddress.optional(), shippingAddress: componentsSchemasAddress.optional(), clearAfter: clearAfter.optional(), dynamicDescriptor: schemasDynamicDescriptor.optional(), foreignRetailer: schemasForeignRetailer.optional(), subMerchant: subMerchantResponse.optional(), riskCheckResult: riskCheckResult.optional(), created: openapiComponentsSchemasCreated, lastModified: componentsSchemasLastModified.optional(), version: schemasVersion, recurringExpiry: schemasRecurringExpiry.optional(), recurringFrequency: schemasRecurringFrequency.optional(), initialChargeKey: initialChargeKey.optional()});

export const mitChargeIntent = z.enum(["purchase", "reservation", "account-status"]);

export const mitCardEntry = z.enum(["card-on-file", "token-on-file"]);

export const mitChargeOrder = z.enum(["recurring", "ucof", "installment", "standing-order"]);

export const mitResponseChargeType = z.object({intent: mitChargeIntent, cardEntry: mitCardEntry, order: mitChargeOrder, sequence: z.literal("subsequent").optional()});

export const chargeAuthenticationMit = z.object({sca: sca, cvc: z.literal("none"), avs: avsResult});

export const mitCharge = z.object({key: chargeKey, merchantAcceptorRef: componentsSchemasAcceptorRef, card: outputCard, amount: componentsSchemasAmount, type: mitResponseChargeType, status: status, authentication: chargeAuthenticationMit, localTransactionDateTime: localTransactionDateTime, authorizationIsoFields: authorizationIsoFields, transactionType: transactionType.optional(), transactionReference: transactionReference.optional(), clearingMode: clearingMode.optional(), clearAfter: clearAfter.optional(), dynamicDescriptor: schemasDynamicDescriptor.optional(), subMerchant: subMerchantResponse.optional(), lastModified: componentsSchemasLastModified.optional(), created: openapiComponentsSchemasCreated, version: schemasVersion});

export const mitChargeTypeFunding = z.object({intent: z.literal("funding"), cardEntry: z.enum(["card-on-file", "token-on-file"]), order: z.enum(["recurring", "ucof", "standing-order"]), sequence: z.literal("subsequent"), fundingType: z.enum(["account-to-account", "general-funds-disbursement", "liquid-assets", "wallet-transfer", "person-to-person", "me-to-me", "me-to-me-debit-prepaid"])});

export const mitFundingThreeDsAuthenticationResultResponse = z.object({directoryServerTransId: z.string().optional()});

export const mitFundingThreeDsAuthentication = z.object({method: method, compliance: z.enum(["mandated", "mit", "exemption"]), complianceReason: threeDsComplianceReason, result: mitFundingThreeDsAuthenticationResultResponse});

export const mitFundingSca = z.union([mitFundingThreeDsAuthentication, scaBEP, authenticationOutOfScope, authenticationExempt, scaMit]);

export const mitFundingChargeAuthentication = z.object({sca: mitFundingSca, cvc: cvcResult, avs: avsResult});

export const mitFundingCharge = z.object({key: chargeKey, merchantAcceptorRef: componentsSchemasAcceptorRef, card: outputCard, tokenDetails: storedTokenDetails.optional(), amount: componentsSchemasAmount, type: mitChargeTypeFunding, localTransactionDateTime: localTransactionDateTime, transactionReference: transactionReference.optional(), receiver: fundingReceiver, sender: fundingSender, riskCheckResult: riskCheckResult.optional(), fraudLiability: fraudLiability, status: status, authentication: mitFundingChargeAuthentication, clearingMode: z.literal("none").optional(), authorizationIsoFields: authorizationIsoFields, purposeOfPayment: purposeOfPayment.optional(), subMerchant: subMerchantResponse.optional(), created: openapiComponentsSchemasCreated, lastModified: componentsSchemasLastModified.optional(), version: schemasVersion});

export const charge = z.union([genericCharge, atmCharge, bepCharge, fundingCharge, payoutCharge, posCharge, mitChargeFromInitialCharge, mitCharge, mitFundingCharge]);

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * Get Charge
 * 
 * GET /charges/{chargeKey}
 * 
 * Also accepts auth: BearerToken
 */
export const getApiChargesChargeKey = async (args: GetApiChargesChargeKeyArgs, options?: GetApiChargesChargeKeyOptions) => {
const {baseUrl = "https://eu-west-1.api.silverflow.com/v1", fetch: fetchFn = fetch, ApiKey} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('accept', "application/json")

if (ApiKey !== undefined) headers.set('authorization', `Basic ${btoa(`${ApiKey.username}:${ApiKey.password}`)}`)

const url = `${baseUrl.replace(/\/+$/, '')}/charges/${encodeURIComponent(String(args.chargeKey))}${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "GET", headers})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(charge, await res.json())
};